clock_gettime(CLOCK_PROCESS_CPUTIME_ID, start);
}
-static u_int64_t end_timing(struct timespec *start)
+static uint64_t end_timing(struct timespec *start)
{
struct timespec end;
static int intcmp(const void *a, const void *b)
{
- return *(u_int64_t*)a - *(u_int64_t*)b;
+ return *(uint64_t*)a - *(uint64_t*)b;
}
-static u_int64_t median(u_int64_t *m, int count)
+static uint64_t median(uint64_t *m, int count)
{
- qsort(m, count, sizeof(u_int64_t), intcmp);
+ qsort(m, count, sizeof(uint64_t), intcmp);
return m[count / 2];
}
{
struct timespec start;
u_char test[dlen];
- u_int64_t mini, maxi, t[256], m[256][10];
+ uint64_t mini, maxi, t[256], m[256][10];
float fastdist = 0, slowdist = 0;
int i, j, k, l, byte, limit, retry = 0;
int fastest = 0, slowest = 0;
{
ike_cfg_t *ike_cfg;
peer_cfg_t *peer_cfg;
- u_int16_t local_port, remote_port = IKEV2_UDP_PORT;
+ uint16_t local_port, remote_port = IKEV2_UDP_PORT;
ike_version_t version = IKE_ANY;
bool aggressive = FALSE;
proposal_t *proposal;
array = g_array_new (FALSE, TRUE, sizeof (guint32));
while (enumerator->enumerate(enumerator, &chunk))
{
- g_array_append_val (array, *(u_int32_t*)chunk.ptr);
+ g_array_append_val (array, *(uint32_t*)chunk.ptr);
}
enumerator->destroy(enumerator);
val = g_slice_new0 (GValue);
enumerator->destroy(enumerator);
val = g_slice_new0(GValue);
g_value_init(val, G_TYPE_UINT);
- g_value_set_uint(val, *(u_int32_t*)me->get_address(me).ptr);
+ g_value_set_uint(val, *(uint32_t*)me->get_address(me).ptr);
g_hash_table_insert(config, NM_VPN_PLUGIN_IP4_CONFIG_ADDRESS, val);
val = g_slice_new0(GValue);
int count, i;
char *iana_id_str, *tkm_id_str;
diffie_hellman_group_t *iana_id;
- u_int64_t *tkm_id;
+ uint64_t *tkm_id;
hashtable_t *map;
enumerator_t *enumerator;
{
iana_id = malloc_thing(diffie_hellman_group_t);
*iana_id = settings_value_as_int(iana_id_str, 0);
- tkm_id = malloc_thing(u_int64_t);
+ tkm_id = malloc_thing(uint64_t);
*tkm_id = settings_value_as_int(tkm_id_str, 0);
map->put(map, iana_id, tkm_id);
return NULL;
}
- u_int64_t *dha_id = group_map->get(group_map, &group);
+ uint64_t *dha_id = group_map->get(group_map, &group);
if (!dha_id)
{
free(this);
METHOD(kernel_ipsec_t, get_spi, status_t,
private_tkm_kernel_ipsec_t *this, host_t *src, host_t *dst,
- u_int8_t protocol, u_int32_t *spi)
+ uint8_t protocol, uint32_t *spi)
{
bool result;
}
}
- result = this->rng->get_bytes(this->rng, sizeof(u_int32_t),
- (u_int8_t *)spi);
+ result = this->rng->get_bytes(this->rng, sizeof(uint32_t),
+ (uint8_t *)spi);
return result ? SUCCESS : FAILED;
}
METHOD(kernel_ipsec_t, get_cpi, status_t,
private_tkm_kernel_ipsec_t *this, host_t *src, host_t *dst,
- u_int16_t *cpi)
+ uint16_t *cpi)
{
return NOT_SUPPORTED;
}
METHOD(kernel_ipsec_t, add_sa, status_t,
private_tkm_kernel_ipsec_t *this, host_t *src, host_t *dst,
- u_int32_t spi, u_int8_t protocol, u_int32_t reqid, mark_t mark,
- u_int32_t tfc, lifetime_cfg_t *lifetime, u_int16_t enc_alg, chunk_t enc_key,
- u_int16_t int_alg, chunk_t int_key, ipsec_mode_t mode,
- u_int16_t ipcomp, u_int16_t cpi, u_int32_t replay_window,
+ uint32_t spi, uint8_t protocol, uint32_t reqid, mark_t mark,
+ uint32_t tfc, lifetime_cfg_t *lifetime, uint16_t enc_alg, chunk_t enc_key,
+ uint16_t int_alg, chunk_t int_key, ipsec_mode_t mode,
+ uint16_t ipcomp, uint16_t cpi, uint32_t replay_window,
bool initiator, bool encap, bool esn, bool inbound, bool update,
linked_list_t* src_ts, linked_list_t* dst_ts)
{
METHOD(kernel_ipsec_t, query_sa, status_t,
private_tkm_kernel_ipsec_t *this, host_t *src, host_t *dst,
- u_int32_t spi, u_int8_t protocol, mark_t mark, u_int64_t *bytes,
- u_int64_t *packets, time_t *time)
+ uint32_t spi, uint8_t protocol, mark_t mark, uint64_t *bytes,
+ uint64_t *packets, time_t *time)
{
return NOT_SUPPORTED;
}
METHOD(kernel_ipsec_t, del_sa, status_t,
private_tkm_kernel_ipsec_t *this, host_t *src, host_t *dst,
- u_int32_t spi, u_int8_t protocol, u_int16_t cpi, mark_t mark)
+ uint32_t spi, uint8_t protocol, uint16_t cpi, mark_t mark)
{
esa_id_type esa_id, other_esa_id;
}
METHOD(kernel_ipsec_t, update_sa, status_t,
- private_tkm_kernel_ipsec_t *this, u_int32_t spi, u_int8_t protocol,
- u_int16_t cpi, host_t *src, host_t *dst, host_t *new_src, host_t *new_dst,
+ private_tkm_kernel_ipsec_t *this, uint32_t spi, uint8_t protocol,
+ uint16_t cpi, host_t *src, host_t *dst, host_t *new_src, host_t *new_dst,
bool old_encap, bool new_encap, mark_t mark)
{
return NOT_SUPPORTED;
}
METHOD(kernel_ipsec_t, enable_udp_decap, bool,
- private_tkm_kernel_ipsec_t *this, int fd, int family, u_int16_t port)
+ private_tkm_kernel_ipsec_t *this, int fd, int family, uint16_t port)
{
int type = UDP_ENCAP_ESPINUDP;
/**
* Reqid.
*/
- u_int32_t reqid;
+ uint32_t reqid;
/**
* Source address of CHILD SA.
/**
* Local SPI of CHILD SA.
*/
- u_int32_t spi_loc;
+ uint32_t spi_loc;
/**
* Remote SPI of CHILD SA.
*/
- u_int32_t spi_rem;
+ uint32_t spi_rem;
/**
* Protocol of CHILD SA (ESP/AH).
*/
- u_int8_t proto;
+ uint8_t proto;
};
* Find a list entry with given src, dst, (remote) spi and proto values.
*/
static bool sad_entry_match(sad_entry_t * const entry, const host_t * const src,
- const host_t * const dst, const u_int32_t * const spi,
- const u_int8_t * const proto)
+ const host_t * const dst, const uint32_t * const spi,
+ const uint8_t * const proto)
{
if (entry->src == NULL || entry->dst == NULL)
{
* Find a list entry with given reqid, spi and proto values.
*/
static bool sad_entry_match_dst(sad_entry_t * const entry,
- const u_int32_t * const reqid,
- const u_int32_t * const spi,
- const u_int8_t * const proto)
+ const uint32_t * const reqid,
+ const uint32_t * const spi,
+ const uint8_t * const proto)
{
return entry->reqid == *reqid &&
entry->spi_rem == *spi &&
*/
static bool sad_entry_match_other_esa(sad_entry_t * const entry,
const esa_id_type * const esa_id,
- const u_int32_t * const reqid)
+ const uint32_t * const reqid)
{
return entry->reqid == *reqid &&
entry->esa_id != *esa_id;
METHOD(tkm_kernel_sad_t, insert, bool,
private_tkm_kernel_sad_t * const this, const esa_id_type esa_id,
- const u_int32_t reqid, const host_t * const src, const host_t * const dst,
- const u_int32_t spi_loc, const u_int32_t spi_rem, const u_int8_t proto)
+ const uint32_t reqid, const host_t * const src, const host_t * const dst,
+ const uint32_t spi_loc, const uint32_t spi_rem, const uint8_t proto)
{
status_t result;
sad_entry_t *new_entry;
METHOD(tkm_kernel_sad_t, get_esa_id, esa_id_type,
private_tkm_kernel_sad_t * const this, const host_t * const src,
- const host_t * const dst, const u_int32_t spi, const u_int8_t proto)
+ const host_t * const dst, const uint32_t spi, const uint8_t proto)
{
esa_id_type id = 0;
sad_entry_t *entry = NULL;
{
esa_id_type id = 0;
sad_entry_t *entry = NULL;
- u_int32_t reqid;
+ uint32_t reqid;
status_t res;
this->mutex->lock(this->mutex);
}
METHOD(tkm_kernel_sad_t, get_dst_host, host_t *,
- private_tkm_kernel_sad_t * const this, const u_int32_t reqid,
- const u_int32_t spi, const u_int8_t proto)
+ private_tkm_kernel_sad_t * const this, const uint32_t reqid,
+ const uint32_t spi, const uint8_t proto)
{
host_t *dst = NULL;
sad_entry_t *entry = NULL;
* @return TRUE if entry was inserted, FALSE otherwise
*/
bool (*insert)(tkm_kernel_sad_t * const this, const esa_id_type esa_id,
- const u_int32_t reqid, const host_t * const src,
- const host_t * const dst, const u_int32_t spi_loc,
- const u_int32_t spi_rem, const u_int8_t proto);
+ const uint32_t reqid, const host_t * const src,
+ const host_t * const dst, const uint32_t spi_loc,
+ const uint32_t spi_rem, const uint8_t proto);
/**
* Get ESA id for entry with given parameters.
*/
esa_id_type (*get_esa_id)(tkm_kernel_sad_t * const this,
const host_t * const src, const host_t * const dst,
- const u_int32_t spi, const u_int8_t proto);
+ const uint32_t spi, const uint8_t proto);
/**
* Get ESA id for entry associated with same security policy as the
* @return destination host of entry if found, NULL otherwise
*/
host_t * (*get_dst_host)(tkm_kernel_sad_t * const this,
- const u_int32_t reqid, const u_int32_t spi, const u_int8_t proto);
+ const uint32_t reqid, const uint32_t spi, const uint8_t proto);
/**
* Remove entry with given ESA id from SAD.
static void aead_create_from_keys(aead_t **in, aead_t **out,
const chunk_t * const sk_ai, const chunk_t * const sk_ar,
const chunk_t * const sk_ei, const chunk_t * const sk_er,
- const u_int16_t enc_alg, const u_int16_t int_alg,
- const u_int16_t key_size, bool initiator)
+ const uint16_t enc_alg, const uint16_t int_alg,
+ const uint16_t key_size, bool initiator)
{
*in = *out = NULL;
signer_t *signer_i, *signer_r;
chunk_t nonce_i, chunk_t nonce_r, ike_sa_id_t *id,
pseudo_random_function_t rekey_function, chunk_t rekey_skd)
{
- u_int16_t enc_alg, int_alg, key_size;
- u_int64_t nc_id, spi_loc, spi_rem;
+ uint16_t enc_alg, int_alg, key_size;
+ uint64_t nc_id, spi_loc, spi_rem;
chunk_t *nonce, c_ai, c_ar, c_ei, c_er;
tkm_diffie_hellman_t *tkm_dh;
dh_id_type dh_id;
};
METHOD(nonce_gen_t, get_nonce, bool,
- private_tkm_nonceg_t *this, size_t size, u_int8_t *buffer)
+ private_tkm_nonceg_t *this, size_t size, uint8_t *buffer)
{
nonce_type nonce;
uint64_t nc_id;
*/
typedef struct {
rng_t *rng;
- u_int64_t spi_mask;
- u_int64_t spi_label;
+ uint64_t spi_mask;
+ uint64_t spi_label;
} get_spi_args_t;
static get_spi_args_t *spi_args;
* @param this Callback args containing rng_t and spi mask & label
* @return labeled SPI
*/
-CALLBACK(tkm_get_spi, u_int64_t,
+CALLBACK(tkm_get_spi, uint64_t,
const get_spi_args_t const *this)
{
- u_int64_t spi;
+ uint64_t spi;
- if (!this->rng->get_bytes(this->rng, sizeof(spi), (u_int8_t*)&spi))
+ if (!this->rng->get_bytes(this->rng, sizeof(spi), (uint8_t*)&spi))
{
return 0;
}
plugin_feature_t *feature,
bool reg, void *cb_data)
{
- u_int64_t spi_mask, spi_label;
+ uint64_t spi_mask, spi_label;
char *spi_val;
rng_t *rng;
tkm_nonceg_t *ng = tkm_nonceg_create();
const size_t length = 256;
- u_int8_t zero[length];
+ uint8_t zero[length];
memset(zero, 0, length);
chunk_t nonce;
tkm_nonceg_t *ng = tkm_nonceg_create();
const size_t length = 128;
- u_int8_t zero[length];
+ uint8_t zero[length];
memset(zero, 0, length);
- u_int8_t *buf = malloc(length + 1);
+ uint8_t *buf = malloc(length + 1);
memset(buf, 0, length);
/* set end marker */
buf[length] = 255;
static void build_checksum(char *path, char *name, char *sname)
{
void *handle, *symbol;
- u_int32_t fsum, ssum;
+ uint32_t fsum, ssum;
size_t fsize = 0;
size_t ssize = 0;
enumerator_t *enumerator, *children;
ike_sa_t *ike_sa;
child_sa_t *child_sa;
- u_int32_t spi, proto;
+ uint32_t spi, proto;
host_t *dst = NULL;
enumerator = charon->controller->create_ike_sa_enumerator(
traffic_selector_t *ts;
ipsec_mode_t mode = MODE_TUNNEL;
char *token;
- u_int32_t tfc;
+ uint32_t tfc;
if (settings->get_bool(settings, "configs.%s.%s.transport",
FALSE, config, child))
* Load custom proposal configuration to proposal list
*/
static linked_list_t* load_proposals(private_custom_proposal_t *this,
- protocol_id_t proto, u_int64_t spi)
+ protocol_id_t proto, uint64_t spi)
{
enumerator_t *props, *algs;
char *number, *key, *value;
{
const proposal_token_t *token = NULL;
proposal_t *proposal;
- u_int16_t type, alg, keysize = 0;
+ uint16_t type, alg, keysize = 0;
char *end;
proposal = proposal_create(proto, atoi(number));
proposals = list->create_enumerator(list);
while (proposals->enumerate(proposals, &proposal))
{
- u_int64_t spi = proposal->get_spi(proposal);
+ uint64_t spi = proposal->get_spi(proposal);
if (proposal->get_protocol(proposal) != PROTO_IKE)
{
char reserved[3];
generator_t *generator;
chunk_t data;
- u_int32_t *lenpos;
+ uint32_t *lenpos;
payload = message->get_payload(message,
message->get_request(message) ? PLV2_ID_INITIATOR : PLV2_ID_RESPONDER);
* Schedule sequence number reset job
*/
static void schedule_reset_job(private_reset_seq_t *this, host_t *dst,
- u_int32_t spi)
+ uint32_t spi)
{
struct reset_cb_data_t *data;
chunk_t chunk;
/**
* Initiator SPI
*/
- u_int64_t spii;
+ uint64_t spii;
/**
* Responder SPI
*/
- u_int64_t spir;
+ uint64_t spir;
};
METHOD(listener_t, message, bool,
if (type == payload->get_type(payload))
{
encoding_rule_t *rules;
- u_int16_t *len;
+ uint16_t *len;
int i, count;
count = payload->get_encoding_rules(payload, &rules);
{
if (rules[i].type == PAYLOAD_LENGTH)
{
- len = (u_int16_t*)(((void*)payload) + rules[i].offset);
+ len = (uint16_t*)(((void*)payload) + rules[i].offset);
DBG1(DBG_CFG, "adjusting length of %N payload "
"from %d to %d", payload_type_short_names, type,
*len, *len + this->diff);
transform_type_t type)
{
enumerator_t *enumerator;
- u_int16_t alg, key_size;
+ uint16_t alg, key_size;
enumerator = from->create_enumerator(from, type);
while (enumerator->enumerate(enumerator, &alg, &key_size))
* Set reserved byte of a payload
*/
static void set_byte(private_set_reserved_t *this, message_t *message,
- payload_type_t type, u_int nr, u_int8_t byteval)
+ payload_type_t type, u_int nr, uint8_t byteval)
{
enumerator_t *payloads;
payload_t *payload;
- u_int8_t *byte;
+ uint8_t *byte;
if (type == PLV2_TRANSFORM_SUBSTRUCTURE || type == PLV2_PROPOSAL_SUBSTRUCTURE)
{
enumerator_t *bits, *bytes, *types;
payload_type_t type;
char *nr, *name;
- u_int8_t byteval;
+ uint8_t byteval;
types = conftest->test->create_section_enumerator(conftest->test,
"hooks.%s", this->name);
typedef struct mconsole_request mconsole_request;
/** mconsole request message */
struct mconsole_request {
- u_int32_t magic;
- u_int32_t version;
- u_int32_t len;
+ uint32_t magic;
+ uint32_t version;
+ uint32_t len;
char data[MCONSOLE_MAX_DATA];
};
typedef struct mconsole_reply mconsole_reply;
/** mconsole reply message */
struct mconsole_reply {
- u_int32_t err;
- u_int32_t more;
- u_int32_t len;
+ uint32_t err;
+ uint32_t more;
+ uint32_t len;
char data[MCONSOLE_MAX_DATA];
};
typedef struct mconsole_notify mconsole_notify;
/** mconsole notify message */
struct mconsole_notify {
- u_int32_t magic;
- u_int32_t version;
+ uint32_t magic;
+ uint32_t version;
enum {
MCONSOLE_SOCKET,
MCONSOLE_PANIC,
MCONSOLE_HANG,
MCONSOLE_USER_NOTIFY,
} type;
- u_int32_t len;
+ uint32_t len;
char data[MCONSOLE_MAX_DATA];
};
*/
static u_int socket_hash(host_t *src)
{
- u_int16_t port = src->get_port(src);
+ uint16_t port = src->get_port(src);
return chunk_hash_inc(src->get_address(src),
chunk_hash(chunk_from_thing(port)));
}
* DNS header and masks to access flags
*/
typedef struct __attribute__((packed)) {
- u_int16_t id;
- u_int16_t flags;
+ uint16_t id;
+ uint16_t flags;
#define DNS_QR_MASK 0x8000
#define DNS_OPCODE_MASK 0x7800
- u_int16_t qdcount;
- u_int16_t ancount;
- u_int16_t nscount;
- u_int16_t arcount;
+ uint16_t qdcount;
+ uint16_t ancount;
+ uint16_t nscount;
+ uint16_t arcount;
} dns_header_t;
/**
static char *extract_hostname(chunk_t data)
{
char *hostname, *pos, *end;
- u_int8_t label;
+ uint8_t label;
if (!data.len || data.len > 255)
{
* Add a route to the TUN device builder
*/
static bool add_route(vpnservice_builder_t *builder, host_t *net,
- u_int8_t prefix)
+ uint8_t prefix)
{
/* if route is 0.0.0.0/0, split it into two routes 0.0.0.0/1 and
* 128.0.0.0/1 because otherwise it would conflict with the current default
while (success && enumerator->enumerate(enumerator, &src_ts, &dst_ts))
{
host_t *net;
- u_int8_t prefix;
+ uint8_t prefix;
dst_ts->to_subnet(dst_ts, &net, &prefix);
success = add_route(builder, net, prefix);
* Terminate the IKE_SA with the given unique ID
*/
CALLBACK(terminate, job_requeue_t,
- u_int32_t *id)
+ uint32_t *id)
{
charon->controller->terminate_ike(charon->controller, *id,
controller_cb_empty, NULL, 0);
* Reestablish the IKE_SA with the given unique ID
*/
CALLBACK(reestablish, job_requeue_t,
- u_int32_t *id)
+ uint32_t *id)
{
ike_sa_t *ike_sa;
break;
case ALERT_KEEP_ON_CHILD_SA_FAILURE:
{
- u_int32_t *id = malloc_thing(u_int32_t);
+ uint32_t *id = malloc_thing(uint32_t);
/* because close_ike_on_child_failure is set this is only
* triggered when CHILD_SA rekeying failed. reestablish it in
this->lock->read_lock(this->lock);
if (this->tunfd < 0)
{
- u_int32_t *id = malloc_thing(u_int32_t);
+ uint32_t *id = malloc_thing(uint32_t);
/* always fail if we are not able to initiate the IKE_SA
* initially */
else
{
peer_cfg_t *peer_cfg;
- u_int32_t tries, try;
+ uint32_t tries, try;
/* when reestablishing and if keyingtries is not %forever
* the IKE_SA is destroyed after the set number of tries,
* so notify the GUI */
peer_cfg = ike_sa->get_peer_cfg(ike_sa);
tries = peer_cfg->get_keyingtries(peer_cfg);
- try = va_arg(args, u_int32_t);
+ try = va_arg(args, uint32_t);
if (tries != 0 && try == tries-1)
{
charonservice->update_status(charonservice,
tcg_pts_attr_req_file_meas_t *attr_cast;
pts_file_meas_t *measurements;
pts_error_code_t pts_error;
- u_int32_t delim;
- u_int16_t req_id;
+ uint32_t delim;
+ uint16_t req_id;
bool is_dir;
char *path;
/**
* Maximum PA-TNC message size for this TNCCS connection
*/
- u_int32_t max_msg_len;
+ uint32_t max_msg_len;
/**
* PA-TNC attribute segmentation contracts associated with TNCCS connection
}
METHOD(imc_state_t, set_max_msg_len, void,
- private_imc_android_state_t *this, u_int32_t max_msg_len)
+ private_imc_android_state_t *this, uint32_t max_msg_len)
{
this->max_msg_len = max_msg_len;
}
-METHOD(imc_state_t, get_max_msg_len, u_int32_t,
+METHOD(imc_state_t, get_max_msg_len, uint32_t,
private_imc_android_state_t *this)
{
return this->max_msg_len;
/**
* Callback registrered with libipsec.
*/
-static void expire(u_int8_t protocol, u_int32_t spi, host_t *dst, bool hard)
+static void expire(uint8_t protocol, uint32_t spi, host_t *dst, bool hard)
{
charon->kernel->expire(charon->kernel, protocol, spi, dst, hard);
}
METHOD(kernel_ipsec_t, get_spi, status_t,
private_kernel_android_ipsec_t *this, host_t *src, host_t *dst,
- u_int8_t protocol, u_int32_t *spi)
+ uint8_t protocol, uint32_t *spi)
{
return ipsec->sas->get_spi(ipsec->sas, src, dst, protocol, spi);
}
METHOD(kernel_ipsec_t, get_cpi, status_t,
private_kernel_android_ipsec_t *this, host_t *src, host_t *dst,
- u_int16_t *cpi)
+ uint16_t *cpi)
{
return NOT_SUPPORTED;
}
METHOD(kernel_ipsec_t, add_sa, status_t,
private_kernel_android_ipsec_t *this, host_t *src, host_t *dst,
- u_int32_t spi, u_int8_t protocol, u_int32_t reqid, mark_t mark,
- u_int32_t tfc, lifetime_cfg_t *lifetime, u_int16_t enc_alg, chunk_t enc_key,
- u_int16_t int_alg, chunk_t int_key, ipsec_mode_t mode,
- u_int16_t ipcomp, u_int16_t cpi, u_int32_t replay_window,
+ uint32_t spi, uint8_t protocol, uint32_t reqid, mark_t mark,
+ uint32_t tfc, lifetime_cfg_t *lifetime, uint16_t enc_alg, chunk_t enc_key,
+ uint16_t int_alg, chunk_t int_key, ipsec_mode_t mode,
+ uint16_t ipcomp, uint16_t cpi, uint32_t replay_window,
bool initiator, bool encap, bool esn, bool inbound, bool update,
linked_list_t *src_ts, linked_list_t *dst_ts)
{
}
METHOD(kernel_ipsec_t, update_sa, status_t,
- private_kernel_android_ipsec_t *this, u_int32_t spi, u_int8_t protocol,
- u_int16_t cpi, host_t *src, host_t *dst, host_t *new_src, host_t *new_dst,
+ private_kernel_android_ipsec_t *this, uint32_t spi, uint8_t protocol,
+ uint16_t cpi, host_t *src, host_t *dst, host_t *new_src, host_t *new_dst,
bool encap, bool new_encap, mark_t mark)
{
return ipsec->sas->update_sa(ipsec->sas, spi, protocol, cpi, src, dst,
METHOD(kernel_ipsec_t, query_sa, status_t,
private_kernel_android_ipsec_t *this, host_t *src, host_t *dst,
- u_int32_t spi, u_int8_t protocol, mark_t mark,
- u_int64_t *bytes, u_int64_t *packets, time_t *time)
+ uint32_t spi, uint8_t protocol, mark_t mark,
+ uint64_t *bytes, uint64_t *packets, time_t *time)
{
return ipsec->sas->query_sa(ipsec->sas, src, dst, spi, protocol, mark,
bytes, packets, time);
METHOD(kernel_ipsec_t, del_sa, status_t,
private_kernel_android_ipsec_t *this, host_t *src, host_t *dst,
- u_int32_t spi, u_int8_t protocol, u_int16_t cpi, mark_t mark)
+ uint32_t spi, uint8_t protocol, uint16_t cpi, mark_t mark)
{
return ipsec->sas->del_sa(ipsec->sas, src, dst, spi, protocol, cpi, mark);
}
}
METHOD(kernel_ipsec_t, enable_udp_decap, bool,
- private_kernel_android_ipsec_t *this, int fd, int family, u_int16_t port)
+ private_kernel_android_ipsec_t *this, int fd, int family, uint16_t port)
{
return NOT_SUPPORTED;
}
}
METHOD(kernel_net_t, add_route, status_t,
- private_android_net_t *this, chunk_t dst_net, u_int8_t prefixlen,
+ private_android_net_t *this, chunk_t dst_net, uint8_t prefixlen,
host_t *gateway, host_t *src_ip, char *if_name)
{
return NOT_SUPPORTED;
}
METHOD(kernel_net_t, del_route, status_t,
- private_android_net_t *this, chunk_t dst_net, u_int8_t prefixlen,
+ private_android_net_t *this, chunk_t dst_net, uint8_t prefixlen,
host_t *gateway, host_t *src_ip, char *if_name)
{
return NOT_SUPPORTED;
/**
* Find an IKE_SA unique identifier by a given XPC channel
*/
-static u_int32_t find_ike_sa_by_conn(private_xpc_channels_t *this,
+static uint32_t find_ike_sa_by_conn(private_xpc_channels_t *this,
xpc_connection_t conn)
{
enumerator_t *enumerator;
entry_t *entry;
- u_int32_t ike_sa = 0;
+ uint32_t ike_sa = 0;
this->lock->read_lock(this->lock);
enumerator = this->channels->create_enumerator(this->channels);
/**
* Trigger termination of a connection
*/
-static void stop_connection(private_xpc_channels_t *this, u_int32_t ike_sa,
+static void stop_connection(private_xpc_channels_t *this, uint32_t ike_sa,
xpc_object_t request, xpc_object_t reply)
{
status_t status;
*/
static struct {
char *name;
- void (*handler)(private_xpc_channels_t *this, u_int32_t ike_sa,
+ void (*handler)(private_xpc_channels_t *this, uint32_t ike_sa,
xpc_object_t request, xpc_object_t reply);
} commands[] = {
{ "stop_connection", stop_connection },
xpc_object_t reply;
const char *type, *rpc;
bool found = FALSE;
- u_int32_t ike_sa;
+ uint32_t ike_sa;
int i;
type = xpc_dictionary_get_string(request, "type");
}
METHOD(xpc_channels_t, add, void,
- private_xpc_channels_t *this, xpc_connection_t conn, u_int32_t ike_sa)
+ private_xpc_channels_t *this, xpc_connection_t conn, uint32_t ike_sa)
{
entry_t *entry;
shared_key_t *shared = NULL;
ike_sa_t *ike_sa;
entry_t *entry;
- u_int32_t sa;
+ uint32_t sa;
switch (type)
{
* @param conn XPC connection to channel
* @param ike_sa IKE_SA unique identifier to associate to connection
*/
- void (*add)(xpc_channels_t *this, xpc_connection_t conn, u_int32_t ike_sa);
+ void (*add)(xpc_channels_t *this, xpc_connection_t conn, uint32_t ike_sa);
/**
* Destroy a xpc_channels_t.
{
ike_cfg_t *ike_cfg;
peer_cfg_t *peer_cfg;
- u_int16_t local_port, remote_port = IKEV2_UDP_PORT;
+ uint16_t local_port, remote_port = IKEV2_UDP_PORT;
local_port = charon->socket->get_port(charon->socket, FALSE);
if (local_port != IKEV2_UDP_PORT)
/**
* Controller initiate callback
*/
-static bool initiate_cb(u_int32_t *sa, debug_t group, level_t level,
+static bool initiate_cb(uint32_t *sa, debug_t group, level_t level,
ike_sa_t *ike_sa, const char *message)
{
if (ike_sa)
bool success = FALSE;
xpc_endpoint_t endpoint;
xpc_connection_t channel;
- u_int32_t ike_sa;
+ uint32_t ike_sa;
name = (char*)xpc_dictionary_get_string(request, "name");
host = (char*)xpc_dictionary_get_string(request, "host");
/**
* IKE_SA we log for
*/
- u_int32_t ike_sa;
+ uint32_t ike_sa;
};
METHOD(logger_t, log_, void,
}
METHOD(xpc_logger_t, set_ike_sa, void,
- private_xpc_logger_t *this, u_int32_t ike_sa)
+ private_xpc_logger_t *this, uint32_t ike_sa)
{
this->ike_sa = ike_sa;
}
*
* @param ike_sa IKE_SA unique identifier
*/
- void (*set_ike_sa)(xpc_logger_t *this, u_int32_t ike_sa);
+ void (*set_ike_sa)(xpc_logger_t *this, uint32_t ike_sa);
/**
* Destroy a xpc_logger_t.
struct sadb_x_kmprivate {
uint16_t sadb_x_kmprivate_len;
uint16_t sadb_x_kmprivate_exttype;
- u_int32_t sadb_x_kmprivate_reserved;
+ uint32_t sadb_x_kmprivate_reserved;
} __attribute__((packed));
/* sizeof(struct sadb_x_kmprivate) == 8 */
{
chunk_t addr;
host_t *host;
- u_int32_t *pos;
+ uint32_t *pos;
offset--;
if (offset > pool->size)
addr = chunk_clone(pool->base->get_address(pool->base));
if (pool->base->get_family(pool->base) == AF_INET6)
{
- pos = (u_int32_t*)(addr.ptr + 12);
+ pos = (uint32_t*)(addr.ptr + 12);
}
else
{
- pos = (u_int32_t*)addr.ptr;
+ pos = (uint32_t*)addr.ptr;
}
*pos = htonl(offset + ntohl(*pos));
host = host_create_from_chunk(pool->base->get_family(pool->base), addr, 0);
static int host2offset(private_mem_pool_t *pool, host_t *addr)
{
chunk_t host, base;
- u_int32_t hosti, basei;
+ uint32_t hosti, basei;
if (addr->get_family(addr) != pool->base->get_family(pool->base))
{
host = chunk_skip(host, 12);
base = chunk_skip(base, 12);
}
- hosti = ntohl(*(u_int32_t*)(host.ptr));
- basei = ntohl(*(u_int32_t*)(base.ptr));
+ hosti = ntohl(*(uint32_t*)(host.ptr));
+ basei = ntohl(*(uint32_t*)(base.ptr));
if (hosti > basei + pool->size)
{
return -1;
*/
static u_int network_id_diff(host_t *host, int hostbits)
{
- u_int32_t last;
+ uint32_t last;
chunk_t addr;
if (!hostbits)
{
private_mem_pool_t *this;
chunk_t fromaddr, toaddr;
- u_int32_t diff;
+ uint32_t diff;
fromaddr = from->get_address(from);
toaddr = to->get_address(to);
}
METHOD(bus_t, children_migrate, void,
- private_bus_t *this, ike_sa_id_t *new, u_int32_t unique)
+ private_bus_t *this, ike_sa_id_t *new, uint32_t unique)
{
enumerator_t *enumerator;
ike_sa_t *ike_sa;
* @param new ID of new SA when called for the old, NULL otherwise
* @param uniue unique ID of new SA when called for the old, 0 otherwise
*/
- void (*children_migrate)(bus_t *this, ike_sa_id_t *new, u_int32_t unique);
+ void (*children_migrate)(bus_t *this, ike_sa_id_t *new, uint32_t unique);
/**
* Virtual IP assignment hook.
* @return TRUE to stay registered, FALSE to unregister
*/
bool (*children_migrate)(listener_t *this, ike_sa_t *ike_sa,
- ike_sa_id_t *new, u_int32_t unique);
+ ike_sa_id_t *new, uint32_t unique);
/**
* Hook called to invoke additional authorization rules.
/**
* Inactivity timeout
*/
- u_int32_t inactivity;
+ uint32_t inactivity;
/**
* Reqid to install CHILD_SA with
*/
- u_int32_t reqid;
+ uint32_t reqid;
/**
* Optional mark to install inbound CHILD_SA with
/**
* Traffic Flow Confidentiality padding, if enabled
*/
- u_int32_t tfc;
+ uint32_t tfc;
/**
* set up IPsec transport SA in MIPv6 proxy mode
/**
* anti-replay window size
*/
- u_int32_t replay_window;
+ uint32_t replay_window;
};
METHOD(child_cfg_t, get_name, char*,
* Note: The distribution of random values is not perfect, but it
* should get the job done.
*/
-static u_int64_t apply_jitter(u_int64_t rekey, u_int64_t jitter)
+static uint64_t apply_jitter(uint64_t rekey, uint64_t jitter)
{
if (jitter == 0)
{
{
enumerator_t *enumerator;
proposal_t *proposal;
- u_int16_t dh_group = MODP_NONE;
+ uint16_t dh_group = MODP_NONE;
enumerator = this->proposals->create_enumerator(this->proposals);
while (enumerator->enumerate(enumerator, &proposal))
return this->use_ipcomp;
}
-METHOD(child_cfg_t, get_inactivity, u_int32_t,
+METHOD(child_cfg_t, get_inactivity, uint32_t,
private_child_cfg_t *this)
{
return this->inactivity;
}
-METHOD(child_cfg_t, get_reqid, u_int32_t,
+METHOD(child_cfg_t, get_reqid, uint32_t,
private_child_cfg_t *this)
{
return this->reqid;
return inbound ? this->mark_in : this->mark_out;
}
-METHOD(child_cfg_t, get_tfc, u_int32_t,
+METHOD(child_cfg_t, get_tfc, uint32_t,
private_child_cfg_t *this)
{
return this->tfc;
}
-METHOD(child_cfg_t, get_replay_window, u_int32_t,
+METHOD(child_cfg_t, get_replay_window, uint32_t,
private_child_cfg_t *this)
{
return this->replay_window;
}
METHOD(child_cfg_t, set_replay_window, void,
- private_child_cfg_t *this, u_int32_t replay_window)
+ private_child_cfg_t *this, uint32_t replay_window)
{
this->replay_window = replay_window;
}
char *updown, bool hostaccess,
ipsec_mode_t mode, action_t start_action,
action_t dpd_action, action_t close_action,
- bool ipcomp, u_int32_t inactivity, u_int32_t reqid,
- mark_t *mark_in, mark_t *mark_out, u_int32_t tfc)
+ bool ipcomp, uint32_t inactivity, uint32_t reqid,
+ mark_t *mark_in, mark_t *mark_out, uint32_t tfc)
{
private_child_cfg_t *this;
*
* @return inactivity timeout in s
*/
- u_int32_t (*get_inactivity)(child_cfg_t *this);
+ uint32_t (*get_inactivity)(child_cfg_t *this);
/**
* Specific reqid to use for CHILD_SA.
*
* @return reqid
*/
- u_int32_t (*get_reqid)(child_cfg_t *this);
+ uint32_t (*get_reqid)(child_cfg_t *this);
/**
* Optional mark for CHILD_SA.
*
* @return TFC padding, 0 to disable, -1 for MTU
*/
- u_int32_t (*get_tfc)(child_cfg_t *this);
+ uint32_t (*get_tfc)(child_cfg_t *this);
/**
* Get anti-replay window size
*
* @return anti-replay window size
*/
- u_int32_t (*get_replay_window)(child_cfg_t *this);
+ uint32_t (*get_replay_window)(child_cfg_t *this);
/**
* Set anti-replay window size
*
* @param window anti-replay window size
*/
- void (*set_replay_window)(child_cfg_t *this, u_int32_t window);
+ void (*set_replay_window)(child_cfg_t *this, uint32_t window);
/**
* Sets two options needed for Mobile IPv6 interoperability.
char *updown, bool hostaccess,
ipsec_mode_t mode, action_t start_action,
action_t dpd_action, action_t close_action,
- bool ipcomp, u_int32_t inactivity, u_int32_t reqid,
- mark_t *mark_in, mark_t *mark_out, u_int32_t tfc);
+ bool ipcomp, uint32_t inactivity, uint32_t reqid,
+ mark_t *mark_in, mark_t *mark_out, uint32_t tfc);
#endif /** CHILD_CFG_H_ @}*/
/**
* our source port
*/
- u_int16_t my_port;
+ uint16_t my_port;
/**
* destination port
*/
- u_int16_t other_port;
+ uint16_t other_port;
/**
* should we send a certificate request?
/**
* DSCP value to use on sent IKE packets
*/
- u_int8_t dscp;
+ uint8_t dscp;
/**
* List of proposals to use
/**
* Common function for resolve_me/other
*/
-static host_t* resolve(linked_list_t *hosts, int family, u_int16_t port)
+static host_t* resolve(linked_list_t *hosts, int family, uint16_t port)
{
enumerator_t *enumerator;
host_t *host = NULL;
traffic_selector_t *ts;
char *str;
host_t *host;
- u_int8_t mask;
+ uint8_t mask;
u_int quality = 0;
/* try single hosts first */
return this->other;
}
-METHOD(ike_cfg_t, get_my_port, u_int16_t,
+METHOD(ike_cfg_t, get_my_port, uint16_t,
private_ike_cfg_t *this)
{
return this->my_port;
}
-METHOD(ike_cfg_t, get_other_port, u_int16_t,
+METHOD(ike_cfg_t, get_other_port, uint16_t,
private_ike_cfg_t *this)
{
return this->other_port;
}
-METHOD(ike_cfg_t, get_dscp, u_int8_t,
+METHOD(ike_cfg_t, get_dscp, uint8_t,
private_ike_cfg_t *this)
{
return this->dscp;
{
enumerator_t *enumerator;
proposal_t *proposal;
- u_int16_t dh_group = MODP_NONE;
+ uint16_t dh_group = MODP_NONE;
enumerator = this->proposals->create_enumerator(this->proposals);
while (enumerator->enumerate(enumerator, &proposal))
* Described in header.
*/
ike_cfg_t *ike_cfg_create(ike_version_t version, bool certreq, bool force_encap,
- char *me, u_int16_t my_port,
- char *other, u_int16_t other_port,
- fragmentation_t fragmentation, u_int8_t dscp)
+ char *me, uint16_t my_port,
+ char *other, uint16_t other_port,
+ fragmentation_t fragmentation, uint8_t dscp)
{
private_ike_cfg_t *this;
*
* @return source address port, host order
*/
- u_int16_t (*get_my_port)(ike_cfg_t *this);
+ uint16_t (*get_my_port)(ike_cfg_t *this);
/**
* Get the port to use as destination port.
*
* @return destination address, host order
*/
- u_int16_t (*get_other_port)(ike_cfg_t *this);
+ uint16_t (*get_other_port)(ike_cfg_t *this);
/**
* Get the DSCP value to use for IKE packets send from connections.
*
* @return DSCP value
*/
- u_int8_t (*get_dscp)(ike_cfg_t *this);
+ uint8_t (*get_dscp)(ike_cfg_t *this);
/**
* Adds a proposal to the list.
* @return ike_cfg_t object.
*/
ike_cfg_t *ike_cfg_create(ike_version_t version, bool certreq, bool force_encap,
- char *me, u_int16_t my_port,
- char *other, u_int16_t other_port,
- fragmentation_t fragmentation, u_int8_t dscp);
+ char *me, uint16_t my_port,
+ char *other, uint16_t other_port,
+ fragmentation_t fragmentation, uint8_t dscp);
/**
* Determine the address family of the local or remtoe address(es). If multiple
/**
* number of tries after giving up if peer does not respond
*/
- u_int32_t keyingtries;
+ uint32_t keyingtries;
/**
* enable support for MOBIKE
/**
* Time before starting rekeying
*/
- u_int32_t rekey_time;
+ uint32_t rekey_time;
/**
* Time before starting reauthentication
*/
- u_int32_t reauth_time;
+ uint32_t reauth_time;
/**
* Time, which specifies the range of a random value subtracted from above.
*/
- u_int32_t jitter_time;
+ uint32_t jitter_time;
/**
* Delay before deleting a rekeying/reauthenticating SA
*/
- u_int32_t over_time;
+ uint32_t over_time;
/**
* DPD check intervall
*/
- u_int32_t dpd;
+ uint32_t dpd;
/**
* DPD timeout intervall (used for IKEv1 only)
*/
- u_int32_t dpd_timeout;
+ uint32_t dpd_timeout;
/**
* List of virtual IPs (host_t*) to request
return this->unique;
}
-METHOD(peer_cfg_t, get_keyingtries, u_int32_t,
+METHOD(peer_cfg_t, get_keyingtries, uint32_t,
private_peer_cfg_t *this)
{
return this->keyingtries;
}
-METHOD(peer_cfg_t, get_rekey_time, u_int32_t,
+METHOD(peer_cfg_t, get_rekey_time, uint32_t,
private_peer_cfg_t *this, bool jitter)
{
if (this->rekey_time == 0)
return this->rekey_time - (random() % this->jitter_time);
}
-METHOD(peer_cfg_t, get_reauth_time, u_int32_t,
+METHOD(peer_cfg_t, get_reauth_time, uint32_t,
private_peer_cfg_t *this, bool jitter)
{
if (this->reauth_time == 0)
return this->reauth_time - (random() % this->jitter_time);
}
-METHOD(peer_cfg_t, get_over_time, u_int32_t,
+METHOD(peer_cfg_t, get_over_time, uint32_t,
private_peer_cfg_t *this)
{
return this->over_time;
return this->pull_mode;
}
-METHOD(peer_cfg_t, get_dpd, u_int32_t,
+METHOD(peer_cfg_t, get_dpd, uint32_t,
private_peer_cfg_t *this)
{
return this->dpd;
}
-METHOD(peer_cfg_t, get_dpd_timeout, u_int32_t,
+METHOD(peer_cfg_t, get_dpd_timeout, uint32_t,
private_peer_cfg_t *this)
{
return this->dpd_timeout;
*/
peer_cfg_t *peer_cfg_create(char *name,
ike_cfg_t *ike_cfg, cert_policy_t cert_policy,
- unique_policy_t unique, u_int32_t keyingtries,
- u_int32_t rekey_time, u_int32_t reauth_time,
- u_int32_t jitter_time, u_int32_t over_time,
+ unique_policy_t unique, uint32_t keyingtries,
+ uint32_t rekey_time, uint32_t reauth_time,
+ uint32_t jitter_time, uint32_t over_time,
bool mobike, bool aggressive, bool pull_mode,
- u_int32_t dpd, u_int32_t dpd_timeout,
+ uint32_t dpd, uint32_t dpd_timeout,
bool mediation, peer_cfg_t *mediated_by,
identification_t *peer_id)
{
*
* @return max number retries
*/
- u_int32_t (*get_keyingtries) (peer_cfg_t *this);
+ uint32_t (*get_keyingtries) (peer_cfg_t *this);
/**
* Get a time to start rekeying.
* @param jitter remove a jitter value to randomize time
* @return time in s when to start rekeying, 0 disables rekeying
*/
- u_int32_t (*get_rekey_time)(peer_cfg_t *this, bool jitter);
+ uint32_t (*get_rekey_time)(peer_cfg_t *this, bool jitter);
/**
* Get a time to start reauthentication.
* @param jitter remove a jitter value to randomize time
* @return time in s when to start reauthentication, 0 disables it
*/
- u_int32_t (*get_reauth_time)(peer_cfg_t *this, bool jitter);
+ uint32_t (*get_reauth_time)(peer_cfg_t *this, bool jitter);
/**
* Get the timeout of a rekeying/reauthenticating SA.
*
* @return timeout in s
*/
- u_int32_t (*get_over_time)(peer_cfg_t *this);
+ uint32_t (*get_over_time)(peer_cfg_t *this);
/**
* Use MOBIKE (RFC4555) if peer supports it?
*
* @return dpd_delay in seconds
*/
- u_int32_t (*get_dpd) (peer_cfg_t *this);
+ uint32_t (*get_dpd) (peer_cfg_t *this);
/**
* Get the DPD timeout interval (IKEv1 only)
*
* @return dpd_timeout in seconds
*/
- u_int32_t (*get_dpd_timeout) (peer_cfg_t *this);
+ uint32_t (*get_dpd_timeout) (peer_cfg_t *this);
/**
* Add a virtual IP to request as initiator.
*/
peer_cfg_t *peer_cfg_create(char *name,
ike_cfg_t *ike_cfg, cert_policy_t cert_policy,
- unique_policy_t unique, u_int32_t keyingtries,
- u_int32_t rekey_time, u_int32_t reauth_time,
- u_int32_t jitter_time, u_int32_t over_time,
+ unique_policy_t unique, uint32_t keyingtries,
+ uint32_t rekey_time, uint32_t reauth_time,
+ uint32_t jitter_time, uint32_t over_time,
bool mobike, bool aggressive, bool pull_mode,
- u_int32_t dpd, u_int32_t dpd_timeout,
+ uint32_t dpd, uint32_t dpd_timeout,
bool mediation, peer_cfg_t *mediated_by,
identification_t *peer_id);
/**
* senders SPI
*/
- u_int64_t spi;
+ uint64_t spi;
/**
* Proposal number
/** Type of the transform */
transform_type_t type;
/** algorithm identifier */
- u_int16_t alg;
+ uint16_t alg;
/** key size in bits, or zero if not needed */
- u_int16_t key_size;
+ uint16_t key_size;
} entry_t;
METHOD(proposal_t, add_algorithm, void,
private_proposal_t *this, transform_type_t type,
- u_int16_t alg, u_int16_t key_size)
+ uint16_t alg, uint16_t key_size)
{
entry_t entry = {
.type = type,
/**
* filter function for peer configs
*/
-static bool alg_filter(uintptr_t type, entry_t **in, u_int16_t *alg,
- void **unused, u_int16_t *key_size)
+static bool alg_filter(uintptr_t type, entry_t **in, uint16_t *alg,
+ void **unused, uint16_t *key_size)
{
entry_t *entry = *in;
METHOD(proposal_t, get_algorithm, bool,
private_proposal_t *this, transform_type_t type,
- u_int16_t *alg, u_int16_t *key_size)
+ uint16_t *alg, uint16_t *key_size)
{
enumerator_t *enumerator;
bool found = FALSE;
{
bool found = FALSE, any = FALSE;
enumerator_t *enumerator;
- u_int16_t current;
+ uint16_t current;
enumerator = create_enumerator(this, DIFFIE_HELLMAN_GROUP);
while (enumerator->enumerate(enumerator, ¤t, NULL))
proposal_t *selected, transform_type_t type, bool priv)
{
enumerator_t *e1, *e2;
- u_int16_t alg1, alg2, ks1, ks2;
+ uint16_t alg1, alg2, ks1, ks2;
bool found = FALSE, optional = FALSE;
if (type == INTEGRITY_ALGORITHM &&
}
METHOD(proposal_t, set_spi, void,
- private_proposal_t *this, u_int64_t spi)
+ private_proposal_t *this, uint64_t spi)
{
this->spi = spi;
}
-METHOD(proposal_t, get_spi, u_int64_t,
+METHOD(proposal_t, get_spi, uint64_t,
private_proposal_t *this)
{
return this->spi;
transform_type_t type)
{
enumerator_t *e1, *e2;
- u_int16_t alg1, alg2, ks1, ks2;
+ uint16_t alg1, alg2, ks1, ks2;
bool equals = TRUE;
e1 = create_enumerator(this, type);
{
enumerator_t *e;
entry_t *entry;
- u_int16_t alg, ks;
+ uint16_t alg, ks;
bool all_aead = TRUE;
int i;
{
enumerator_t *enumerator;
size_t written = 0;
- u_int16_t alg, size;
+ uint16_t alg, size;
enumerator = create_enumerator(this, kind);
while (enumerator->enumerate(enumerator, &alg, &size))
* @param key_size key size to use
*/
void (*add_algorithm) (proposal_t *this, transform_type_t type,
- u_int16_t alg, u_int16_t key_size);
+ uint16_t alg, uint16_t key_size);
/**
* Get an enumerator over algorithms for a specifc algo type.
*
* @param type kind of algorithm
- * @return enumerator over u_int16_t alg, u_int16_t key_size
+ * @return enumerator over uint16_t alg, uint16_t key_size
*/
enumerator_t *(*create_enumerator) (proposal_t *this, transform_type_t type);
* @return TRUE if algorithm of this kind available
*/
bool (*get_algorithm) (proposal_t *this, transform_type_t type,
- u_int16_t *alg, u_int16_t *key_size);
+ uint16_t *alg, uint16_t *key_size);
/**
* Check if the proposal has a specific DH group.
*
* @return spi for proto
*/
- u_int64_t (*get_spi) (proposal_t *this);
+ uint64_t (*get_spi) (proposal_t *this);
/**
* Set the SPI of the proposal.
*
* @param spi spi to set for proto
*/
- void (*set_spi) (proposal_t *this, u_int64_t spi);
+ void (*set_spi) (proposal_t *this, uint64_t spi);
/**
* Get the proposal number, as encoded in SA payload
/**
* unique ID, used for various methods
*/
- u_int32_t id;
+ uint32_t id;
/**
* semaphore to implement wait_for_listener()
interface_job_t *job)
{
interface_listener_t *listener = &job->listener;
- u_int32_t unique_id = listener->id;
+ uint32_t unique_id = listener->id;
ike_sa_t *ike_sa;
ike_sa = charon->ike_sa_manager->checkout_by_id(charon->ike_sa_manager,
}
METHOD(controller_t, terminate_ike, status_t,
- controller_t *this, u_int32_t unique_id,
+ controller_t *this, uint32_t unique_id,
controller_cb_t callback, void *param, u_int timeout)
{
interface_job_t *job;
interface_job_t *job)
{
interface_listener_t *listener = &job->listener;
- u_int32_t id = listener->id;
+ uint32_t id = listener->id;
child_sa_t *child_sa;
ike_sa_t *ike_sa;
}
METHOD(controller_t, terminate_child, status_t,
- controller_t *this, u_int32_t unique_id,
+ controller_t *this, uint32_t unique_id,
controller_cb_t callback, void *param, u_int timeout)
{
interface_job_t *job;
* - NEED_MORE, if callback returned FALSE
* - OUT_OF_RES if timed out
*/
- status_t (*terminate_ike)(controller_t *this, u_int32_t unique_id,
+ status_t (*terminate_ike)(controller_t *this, uint32_t unique_id,
controller_cb_t callback, void *param,
u_int timeout);
* - NEED_MORE, if callback returned FALSE
* - OUT_OF_RES if timed out
*/
- status_t (*terminate_child)(controller_t *this, u_int32_t unique_id,
+ status_t (*terminate_child)(controller_t *this, uint32_t unique_id,
controller_cb_t callback, void *param,
u_int timeout);
/**
* Buffer used to generate the data into.
*/
- u_int8_t *buffer;
+ uint8_t *buffer;
/**
* Current write position in buffer (one byte aligned).
*/
- u_int8_t *out_position;
+ uint8_t *out_position;
/**
* Position of last byte in buffer.
*/
- u_int8_t *roof_position;
+ uint8_t *roof_position;
/**
* Current bit writing to in current byte (between 0 and 7).
*/
- u_int8_t current_bit;
+ uint8_t current_bit;
/**
* Associated data struct to read informations from.
/**
* Offset of the header length field in the buffer.
*/
- u_int32_t header_length_offset;
+ uint32_t header_length_offset;
/**
* Attribute format of the last generated transform attribute.
* Depending on the value of attribute_format this field is used
* to hold the length of the transform attribute in bytes.
*/
- u_int16_t attribute_length;
+ uint16_t attribute_length;
/**
* TRUE, if debug messages should be logged during generation.
/**
* Get current offset in buffer (in bytes).
*/
-static u_int32_t get_offset(private_generator_t *this)
+static uint32_t get_offset(private_generator_t *this)
{
return this->out_position - this->buffer;
}
int number_of_bytes)
{
int i;
- u_int8_t *read_position = (u_int8_t *)bytes;
+ uint8_t *read_position = (uint8_t *)bytes;
make_space_available(this, number_of_bytes * 8);
* Generates a U_INT-Field type and writes it to buffer.
*/
static void generate_u_int_type(private_generator_t *this,
- encoding_type_t int_type,u_int32_t offset)
+ encoding_type_t int_type,uint32_t offset)
{
int number_of_bits = 0;
{
case U_INT_4:
{
- u_int8_t high, low;
+ uint8_t high, low;
if (this->current_bit == 0)
{
/* high of current byte in buffer has to be set to the new value*/
- high = *((u_int8_t *)(this->data_struct + offset)) << 4;
+ high = *((uint8_t *)(this->data_struct + offset)) << 4;
/* low in buffer is not changed */
low = *(this->out_position) & 0x0F;
/* high is set, low_val is not changed */
/* high in buffer is not changed */
high = *(this->out_position) & 0xF0;
/* low of current byte in buffer has to be set to the new value*/
- low = *((u_int8_t *)(this->data_struct + offset)) & 0x0F;
+ low = *((uint8_t *)(this->data_struct + offset)) & 0x0F;
*(this->out_position) = high | low;
if (this->debug)
{
case U_INT_8:
{
/* 8 bit values are written as they are */
- *this->out_position = *((u_int8_t *)(this->data_struct + offset));
+ *this->out_position = *((uint8_t *)(this->data_struct + offset));
if (this->debug)
{
DBG3(DBG_ENC, " => %d", *(this->out_position));
}
case ATTRIBUTE_TYPE:
{
- u_int8_t attribute_format_flag;
- u_int16_t val;
+ uint8_t attribute_format_flag;
+ uint16_t val;
/* attribute type must not change first bit of current byte */
if (this->current_bit != 1)
}
attribute_format_flag = *(this->out_position) & 0x80;
/* get attribute type value as 16 bit integer*/
- val = *((u_int16_t*)(this->data_struct + offset));
+ val = *((uint16_t*)(this->data_struct + offset));
/* unset most significant bit */
val &= 0x7FFF;
if (attribute_format_flag)
DBG3(DBG_ENC, " => %d", val);
}
/* write bytes to buffer (set bit is overwritten) */
- write_bytes_to_buffer(this, &val, sizeof(u_int16_t));
+ write_bytes_to_buffer(this, &val, sizeof(uint16_t));
this->current_bit = 0;
break;
case PAYLOAD_LENGTH:
case ATTRIBUTE_LENGTH:
{
- u_int16_t val = htons(*((u_int16_t*)(this->data_struct + offset)));
+ uint16_t val = htons(*((uint16_t*)(this->data_struct + offset)));
if (this->debug)
{
- DBG3(DBG_ENC, " %b", &val, sizeof(u_int16_t));
+ DBG3(DBG_ENC, " %b", &val, sizeof(uint16_t));
}
- write_bytes_to_buffer(this, &val, sizeof(u_int16_t));
+ write_bytes_to_buffer(this, &val, sizeof(uint16_t));
break;
}
case U_INT_32:
{
- u_int32_t val = htonl(*((u_int32_t*)(this->data_struct + offset)));
+ uint32_t val = htonl(*((uint32_t*)(this->data_struct + offset)));
if (this->debug)
{
- DBG3(DBG_ENC, " %b", &val, sizeof(u_int32_t));
+ DBG3(DBG_ENC, " %b", &val, sizeof(uint32_t));
}
- write_bytes_to_buffer(this, &val, sizeof(u_int32_t));
+ write_bytes_to_buffer(this, &val, sizeof(uint32_t));
break;
}
case IKE_SPI:
{
/* 64 bit are written as-is, no host order conversion */
write_bytes_to_buffer(this, this->data_struct + offset,
- sizeof(u_int64_t));
+ sizeof(uint64_t));
if (this->debug)
{
DBG3(DBG_ENC, " %b", this->data_struct + offset,
- sizeof(u_int64_t));
+ sizeof(uint64_t));
}
break;
}
/**
* Generate a FLAG filed
*/
-static void generate_flag(private_generator_t *this, u_int32_t offset)
+static void generate_flag(private_generator_t *this, uint32_t offset)
{
- u_int8_t flag_value;
- u_int8_t flag;
+ uint8_t flag_value;
+ uint8_t flag;
flag_value = (*((bool *) (this->data_struct + offset))) ? 1 : 0;
/* get flag position */
/**
* Generates a bytestream from a chunk_t.
*/
-static void generate_from_chunk(private_generator_t *this, u_int32_t offset)
+static void generate_from_chunk(private_generator_t *this, uint32_t offset)
{
chunk_t *value;
}
METHOD(generator_t, get_chunk, chunk_t,
- private_generator_t *this, u_int32_t **lenpos)
+ private_generator_t *this, uint32_t **lenpos)
{
chunk_t data;
- *lenpos = (u_int32_t*)(this->buffer + this->header_length_offset);
+ *lenpos = (uint32_t*)(this->buffer + this->header_length_offset);
data = chunk_create(this->buffer, get_length(this));
if (this->debug)
{
generate_u_int_type(this, U_INT_16, rules[i].offset);
/* this field hold the length of the attribute */
this->attribute_length =
- *((u_int16_t *)(this->data_struct + rules[i].offset));
+ *((uint16_t *)(this->data_struct + rules[i].offset));
}
break;
case ATTRIBUTE_VALUE:
* @param lenpos receives a pointer to fill in length value
* @param return chunk to internal buffer.
*/
- chunk_t (*get_chunk) (generator_t *this, u_int32_t **lenpos);
+ chunk_t (*get_chunk) (generator_t *this, uint32_t **lenpos);
/**
* Destroys a generator_t object.
* fragments we expect.
* For IKEv2 we store the total number of fragment we received last.
*/
- u_int16_t last;
+ uint16_t last;
/**
* Length of all currently received fragments.
/**
* Minor version of message.
*/
- u_int8_t major_version;
+ uint8_t major_version;
/**
* Major version of message.
*/
- u_int8_t minor_version;
+ uint8_t minor_version;
/**
* First Payload in message.
/**
* Message ID of this message.
*/
- u_int32_t message_id;
+ uint32_t message_id;
/**
* ID of assigned IKE_SA.
typedef struct {
/** fragment number */
- u_int8_t num;
+ uint8_t num;
/** fragment data */
chunk_t data;
}
METHOD(message_t, set_message_id, void,
- private_message_t *this,u_int32_t message_id)
+ private_message_t *this,uint32_t message_id)
{
this->message_id = message_id;
}
-METHOD(message_t, get_message_id, u_int32_t,
+METHOD(message_t, get_message_id, uint32_t,
private_message_t *this)
{
return this->message_id;
}
-METHOD(message_t, get_initiator_spi, u_int64_t,
+METHOD(message_t, get_initiator_spi, uint64_t,
private_message_t *this)
{
return (this->ike_sa_id->get_initiator_spi(this->ike_sa_id));
}
-METHOD(message_t, get_responder_spi, u_int64_t,
+METHOD(message_t, get_responder_spi, uint64_t,
private_message_t *this)
{
return (this->ike_sa_id->get_responder_spi(this->ike_sa_id));
}
METHOD(message_t, set_major_version, void,
- private_message_t *this, u_int8_t major_version)
+ private_message_t *this, uint8_t major_version)
{
this->major_version = major_version;
}
-METHOD(message_t, get_major_version, u_int8_t,
+METHOD(message_t, get_major_version, uint8_t,
private_message_t *this)
{
return this->major_version;
}
METHOD(message_t, set_minor_version, void,
- private_message_t *this,u_int8_t minor_version)
+ private_message_t *this,uint8_t minor_version)
{
this->minor_version = minor_version;
}
-METHOD(message_t, get_minor_version, u_int8_t,
+METHOD(message_t, get_minor_version, uint8_t,
private_message_t *this)
{
return this->minor_version;
if (payload->get_type(payload) == PLV2_EAP)
{
eap_payload_t *eap = (eap_payload_t*)payload;
- u_int32_t vendor;
+ uint32_t vendor;
eap_type_t type;
char method[64] = "";
{
keymat_v1_t *keymat_v1 = (keymat_v1_t*)keymat;
chunk_t chunk;
- u_int32_t *lenpos;
+ uint32_t *lenpos;
if (encrypted)
{
* Create a single fragment with the given data
*/
static message_t *create_fragment(private_message_t *this, payload_type_t next,
- u_int16_t num, u_int16_t count, chunk_t data)
+ uint16_t num, uint16_t count, chunk_t data)
{
enumerator_t *enumerator;
payload_t *fragment, *payload;
message_t *fragment;
packet_t *packet;
payload_type_t next = PL_NONE;
- u_int16_t num, count;
+ uint16_t num, count;
host_t *src, *dst;
chunk_t data;
status_t status;
- u_int32_t *lenpos;
+ uint32_t *lenpos;
size_t len;
src = this->packet->get_source(this->packet);
/**
* Store the fragment data for the fragment with the given fragment number.
*/
-static status_t add_fragment(private_message_t *this, u_int16_t num,
+static status_t add_fragment(private_message_t *this, uint16_t num,
chunk_t data)
{
fragment_t *fragment;
{
fragment_payload_t *payload;
chunk_t data;
- u_int8_t num;
+ uint8_t num;
status_t status;
if (!this->frag)
payload_t *payload;
enumerator_t *enumerator;
chunk_t data;
- u_int16_t total, num;
+ uint16_t total, num;
status_t status;
if (!this->frag)
*
* @param major_version major version to set
*/
- void (*set_major_version) (message_t *this, u_int8_t major_version);
+ void (*set_major_version) (message_t *this, uint8_t major_version);
/**
* Gets the IKE major version of the message.
*
* @return major version of the message
*/
- u_int8_t (*get_major_version) (message_t *this);
+ uint8_t (*get_major_version) (message_t *this);
/**
* Sets the IKE minor version of the message.
*
* @param minor_version minor version to set
*/
- void (*set_minor_version) (message_t *this, u_int8_t minor_version);
+ void (*set_minor_version) (message_t *this, uint8_t minor_version);
/**
* Gets the IKE minor version of the message.
*
* @return minor version of the message
*/
- u_int8_t (*get_minor_version) (message_t *this);
+ uint8_t (*get_minor_version) (message_t *this);
/**
* Sets the Message ID of the message.
*
* @param message_id message_id to set
*/
- void (*set_message_id) (message_t *this, u_int32_t message_id);
+ void (*set_message_id) (message_t *this, uint32_t message_id);
/**
* Gets the Message ID of the message.
*
* @return message_id type of the message
*/
- u_int32_t (*get_message_id) (message_t *this);
+ uint32_t (*get_message_id) (message_t *this);
/**
* Gets the initiator SPI of the message.
*
* @return initiator spi of the message
*/
- u_int64_t (*get_initiator_spi) (message_t *this);
+ uint64_t (*get_initiator_spi) (message_t *this);
/**
* Gets the responder SPI of the message.
*
* @return responder spi of the message
*/
- u_int64_t (*get_responder_spi) (message_t *this);
+ uint64_t (*get_responder_spi) (message_t *this);
/**
* Sets the IKE_SA ID of the message.
/**
* major IKE version
*/
- u_int8_t major_version;
+ uint8_t major_version;
/**
* Current bit for reading in input data.
*/
- u_int8_t bit_pos;
+ uint8_t bit_pos;
/**
* Current byte for reading in input data.
*/
- u_int8_t *byte_pos;
+ uint8_t *byte_pos;
/**
* Input data to parse.
*/
- u_int8_t *input;
+ uint8_t *input;
/**
* Roof of input, used for length-checking.
*/
- u_int8_t *input_roof;
+ uint8_t *input_roof;
/**
* Set of encoding rules for this parsing session.
* Parse a 4-Bit unsigned integer from the current parsing position.
*/
static bool parse_uint4(private_parser_t *this, int rule_number,
- u_int8_t *output_pos)
+ uint8_t *output_pos)
{
- if (this->byte_pos + sizeof(u_int8_t) > this->input_roof)
+ if (this->byte_pos + sizeof(uint8_t) > this->input_roof)
{
return short_input(this, rule_number);
}
* Parse a 8-Bit unsigned integer from the current parsing position.
*/
static bool parse_uint8(private_parser_t *this, int rule_number,
- u_int8_t *output_pos)
+ uint8_t *output_pos)
{
- if (this->byte_pos + sizeof(u_int8_t) > this->input_roof)
+ if (this->byte_pos + sizeof(uint8_t) > this->input_roof)
{
return short_input(this, rule_number);
}
* Parse a 15-Bit unsigned integer from the current parsing position.
*/
static bool parse_uint15(private_parser_t *this, int rule_number,
- u_int16_t *output_pos)
+ uint16_t *output_pos)
{
- if (this->byte_pos + sizeof(u_int16_t) > this->input_roof)
+ if (this->byte_pos + sizeof(uint16_t) > this->input_roof)
{
return short_input(this, rule_number);
}
}
if (output_pos)
{
- memcpy(output_pos, this->byte_pos, sizeof(u_int16_t));
+ memcpy(output_pos, this->byte_pos, sizeof(uint16_t));
*output_pos = ntohs(*output_pos) & ~0x8000;
DBG3(DBG_ENC, " => %hu", *output_pos);
}
- this->byte_pos += sizeof(u_int16_t);
+ this->byte_pos += sizeof(uint16_t);
this->bit_pos = 0;
return TRUE;
}
* Parse a 16-Bit unsigned integer from the current parsing position.
*/
static bool parse_uint16(private_parser_t *this, int rule_number,
- u_int16_t *output_pos)
+ uint16_t *output_pos)
{
- if (this->byte_pos + sizeof(u_int16_t) > this->input_roof)
+ if (this->byte_pos + sizeof(uint16_t) > this->input_roof)
{
return short_input(this, rule_number);
}
}
if (output_pos)
{
- memcpy(output_pos, this->byte_pos, sizeof(u_int16_t));
+ memcpy(output_pos, this->byte_pos, sizeof(uint16_t));
*output_pos = ntohs(*output_pos);
DBG3(DBG_ENC, " => %hu", *output_pos);
}
- this->byte_pos += sizeof(u_int16_t);
+ this->byte_pos += sizeof(uint16_t);
return TRUE;
}
/**
* Parse a 32-Bit unsigned integer from the current parsing position.
*/
static bool parse_uint32(private_parser_t *this, int rule_number,
- u_int32_t *output_pos)
+ uint32_t *output_pos)
{
- if (this->byte_pos + sizeof(u_int32_t) > this->input_roof)
+ if (this->byte_pos + sizeof(uint32_t) > this->input_roof)
{
return short_input(this, rule_number);
}
}
if (output_pos)
{
- memcpy(output_pos, this->byte_pos, sizeof(u_int32_t));
+ memcpy(output_pos, this->byte_pos, sizeof(uint32_t));
*output_pos = ntohl(*output_pos);
DBG3(DBG_ENC, " => %u", *output_pos);
}
- this->byte_pos += sizeof(u_int32_t);
+ this->byte_pos += sizeof(uint32_t);
return TRUE;
}
* Parse a given amount of bytes and writes them to a specific location
*/
static bool parse_bytes(private_parser_t *this, int rule_number,
- u_int8_t *output_pos, int bytes)
+ uint8_t *output_pos, int bytes)
{
if (this->byte_pos + bytes > this->input_roof)
{
static bool parse_bit(private_parser_t *this, int rule_number,
bool *output_pos)
{
- if (this->byte_pos + sizeof(u_int8_t) > this->input_roof)
+ if (this->byte_pos + sizeof(uint8_t) > this->input_roof)
{
return short_input(this, rule_number);
}
if (output_pos)
{
- u_int8_t mask;
+ uint8_t mask;
mask = 0x01 << (7 - this->bit_pos);
*output_pos = *this->byte_pos & mask;
}
while (length > 0)
{
- u_int8_t *pos_before = this->byte_pos;
+ uint8_t *pos_before = this->byte_pos;
payload_t *payload;
DBG2(DBG_ENC, " %d bytes left, parsing recursively %N",
payload_t *pld;
void *output;
int payload_length = 0, spi_size = 0, attribute_length = 0, header_length;
- u_int16_t ts_type = 0;
+ uint16_t ts_type = 0;
bool attribute_format = FALSE;
int rule_number, rule_count;
encoding_rule_t *rule;
return PARSE_ERROR;
}
/* parsed u_int16 should be aligned */
- payload_length = *(u_int16_t*)(output + rule->offset);
+ payload_length = *(uint16_t*)(output + rule->offset);
/* all payloads must have at least 4 bytes header */
if (payload_length < 4)
{
pld->destroy(pld);
return PARSE_ERROR;
}
- spi_size = *(u_int8_t*)(output + rule->offset);
+ spi_size = *(uint8_t*)(output + rule->offset);
break;
}
case SPI:
pld->destroy(pld);
return PARSE_ERROR;
}
- attribute_length = *(u_int16_t*)(output + rule->offset);
+ attribute_length = *(uint16_t*)(output + rule->offset);
break;
}
case ATTRIBUTE_LENGTH_OR_VALUE:
pld->destroy(pld);
return PARSE_ERROR;
}
- attribute_length = *(u_int16_t*)(output + rule->offset);
+ attribute_length = *(uint16_t*)(output + rule->offset);
break;
}
case ATTRIBUTE_VALUE:
pld->destroy(pld);
return PARSE_ERROR;
}
- ts_type = *(u_int8_t*)(output + rule->offset);
+ ts_type = *(uint8_t*)(output + rule->offset);
break;
}
case ADDRESS:
}
METHOD(parser_t, set_major_version, void,
- private_parser_t *this, u_int8_t major_version)
+ private_parser_t *this, uint8_t major_version)
{
this->major_version = major_version;
}
*
* @param major_version the major IKE version
*/
- void (*set_major_version) (parser_t *this, u_int8_t major_version);
+ void (*set_major_version) (parser_t *this, uint8_t major_version);
/**
* Destroys a parser_t object.
/**
* Next payload type.
*/
- u_int8_t next_payload;
+ uint8_t next_payload;
/**
* Critical flag.
/**
* Reserved bytes
*/
- u_int8_t reserved_byte[3];
+ uint8_t reserved_byte[3];
/**
* Length of this payload.
*/
- u_int16_t payload_length;
+ uint16_t payload_length;
/**
* Method of the AUTH Data.
*/
- u_int8_t auth_method;
+ uint8_t auth_method;
/**
* The contained auth data value.
/**
* Next payload type.
*/
- u_int8_t next_payload;
+ uint8_t next_payload;
/**
* Critical flag.
/**
* Length of this payload.
*/
- u_int16_t payload_length;
+ uint16_t payload_length;
/**
* Encoding of the CERT Data.
*/
- u_int8_t encoding;
+ uint8_t encoding;
/**
* The contained cert data value.
/**
* Next payload type.
*/
- u_int8_t next_payload;
+ uint8_t next_payload;
/**
* Critical flag.
/**
* Length of this payload.
*/
- u_int16_t payload_length;
+ uint16_t payload_length;
/**
* Encoding of the CERT Data.
*/
- u_int8_t encoding;
+ uint8_t encoding;
/**
* The contained certreq data value.
/**
* Type of the attribute.
*/
- u_int16_t attr_type;
+ uint16_t attr_type;
/**
* Length of the attribute, value if af_flag set.
*/
- u_int16_t length_or_value;
+ uint16_t length_or_value;
/**
* Attribute value as chunk.
return this->value;
}
-METHOD(configuration_attribute_t, get_value, u_int16_t,
+METHOD(configuration_attribute_t, get_value, uint16_t,
private_configuration_attribute_t *this)
{
if (this->af_flag)
this = (private_configuration_attribute_t*)
configuration_attribute_create(type);
- this->attr_type = ((u_int16_t)attr_type) & 0x7FFF;
+ this->attr_type = ((uint16_t)attr_type) & 0x7FFF;
this->value = chunk_clone(chunk);
this->length_or_value = chunk.len;
* Described in header.
*/
configuration_attribute_t *configuration_attribute_create_value(
- configuration_attribute_type_t attr_type, u_int16_t value)
+ configuration_attribute_type_t attr_type, uint16_t value)
{
private_configuration_attribute_t *this;
this = (private_configuration_attribute_t*)
configuration_attribute_create(PLV1_CONFIGURATION_ATTRIBUTE);
- this->attr_type = ((u_int16_t)attr_type) & 0x7FFF;
+ this->attr_type = ((uint16_t)attr_type) & 0x7FFF;
this->length_or_value = value;
this->af_flag = TRUE;
*
* @return attribute value
*/
- u_int16_t (*get_value) (configuration_attribute_t *this);
+ uint16_t (*get_value) (configuration_attribute_t *this);
/**
* Destroys an configuration_attribute_t object.
* @return created PLV1_CONFIGURATION_ATTRIBUTE configuration attribute
*/
configuration_attribute_t *configuration_attribute_create_value(
- configuration_attribute_type_t attr_type, u_int16_t value);
+ configuration_attribute_type_t attr_type, uint16_t value);
#endif /** CONFIGURATION_ATTRIBUTE_H_ @}*/
/**
* Next payload type.
*/
- u_int8_t next_payload;
+ uint8_t next_payload;
/**
* Critical flag.
/**
* Reserved bytes
*/
- u_int8_t reserved_byte[3];
+ uint8_t reserved_byte[3];
/**
* Length of this payload.
*/
- u_int16_t payload_length;
+ uint16_t payload_length;
/**
* Identifier field, IKEv1 only
*/
- u_int16_t identifier;
+ uint16_t identifier;
/**
* List of attributes, as configuration_attribute_t
/**
* Config Type.
*/
- u_int8_t cfg_type;
+ uint8_t cfg_type;
/**
* PLV2_CONFIGURATION or PLV1_CONFIGURATION
return this->cfg_type;
}
-METHOD(cp_payload_t, get_identifier, u_int16_t,
+METHOD(cp_payload_t, get_identifier, uint16_t,
private_cp_payload_t *this)
{
return this->identifier;
}
METHOD(cp_payload_t, set_identifier, void,
- private_cp_payload_t *this, u_int16_t identifier)
+ private_cp_payload_t *this, uint16_t identifier)
{
this->identifier = identifier;
}
*
@param identifier identifier to set
*/
- void (*set_identifier) (cp_payload_t *this, u_int16_t identifier);
+ void (*set_identifier) (cp_payload_t *this, uint16_t identifier);
/**
* Get the configuration payload identifier (IKEv1 only).
*
* @return identifier
*/
- u_int16_t (*get_identifier) (cp_payload_t *this);
+ uint16_t (*get_identifier) (cp_payload_t *this);
/**
* Destroys an cp_payload_t object.
/**
* Next payload type.
*/
- u_int8_t next_payload;
+ uint8_t next_payload;
/**
* Critical flag.
/**
* Length of this payload.
*/
- u_int16_t payload_length;
+ uint16_t payload_length;
/**
* IKEv1 Domain of Interpretation
*/
- u_int32_t doi;
+ uint32_t doi;
/**
* Protocol ID.
*/
- u_int8_t protocol_id;
+ uint8_t protocol_id;
/**
* SPI Size.
*/
- u_int8_t spi_size;
+ uint8_t spi_size;
/**
* Number of SPI's.
*/
- u_int16_t spi_count;
+ uint16_t spi_count;
/**
* The contained SPI's.
}
METHOD(delete_payload_t, add_spi, void,
- private_delete_payload_t *this, u_int32_t spi)
+ private_delete_payload_t *this, uint32_t spi)
{
switch (this->protocol_id)
{
}
METHOD(delete_payload_t, set_ike_spi, void,
- private_delete_payload_t *this, u_int64_t spi_i, u_int64_t spi_r)
+ private_delete_payload_t *this, uint64_t spi_i, uint64_t spi_r)
{
free(this->spis.ptr);
this->spis = chunk_cat("cc", chunk_from_thing(spi_i),
}
METHOD(delete_payload_t, get_ike_spi, bool,
- private_delete_payload_t *this, u_int64_t *spi_i, u_int64_t *spi_r)
+ private_delete_payload_t *this, uint64_t *spi_i, uint64_t *spi_r)
{
if (this->protocol_id != PROTO_IKE ||
- this->spis.len < 2 * sizeof(u_int64_t))
+ this->spis.len < 2 * sizeof(uint64_t))
{
return FALSE;
}
- memcpy(spi_i, this->spis.ptr, sizeof(u_int64_t));
- memcpy(spi_r, this->spis.ptr + sizeof(u_int64_t), sizeof(u_int64_t));
+ memcpy(spi_i, this->spis.ptr, sizeof(uint64_t));
+ memcpy(spi_r, this->spis.ptr + sizeof(uint64_t), sizeof(uint64_t));
return TRUE;
}
} spi_enumerator_t;
METHOD(enumerator_t, spis_enumerate, bool,
- spi_enumerator_t *this, u_int32_t *spi)
+ spi_enumerator_t *this, uint32_t *spi)
{
if (this->spis.len >= sizeof(*spi))
{
{
spi_enumerator_t *e;
- if (this->spi_size != sizeof(u_int32_t))
+ if (this->spi_size != sizeof(uint32_t))
{
return enumerator_create_empty();
}
*
* @param spi spi to add
*/
- void (*add_spi) (delete_payload_t *this, u_int32_t spi);
+ void (*add_spi) (delete_payload_t *this, uint32_t spi);
/**
* Set the IKE SPIs for an IKEv1 delete.
* @param spi_i initiator SPI
* @param spi_r responder SPI
*/
- void (*set_ike_spi)(delete_payload_t *this, u_int64_t spi_i, u_int64_t spi_r);
+ void (*set_ike_spi)(delete_payload_t *this, uint64_t spi_i, uint64_t spi_r);
/**
* Get the IKE SPIs from an IKEv1 delete.
* @param spi_r responder SPI
* @return TRUE if SPIs extracted successfully
*/
- bool (*get_ike_spi)(delete_payload_t *this, u_int64_t *spi_i, u_int64_t *spi_r);
+ bool (*get_ike_spi)(delete_payload_t *this, uint64_t *spi_i, uint64_t *spi_r);
/**
* Get an enumerator over the SPIs in network order.
*
- * @return enumerator over SPIs, u_int32_t
+ * @return enumerator over SPIs, uint32_t
*/
enumerator_t *(*create_spi_enumerator) (delete_payload_t *this);
/**
* Next payload type.
*/
- u_int8_t next_payload;
+ uint8_t next_payload;
/**
* Critical flag.
/**
* Length of this payload.
*/
- u_int16_t payload_length;
+ uint16_t payload_length;
/**
* EAP message data, if available
METHOD(payload_t, verify, status_t,
private_eap_payload_t *this)
{
- u_int16_t length;
- u_int8_t code;
+ uint16_t length;
+ uint8_t code;
if (this->data.len < 4)
{
return 0;
}
-METHOD(eap_payload_t, get_identifier, u_int8_t,
+METHOD(eap_payload_t, get_identifier, uint8_t,
private_eap_payload_t *this)
{
if (this->data.len > 1)
* @return the new offset or 0 if failed
*/
static size_t extract_type(private_eap_payload_t *this, size_t offset,
- eap_type_t *type, u_int32_t *vendor)
+ eap_type_t *type, uint32_t *vendor)
{
if (this->data.len > offset)
{
}
METHOD(eap_payload_t, get_type, eap_type_t,
- private_eap_payload_t *this, u_int32_t *vendor)
+ private_eap_payload_t *this, uint32_t *vendor)
{
eap_type_t type;
} type_enumerator_t;
METHOD(enumerator_t, enumerate_types, bool,
- type_enumerator_t *this, eap_type_t *type, u_int32_t *vendor)
+ type_enumerator_t *this, eap_type_t *type, uint32_t *vendor)
{
this->offset = extract_type(this->payload, this->offset, type, vendor);
return this->offset;
{
type_enumerator_t *enumerator;
eap_type_t type;
- u_int32_t vendor;
+ uint32_t vendor;
size_t offset;
offset = extract_type(this, 4, &type, &vendor);
/*
* Described in header
*/
-eap_payload_t *eap_payload_create_code(eap_code_t code, u_int8_t identifier)
+eap_payload_t *eap_payload_create_code(eap_code_t code, uint8_t identifier)
{
chunk_t data;
/**
* Write the given type either expanded or not
*/
-static void write_type(bio_writer_t *writer, eap_type_t type, u_int32_t vendor,
+static void write_type(bio_writer_t *writer, eap_type_t type, uint32_t vendor,
bool expanded)
{
if (expanded)
/*
* Described in header
*/
-eap_payload_t *eap_payload_create_nak(u_int8_t identifier, eap_type_t type,
- u_int32_t vendor, bool expanded)
+eap_payload_t *eap_payload_create_nak(uint8_t identifier, eap_type_t type,
+ uint32_t vendor, bool expanded)
{
enumerator_t *enumerator;
eap_type_t reg_type;
- u_int32_t reg_vendor;
+ uint32_t reg_vendor;
bio_writer_t *writer;
chunk_t data;
bool added_any = FALSE, found_vendor = FALSE;
*
* @return unique identifier
*/
- u_int8_t (*get_identifier) (eap_payload_t *this);
+ uint8_t (*get_identifier) (eap_payload_t *this);
/**
* Get the EAP method type.
* @param vendor pointer receiving vendor identifier
* @return EAP method type, vendor specific if vendor != 0
*/
- eap_type_t (*get_type) (eap_payload_t *this, u_int32_t *vendor);
+ eap_type_t (*get_type) (eap_payload_t *this, uint32_t *vendor);
/**
* Enumerate the EAP method types contained in an EAP-Nak (i.e. get_type()
* returns EAP_NAK).
*
- * @return enumerator over (eap_type_t type, u_int32_t vendor)
+ * @return enumerator over (eap_type_t type, uint32_t vendor)
*/
enumerator_t* (*get_types) (eap_payload_t *this);
* @param identifier EAP identifier to use in payload
* @return eap_payload_t object
*/
-eap_payload_t *eap_payload_create_code(eap_code_t code, u_int8_t identifier);
+eap_payload_t *eap_payload_create_code(eap_code_t code, uint8_t identifier);
/**
* Creates an eap_payload_t EAP_RESPONSE containing an EAP_NAK.
* @param expanded TRUE to send an expanded Nak
* @return eap_payload_t object
*/
-eap_payload_t *eap_payload_create_nak(u_int8_t identifier, eap_type_t type,
- u_int32_t vendor, bool expanded);
+eap_payload_t *eap_payload_create_nak(uint8_t identifier, eap_type_t type,
+ uint32_t vendor, bool expanded);
#endif /** EAP_PAYLOAD_H_ @}*/
/**
* Representating an IKE_SPI field in an IKEv2 Header.
*
- * When generating the value of the u_int64_t pointing to
+ * When generating the value of the uint64_t pointing to
* is written (host and networ order is not changed).
*
- * When parsing 8 bytes are read and written into the u_int64_t pointing to.
+ * When parsing 8 bytes are read and written into the uint64_t pointing to.
*/
IKE_SPI,
* When generating, data are read from this offset in the
* data struct.
*/
- u_int32_t offset;
+ uint32_t offset;
};
#endif /** ENCODINGS_H_ @}*/
*
* @return fragment number
*/
- u_int16_t (*get_fragment_number)(encrypted_fragment_payload_t *this);
+ uint16_t (*get_fragment_number)(encrypted_fragment_payload_t *this);
/**
* Get the total number of fragments.
*
* @return total number of fragments
*/
- u_int16_t (*get_total_fragments)(encrypted_fragment_payload_t *this);
+ uint16_t (*get_total_fragments)(encrypted_fragment_payload_t *this);
/**
* Get the (decrypted) content of this payload.
* @return encrypted_fragment_payload_t object
*/
encrypted_fragment_payload_t *encrypted_fragment_payload_create_from_data(
- u_int16_t num, u_int16_t total, chunk_t data);
+ uint16_t num, uint16_t total, chunk_t data);
#endif /** ENCRYPTED_FRAGMENT_PAYLOAD_H_ @}*/
* next_payload means here the first payload of the
* contained, encrypted payload.
*/
- u_int8_t next_payload;
+ uint8_t next_payload;
/**
* Flags, including reserved bits
*/
- u_int8_t flags;
+ uint8_t flags;
/**
* Length of this payload
*/
- u_int16_t payload_length;
+ uint16_t payload_length;
/**
* Chunk containing the IV, plain, padding and ICV.
* the original encrypted payload, for all other fragments it MUST be set
* to zero.
*/
- u_int8_t next_payload;
+ uint8_t next_payload;
/**
* Flags, including reserved bits
*/
- u_int8_t flags;
+ uint8_t flags;
/**
* Length of this payload
*/
- u_int16_t payload_length;
+ uint16_t payload_length;
/**
* Chunk containing the IV, plain, padding and ICV.
/**
* Fragment number
*/
- u_int16_t fragment_number;
+ uint16_t fragment_number;
/**
* Total fragments
*/
- u_int16_t total_fragments;
+ uint16_t total_fragments;
/**
* AEAD transform to use
{
payload_t *current, *next;
enumerator_t *enumerator;
- u_int32_t *lenpos;
+ uint32_t *lenpos;
chunk_t chunk = chunk_empty;
enumerator = this->payloads->create_enumerator(this->payloads);
static chunk_t append_header(private_encrypted_payload_t *this, chunk_t assoc)
{
struct {
- u_int8_t next_payload;
- u_int8_t flags;
- u_int16_t length;
+ uint8_t next_payload;
+ uint8_t flags;
+ uint16_t length;
} __attribute__((packed)) header = {
.next_payload = this->next_payload,
.flags = this->flags,
/**
* Encrypts the data in plain and returns it in an allocated chunk.
*/
-static status_t encrypt_content(char *label, aead_t *aead, u_int64_t mid,
+static status_t encrypt_content(char *label, aead_t *aead, uint64_t mid,
chunk_t plain, chunk_t assoc, chunk_t *encrypted)
{
chunk_t iv, padding, icv, crypt;
}
METHOD(encrypted_payload_t, encrypt, status_t,
- private_encrypted_payload_t *this, u_int64_t mid, chunk_t assoc)
+ private_encrypted_payload_t *this, uint64_t mid, chunk_t assoc)
{
generator_t *generator;
chunk_t plain;
}
METHOD(encrypted_payload_t, encrypt_v1, status_t,
- private_encrypted_payload_t *this, u_int64_t mid, chunk_t iv)
+ private_encrypted_payload_t *this, uint64_t mid, chunk_t iv)
{
generator_t *generator;
chunk_t plain, padding;
return this->payload_length;
}
-METHOD(encrypted_fragment_payload_t, get_fragment_number, u_int16_t,
+METHOD(encrypted_fragment_payload_t, get_fragment_number, uint16_t,
private_encrypted_fragment_payload_t *this)
{
return this->fragment_number;
}
-METHOD(encrypted_fragment_payload_t, get_total_fragments, u_int16_t,
+METHOD(encrypted_fragment_payload_t, get_total_fragments, uint16_t,
private_encrypted_fragment_payload_t *this)
{
return this->total_fragments;
chunk_t assoc)
{
struct {
- u_int8_t next_payload;
- u_int8_t flags;
- u_int16_t length;
- u_int16_t fragment_number;
- u_int16_t total_fragments;
+ uint8_t next_payload;
+ uint8_t flags;
+ uint16_t length;
+ uint16_t fragment_number;
+ uint16_t total_fragments;
} __attribute__((packed)) header = {
.next_payload = this->next_payload,
.flags = this->flags,
}
METHOD(encrypted_payload_t, frag_encrypt, status_t,
- private_encrypted_fragment_payload_t *this, u_int64_t mid, chunk_t assoc)
+ private_encrypted_fragment_payload_t *this, uint64_t mid, chunk_t assoc)
{
status_t status;
* Described in header
*/
encrypted_fragment_payload_t *encrypted_fragment_payload_create_from_data(
- u_int16_t num, u_int16_t total, chunk_t plain)
+ uint16_t num, uint16_t total, chunk_t plain)
{
private_encrypted_fragment_payload_t *this;
* - FAILED if encryption failed
* - INVALID_STATE if aead not supplied, but needed
*/
- status_t (*encrypt) (encrypted_payload_t *this, u_int64_t mid,
+ status_t (*encrypt) (encrypted_payload_t *this, uint64_t mid,
chunk_t assoc);
/**
/**
* Priority
*/
- u_int32_t priority;
+ uint32_t priority;
/**
* Family
/**
* Helper functions to parse integer values
*/
-static status_t parse_uint8(u_int8_t **cur, u_int8_t *top, u_int8_t *val)
+static status_t parse_uint8(uint8_t **cur, uint8_t *top, uint8_t *val)
{
- if (*cur + sizeof(u_int8_t) > top)
+ if (*cur + sizeof(uint8_t) > top)
{
return FAILED;
}
- *val = *(u_int8_t*)*cur;
- *cur += sizeof(u_int8_t);
+ *val = *(uint8_t*)*cur;
+ *cur += sizeof(uint8_t);
return SUCCESS;
}
-static status_t parse_uint16(u_int8_t **cur, u_int8_t *top, u_int16_t *val)
+static status_t parse_uint16(uint8_t **cur, uint8_t *top, uint16_t *val)
{
- if (*cur + sizeof(u_int16_t) > top)
+ if (*cur + sizeof(uint16_t) > top)
{
return FAILED;
}
- *val = ntohs(*(u_int16_t*)*cur);
- *cur += sizeof(u_int16_t);
+ *val = ntohs(*(uint16_t*)*cur);
+ *cur += sizeof(uint16_t);
return SUCCESS;
}
-static status_t parse_uint32(u_int8_t **cur, u_int8_t *top, u_int32_t *val)
+static status_t parse_uint32(uint8_t **cur, uint8_t *top, uint32_t *val)
{
- if (*cur + sizeof(u_int32_t) > top)
+ if (*cur + sizeof(uint32_t) > top)
{
return FAILED;
}
- *val = ntohl(*(u_int32_t*)*cur);
- *cur += sizeof(u_int32_t);
+ *val = ntohl(*(uint32_t*)*cur);
+ *cur += sizeof(uint32_t);
return SUCCESS;
}
*/
static status_t parse_notification_data(private_endpoint_notify_t *this, chunk_t data)
{
- u_int8_t family, type, addr_family;
- u_int16_t port;
+ uint8_t family, type, addr_family;
+ uint16_t port;
chunk_t addr;
- u_int8_t *cur = data.ptr;
- u_int8_t *top = data.ptr + data.len;
+ uint8_t *cur = data.ptr;
+ uint8_t *top = data.ptr + data.len;
DBG3(DBG_IKE, "me_endpoint_data %B", &data);
{
chunk_t prio_chunk, family_chunk, type_chunk, port_chunk, addr_chunk;
chunk_t data;
- u_int32_t prio;
- u_int16_t port;
- u_int8_t family, type;
+ uint32_t prio;
+ uint16_t port;
+ uint8_t family, type;
prio = htonl(this->priority);
prio_chunk = chunk_from_thing(prio);
}
-METHOD(endpoint_notify_t, get_priority, u_int32_t,
+METHOD(endpoint_notify_t, get_priority, uint32_t,
private_endpoint_notify_t *this)
{
return this->priority;
}
METHOD(endpoint_notify_t, set_priority, void,
- private_endpoint_notify_t *this, u_int32_t priority)
+ private_endpoint_notify_t *this, uint32_t priority)
{
this->priority = priority;
}
*
* @return priority
*/
- u_int32_t (*get_priority) (endpoint_notify_t *this);
+ uint32_t (*get_priority) (endpoint_notify_t *this);
/**
* Sets the priority of this endpoint.
*
* @param priority priority
*/
- void (*set_priority) (endpoint_notify_t *this, u_int32_t priority);
+ void (*set_priority) (endpoint_notify_t *this, uint32_t priority);
/**
* Returns the endpoint type of this endpoint.
/**
* Next payload type.
*/
- u_int8_t next_payload;
+ uint8_t next_payload;
/**
* Reserved byte
*/
- u_int8_t reserved;
+ uint8_t reserved;
/**
* Length of this payload.
*/
- u_int16_t payload_length;
+ uint16_t payload_length;
/**
* Fragment ID.
*/
- u_int16_t fragment_id;
+ uint16_t fragment_id;
/**
* Fragment number.
*/
- u_int8_t fragment_number;
+ uint8_t fragment_number;
/**
* Flags
*/
- u_int8_t flags;
+ uint8_t flags;
/**
* The contained fragment data.
return this->payload_length;
}
-METHOD(fragment_payload_t, get_id, u_int16_t,
+METHOD(fragment_payload_t, get_id, uint16_t,
private_fragment_payload_t *this)
{
return this->fragment_id;
}
-METHOD(fragment_payload_t, get_number, u_int8_t,
+METHOD(fragment_payload_t, get_number, uint8_t,
private_fragment_payload_t *this)
{
return this->fragment_number;
/*
* Described in header
*/
-fragment_payload_t *fragment_payload_create_from_data(u_int8_t num, bool last,
+fragment_payload_t *fragment_payload_create_from_data(uint8_t num, bool last,
chunk_t data)
{
private_fragment_payload_t *this;
*
* @return fragment ID
*/
- u_int16_t (*get_id)(fragment_payload_t *this);
+ uint16_t (*get_id)(fragment_payload_t *this);
/**
* Get the fragment number. Defines the order of the fragments.
*
* @return fragment number
*/
- u_int8_t (*get_number)(fragment_payload_t *this);
+ uint8_t (*get_number)(fragment_payload_t *this);
/**
* Check if this is the last fragment.
* @param data fragment data (gets cloned)
* @return fragment_payload_t object
*/
-fragment_payload_t *fragment_payload_create_from_data(u_int8_t num, bool last,
+fragment_payload_t *fragment_payload_create_from_data(uint8_t num, bool last,
chunk_t data);
#endif /** FRAGMENT_PAYLOAD_H_ @}*/
/**
* Next payload type.
*/
- u_int8_t next_payload;
+ uint8_t next_payload;
/**
* Reserved byte
*/
- u_int8_t reserved;
+ uint8_t reserved;
/**
* Length of this payload.
*/
- u_int16_t payload_length;
+ uint16_t payload_length;
/**
* The contained hash value.
/**
* Next payload type.
*/
- u_int8_t next_payload;
+ uint8_t next_payload;
/**
* Critical flag.
/**
* Reserved bytes
*/
- u_int8_t reserved_byte[3];
+ uint8_t reserved_byte[3];
/**
* Length of this payload.
*/
- u_int16_t payload_length;
+ uint16_t payload_length;
/**
* Type of the ID Data.
*/
- u_int8_t id_type;
+ uint8_t id_type;
/**
* The contained id data value.
/**
* Tunneled protocol ID for IKEv1 quick modes.
*/
- u_int8_t protocol_id;
+ uint8_t protocol_id;
/**
* Tunneled port for IKEv1 quick modes.
*/
- u_int16_t port;
+ uint16_t port;
/**
* one of PLV2_ID_INITIATOR, PLV2_ID_RESPONDER, IDv1 and PLV1_NAT_OA
METHOD(id_payload_t, get_encoded, chunk_t,
private_id_payload_t *this)
{
- u_int16_t port = htons(this->port);
+ uint16_t port = htons(this->port);
return chunk_cat("cccc", chunk_from_thing(this->id_type),
chunk_from_thing(this->protocol_id),
chunk_from_thing(port), this->id_data);
id_payload_t *id_payload_create_from_ts(traffic_selector_t *ts)
{
private_id_payload_t *this;
- u_int8_t mask;
+ uint8_t mask;
host_t *net;
this = (private_id_payload_t*)id_payload_create(PLV1_ID);
}
else if (ts->to_subnet(ts, &net, &mask))
{
- u_int8_t netmask[16], len, byte;
+ uint8_t netmask[16], len, byte;
if (ts->get_type(ts) == TS_IPV4_ADDR_RANGE)
{
/**
* SPI of the initiator.
*/
- u_int64_t initiator_spi;
+ uint64_t initiator_spi;
/**
* SPI of the responder.
*/
- u_int64_t responder_spi;
+ uint64_t responder_spi;
/**
* Next payload type.
*/
- u_int8_t next_payload;
+ uint8_t next_payload;
/**
* IKE major version.
*/
- u_int8_t maj_version;
+ uint8_t maj_version;
/**
* IKE minor version.
*/
- u_int8_t min_version;
+ uint8_t min_version;
/**
* Exchange type .
*/
- u_int8_t exchange_type;
+ uint8_t exchange_type;
/**
* Flags of the Message.
/**
* Associated Message-ID.
*/
- u_int32_t message_id;
+ uint32_t message_id;
/**
* Length of the whole IKEv2-Message (header and all payloads).
*/
- u_int32_t length;
+ uint32_t length;
};
ENUM_BEGIN(exchange_type_names, ID_PROT, TRANSACTION,
return this->length;
}
-METHOD(ike_header_t, get_initiator_spi, u_int64_t,
+METHOD(ike_header_t, get_initiator_spi, uint64_t,
private_ike_header_t *this)
{
return this->initiator_spi;
}
METHOD(ike_header_t, set_initiator_spi, void,
- private_ike_header_t *this, u_int64_t initiator_spi)
+ private_ike_header_t *this, uint64_t initiator_spi)
{
this->initiator_spi = initiator_spi;
}
-METHOD(ike_header_t, get_responder_spi, u_int64_t,
+METHOD(ike_header_t, get_responder_spi, uint64_t,
private_ike_header_t *this)
{
return this->responder_spi;
}
METHOD(ike_header_t, set_responder_spi, void,
- private_ike_header_t *this, u_int64_t responder_spi)
+ private_ike_header_t *this, uint64_t responder_spi)
{
this->responder_spi = responder_spi;
}
-METHOD(ike_header_t, get_maj_version, u_int8_t,
+METHOD(ike_header_t, get_maj_version, uint8_t,
private_ike_header_t *this)
{
return this->maj_version;
}
METHOD(ike_header_t, set_maj_version, void,
- private_ike_header_t *this, u_int8_t major)
+ private_ike_header_t *this, uint8_t major)
{
this->maj_version = major;
}
-METHOD(ike_header_t, get_min_version, u_int8_t,
+METHOD(ike_header_t, get_min_version, uint8_t,
private_ike_header_t *this)
{
return this->min_version;
}
METHOD(ike_header_t, set_min_version, void,
- private_ike_header_t *this, u_int8_t minor)
+ private_ike_header_t *this, uint8_t minor)
{
this->min_version = minor;
}
this->flags.authonly = authonly;
}
-METHOD(ike_header_t, get_exchange_type, u_int8_t,
+METHOD(ike_header_t, get_exchange_type, uint8_t,
private_ike_header_t *this)
{
return this->exchange_type;
}
METHOD(ike_header_t, set_exchange_type, void,
- private_ike_header_t *this, u_int8_t exchange_type)
+ private_ike_header_t *this, uint8_t exchange_type)
{
this->exchange_type = exchange_type;
}
-METHOD(ike_header_t, get_message_id, u_int32_t,
+METHOD(ike_header_t, get_message_id, uint32_t,
private_ike_header_t *this)
{
return this->message_id;
}
METHOD(ike_header_t, set_message_id, void,
- private_ike_header_t *this, u_int32_t message_id)
+ private_ike_header_t *this, uint32_t message_id)
{
this->message_id = message_id;
}
*
* @return initiator_spi
*/
- u_int64_t (*get_initiator_spi) (ike_header_t *this);
+ uint64_t (*get_initiator_spi) (ike_header_t *this);
/**
* Set the initiator spi.
*
* @param initiator_spi initiator_spi
*/
- void (*set_initiator_spi) (ike_header_t *this, u_int64_t initiator_spi);
+ void (*set_initiator_spi) (ike_header_t *this, uint64_t initiator_spi);
/**
* Get the responder spi.
*
* @return responder_spi
*/
- u_int64_t (*get_responder_spi) (ike_header_t *this);
+ uint64_t (*get_responder_spi) (ike_header_t *this);
/**
* Set the responder spi.
*
* @param responder_spi responder_spi
*/
- void (*set_responder_spi) (ike_header_t *this, u_int64_t responder_spi);
+ void (*set_responder_spi) (ike_header_t *this, uint64_t responder_spi);
/**
* Get the major version.
*
* @return major version
*/
- u_int8_t (*get_maj_version) (ike_header_t *this);
+ uint8_t (*get_maj_version) (ike_header_t *this);
/**
* Set the major version.
*
* @param major major version
*/
- void (*set_maj_version) (ike_header_t *this, u_int8_t major);
+ void (*set_maj_version) (ike_header_t *this, uint8_t major);
/**
* Get the minor version.
*
* @return minor version
*/
- u_int8_t (*get_min_version) (ike_header_t *this);
+ uint8_t (*get_min_version) (ike_header_t *this);
/**
* Set the minor version.
*
* @param minor minor version
*/
- void (*set_min_version) (ike_header_t *this, u_int8_t minor);
+ void (*set_min_version) (ike_header_t *this, uint8_t minor);
/**
* Get the response flag.
*
* @return exchange type
*/
- u_int8_t (*get_exchange_type) (ike_header_t *this);
+ uint8_t (*get_exchange_type) (ike_header_t *this);
/**
* Set the exchange type.
*
* @param exchange_type exchange type
*/
- void (*set_exchange_type) (ike_header_t *this, u_int8_t exchange_type);
+ void (*set_exchange_type) (ike_header_t *this, uint8_t exchange_type);
/**
* Get the message id.
*
* @return message id
*/
- u_int32_t (*get_message_id) (ike_header_t *this);
+ uint32_t (*get_message_id) (ike_header_t *this);
/**
* Set the message id.
*
* @param initiator_spi message id
*/
- void (*set_message_id) (ike_header_t *this, u_int32_t message_id);
+ void (*set_message_id) (ike_header_t *this, uint32_t message_id);
/**
* Destroys a ike_header_t object.
/**
* Next payload type.
*/
- u_int8_t next_payload;
+ uint8_t next_payload;
/**
* Critical flag.
/**
* Reserved bytes
*/
- u_int8_t reserved_byte[2];
+ uint8_t reserved_byte[2];
/**
* Length of this payload.
*/
- u_int16_t payload_length;
+ uint16_t payload_length;
/**
* DH Group Number.
*/
- u_int16_t dh_group_number;
+ uint16_t dh_group_number;
/**
* Key Exchange Data of this KE payload.
/**
* Next payload type.
*/
- u_int8_t next_payload;
+ uint8_t next_payload;
/**
* Critical flag.
/**
* Length of this payload.
*/
- u_int16_t payload_length;
+ uint16_t payload_length;
/**
* The contained nonce value.
/**
* Next payload type.
*/
- u_int8_t next_payload;
+ uint8_t next_payload;
/**
* Critical flag.
/**
* Length of this payload.
*/
- u_int16_t payload_length;
+ uint16_t payload_length;
/**
* Domain of interpretation, IKEv1 only.
*/
- u_int32_t doi;
+ uint32_t doi;
/**
* Protocol id.
*/
- u_int8_t protocol_id;
+ uint8_t protocol_id;
/**
* Spi size.
*/
- u_int8_t spi_size;
+ uint8_t spi_size;
/**
* Notify message type.
*/
- u_int16_t notify_type;
+ uint16_t notify_type;
/**
* Security parameter index (spi).
return this->payload_length;
}
-METHOD(notify_payload_t, get_protocol_id, u_int8_t,
+METHOD(notify_payload_t, get_protocol_id, uint8_t,
private_notify_payload_t *this)
{
return this->protocol_id;
}
METHOD(notify_payload_t, set_protocol_id, void,
- private_notify_payload_t *this, u_int8_t protocol_id)
+ private_notify_payload_t *this, uint8_t protocol_id)
{
this->protocol_id = protocol_id;
}
this->notify_type = notify_type;
}
-METHOD(notify_payload_t, get_spi, u_int32_t,
+METHOD(notify_payload_t, get_spi, uint32_t,
private_notify_payload_t *this)
{
switch (this->protocol_id)
case PROTO_ESP:
if (this->spi.len == 4)
{
- return *((u_int32_t*)this->spi.ptr);
+ return *((uint32_t*)this->spi.ptr);
}
default:
break;
}
METHOD(notify_payload_t, set_spi, void,
- private_notify_payload_t *this, u_int32_t spi)
+ private_notify_payload_t *this, uint32_t spi)
{
chunk_free(&this->spi);
switch (this->protocol_id)
case PROTO_AH:
case PROTO_ESP:
this->spi = chunk_alloc(4);
- *((u_int32_t*)this->spi.ptr) = spi;
+ *((uint32_t*)this->spi.ptr) = spi;
break;
default:
break;
*
* @return protocol id of this payload
*/
- u_int8_t (*get_protocol_id) (notify_payload_t *this);
+ uint8_t (*get_protocol_id) (notify_payload_t *this);
/**
* Sets the protocol id of this payload.
*
* @param protocol_id protocol id to set
*/
- void (*set_protocol_id) (notify_payload_t *this, u_int8_t protocol_id);
+ void (*set_protocol_id) (notify_payload_t *this, uint8_t protocol_id);
/**
* Gets the notify message type of this payload.
*
* @return SPI value
*/
- u_int32_t (*get_spi) (notify_payload_t *this);
+ uint32_t (*get_spi) (notify_payload_t *this);
/**
* Sets the spi of this payload.
*
* @param spi SPI value
*/
- void (*set_spi) (notify_payload_t *this, u_int32_t spi);
+ void (*set_spi) (notify_payload_t *this, uint32_t spi);
/**
* Returns the currently set spi of this payload.
/**
* See header.
*/
-bool payload_is_known(payload_type_t type, u_int8_t maj_ver)
+bool payload_is_known(payload_type_t type, uint8_t maj_ver)
{
if (type >= PL_HEADER)
{
* @param maj_ver major IKE version (use 0 to skip version check)
* @return FALSE if payload type handled as unknown payload
*/
-bool payload_is_known(payload_type_t type, u_int8_t maj_ver);
+bool payload_is_known(payload_type_t type, uint8_t maj_ver);
/**
* Get the value field in a payload using encoding rules.
/**
* Next payload type.
*/
- u_int8_t next_payload;
+ uint8_t next_payload;
/**
* reserved byte
*/
- u_int8_t reserved;
+ uint8_t reserved;
/**
* Length of this payload.
*/
- u_int16_t proposal_length;
+ uint16_t proposal_length;
/**
* Proposal number.
*/
- u_int8_t proposal_number;
+ uint8_t proposal_number;
/**
* Protocol ID.
*/
- u_int8_t protocol_id;
+ uint8_t protocol_id;
/**
* SPI size of the following SPI.
*/
- u_int8_t spi_size;
+ uint8_t spi_size;
/**
* Number of transforms.
*/
- u_int8_t transforms_count;
+ uint8_t transforms_count;
/**
* SPI is stored as chunk.
}
METHOD(proposal_substructure_t, set_proposal_number, void,
- private_proposal_substructure_t *this,u_int8_t proposal_number)
+ private_proposal_substructure_t *this,uint8_t proposal_number)
{
this->proposal_number = proposal_number;
}
-METHOD(proposal_substructure_t, get_proposal_number, u_int8_t,
+METHOD(proposal_substructure_t, get_proposal_number, uint8_t,
private_proposal_substructure_t *this)
{
return this->proposal_number;
}
METHOD(proposal_substructure_t, set_protocol_id, void,
- private_proposal_substructure_t *this,u_int8_t protocol_id)
+ private_proposal_substructure_t *this,uint8_t protocol_id)
{
this->protocol_id = protocol_id;
}
-METHOD(proposal_substructure_t, get_protocol_id, u_int8_t,
+METHOD(proposal_substructure_t, get_protocol_id, uint8_t,
private_proposal_substructure_t *this)
{
return this->protocol_id;
}
METHOD(proposal_substructure_t, get_cpi, bool,
- private_proposal_substructure_t *this, u_int16_t *cpi)
+ private_proposal_substructure_t *this, uint16_t *cpi)
{
transform_substructure_t *transform;
{
transform_attribute_t *tattr;
enumerator_t *enumerator;
- u_int16_t key_length = 0;
+ uint16_t key_length = 0;
enumerator = transform->create_attribute_enumerator(transform);
while (enumerator->enumerate(enumerator, &tattr))
* Map IKEv1 to IKEv2 algorithms
*/
typedef struct {
- u_int16_t ikev1;
- u_int16_t ikev2;
+ uint16_t ikev1;
+ uint16_t ikev2;
} algo_map_t;
/**
/**
* Map an IKEv1 to an IKEv2 identifier
*/
-static u_int16_t ikev2_from_ikev1(algo_map_t *map, int count, u_int16_t def,
- u_int16_t value)
+static uint16_t ikev2_from_ikev1(algo_map_t *map, int count, uint16_t def,
+ uint16_t value)
{
int i;
/**
* Map an IKEv2 to an IKEv1 identifier
*/
-static u_int16_t ikev1_from_ikev2(algo_map_t *map, int count, u_int16_t value)
+static uint16_t ikev1_from_ikev2(algo_map_t *map, int count, uint16_t value)
{
int i;
/**
* Get IKEv2 algorithm from IKEv1 identifier
*/
-static u_int16_t get_alg_from_ikev1(transform_type_t type, u_int16_t value)
+static uint16_t get_alg_from_ikev1(transform_type_t type, uint16_t value)
{
switch (type)
{
/**
* Get IKEv1 algorithm from IKEv2 identifier
*/
-static u_int16_t get_ikev1_from_alg(transform_type_t type, u_int16_t value)
+static uint16_t get_ikev1_from_alg(transform_type_t type, uint16_t value)
{
switch (type)
{
/**
* Get IKEv2 algorithm from IKEv1 ESP/AH transform ID
*/
-static u_int16_t get_alg_from_ikev1_transid(transform_type_t type,
- u_int16_t value)
+static uint16_t get_alg_from_ikev1_transid(transform_type_t type,
+ uint16_t value)
{
switch (type)
{
/**
* Get IKEv1 ESP/AH transform ID from IKEv2 identifier
*/
-static u_int16_t get_ikev1_transid_from_alg(transform_type_t type,
- u_int16_t value)
+static uint16_t get_ikev1_transid_from_alg(transform_type_t type,
+ uint16_t value)
{
switch (type)
{
/**
* Get IKEv1 authentication algorithm from IKEv2 identifier
*/
-static u_int16_t get_alg_from_ikev1_auth(u_int16_t value)
+static uint16_t get_alg_from_ikev1_auth(uint16_t value)
{
return ikev2_from_ikev1(map_auth, countof(map_auth), AUTH_UNDEFINED, value);
}
/**
* Get IKEv1 authentication algorithm from IKEv2 identifier
*/
-static u_int16_t get_ikev1_auth_from_alg(u_int16_t value)
+static uint16_t get_ikev1_auth_from_alg(uint16_t value)
{
return ikev1_from_ikev2(map_auth, countof(map_auth), value);
}
/**
* Get IKEv1 authentication attribute from auth_method_t
*/
-static u_int16_t get_ikev1_auth(auth_method_t method)
+static uint16_t get_ikev1_auth(auth_method_t method)
{
switch (method)
{
/**
* Get IKEv1 encapsulation mode
*/
-static u_int16_t get_ikev1_mode(ipsec_mode_t mode, encap_t udp)
+static uint16_t get_ikev1_mode(ipsec_mode_t mode, encap_t udp)
{
switch (mode)
{
transform_attribute_type_t type;
transform_attribute_t *tattr;
enumerator_t *enumerator;
- u_int16_t value, key_length = 0;
- u_int16_t encr = ENCR_UNDEFINED;
+ uint16_t value, key_length = 0;
+ uint16_t encr = ENCR_UNDEFINED;
enumerator = transform->create_attribute_enumerator(transform);
while (enumerator->enumerate(enumerator, &tattr))
transform_attribute_type_t type;
transform_attribute_t *tattr;
enumerator_t *enumerator;
- u_int16_t encr, value, key_length = 0;
+ uint16_t encr, value, key_length = 0;
enumerator = transform->create_attribute_enumerator(transform);
while (enumerator->enumerate(enumerator, &tattr))
transform_substructure_t *transform;
enumerator_t *enumerator;
proposal_t *proposal = NULL;
- u_int64_t spi = 0;
+ uint64_t spi = 0;
switch (this->spi.len)
{
case 4:
- spi = *((u_int32_t*)this->spi.ptr);
+ spi = *((uint32_t*)this->spi.ptr);
break;
case 8:
- spi = *((u_int64_t*)this->spi.ptr);
+ spi = *((uint64_t*)this->spi.ptr);
break;
default:
break;
/**
* Get an attribute from any transform, 0 if not found
*/
-static u_int64_t get_attr(private_proposal_substructure_t *this,
+static uint64_t get_attr(private_proposal_substructure_t *this,
transform_attribute_type_t type)
{
enumerator_t *transforms, *attributes;
/**
* Look up a lifetime duration of a given kind in all transforms
*/
-static u_int64_t get_life_duration(private_proposal_substructure_t *this,
+static uint64_t get_life_duration(private_proposal_substructure_t *this,
transform_attribute_type_t type_attr, ikev1_life_type_t type,
transform_attribute_type_t dur_attr)
{
return 0;
}
-METHOD(proposal_substructure_t, get_lifetime, u_int32_t,
+METHOD(proposal_substructure_t, get_lifetime, uint32_t,
private_proposal_substructure_t *this)
{
- u_int32_t duration;
+ uint32_t duration;
switch (this->protocol_id)
{
}
}
-METHOD(proposal_substructure_t, get_lifebytes, u_int64_t,
+METHOD(proposal_substructure_t, get_lifebytes, uint64_t,
private_proposal_substructure_t *this)
{
switch (this->protocol_id)
* Add an IKEv1 IKE proposal to the substructure
*/
static void set_from_proposal_v1_ike(private_proposal_substructure_t *this,
- proposal_t *proposal, u_int32_t lifetime,
+ proposal_t *proposal, uint32_t lifetime,
auth_method_t method, int number)
{
transform_substructure_t *transform;
- u_int16_t alg, key_size;
+ uint16_t alg, key_size;
enumerator_t *enumerator;
transform = transform_substructure_create_type(PLV1_TRANSFORM_SUBSTRUCTURE,
* Add an IKEv1 ESP/AH proposal to the substructure
*/
static void set_from_proposal_v1(private_proposal_substructure_t *this,
- proposal_t *proposal, u_int32_t lifetime, u_int64_t lifebytes,
+ proposal_t *proposal, uint32_t lifetime, uint64_t lifebytes,
ipsec_mode_t mode, encap_t udp, int number)
{
transform_substructure_t *transform = NULL;
- u_int16_t alg, transid, key_size;
+ uint16_t alg, transid, key_size;
enumerator_t *enumerator;
enumerator = proposal->create_enumerator(proposal, ENCRYPTION_ALGORITHM);
proposal_t *proposal)
{
transform_substructure_t *transform;
- u_int16_t alg, key_size;
+ uint16_t alg, key_size;
enumerator_t *enumerator;
/* encryption algorithm is only available in ESP */
*/
static void set_data(private_proposal_substructure_t *this, proposal_t *proposal)
{
- u_int64_t spi64;
- u_int32_t spi32;
+ uint64_t spi64;
+ uint32_t spi32;
/* add SPI, if necessary */
switch (proposal->get_protocol(proposal))
* See header.
*/
proposal_substructure_t *proposal_substructure_create_from_proposal_v1(
- proposal_t *proposal, u_int32_t lifetime, u_int64_t lifebytes,
+ proposal_t *proposal, uint32_t lifetime, uint64_t lifebytes,
auth_method_t auth, ipsec_mode_t mode, encap_t udp)
{
private_proposal_substructure_t *this;
* See header.
*/
proposal_substructure_t *proposal_substructure_create_from_proposals_v1(
- linked_list_t *proposals, u_int32_t lifetime, u_int64_t lifebytes,
+ linked_list_t *proposals, uint32_t lifetime, uint64_t lifebytes,
auth_method_t auth, ipsec_mode_t mode, encap_t udp)
{
private_proposal_substructure_t *this = NULL;
* See header.
*/
proposal_substructure_t *proposal_substructure_create_for_ipcomp_v1(
- u_int32_t lifetime, u_int64_t lifebytes, u_int16_t cpi,
- ipsec_mode_t mode, encap_t udp, u_int8_t proposal_number)
+ uint32_t lifetime, uint64_t lifebytes, uint16_t cpi,
+ ipsec_mode_t mode, encap_t udp, uint8_t proposal_number)
{
private_proposal_substructure_t *this;
transform_substructure_t *transform;
* @param id proposal number to set
*/
void (*set_proposal_number) (proposal_substructure_t *this,
- u_int8_t proposal_number);
+ uint8_t proposal_number);
/**
* get proposal number of current proposal.
*
* @return proposal number of current proposal substructure.
*/
- u_int8_t (*get_proposal_number) (proposal_substructure_t *this);
+ uint8_t (*get_proposal_number) (proposal_substructure_t *this);
/**
* Sets the protocol id of current proposal.
* @param id protocol id to set
*/
void (*set_protocol_id) (proposal_substructure_t *this,
- u_int8_t protocol_id);
+ uint8_t protocol_id);
/**
* get protocol id of current proposal.
*
* @return protocol id of current proposal substructure.
*/
- u_int8_t (*get_protocol_id) (proposal_substructure_t *this);
+ uint8_t (*get_protocol_id) (proposal_substructure_t *this);
/**
* Sets the next_payload field of this substructure
* @param cpi the CPI if a supported algorithm is proposed
* @return TRUE if a supported algorithm is proposed
*/
- bool (*get_cpi) (proposal_substructure_t *this, u_int16_t *cpi);
+ bool (*get_cpi) (proposal_substructure_t *this, uint16_t *cpi);
/**
* Get proposals contained in a propsal_substructure_t.
*
* @return lifetime, in seconds
*/
- u_int32_t (*get_lifetime)(proposal_substructure_t *this);
+ uint32_t (*get_lifetime)(proposal_substructure_t *this);
/**
* Get the (shortest) life duration of a proposal (IKEv1 only).
*
* @return life duration, in bytes
*/
- u_int64_t (*get_lifebytes)(proposal_substructure_t *this);
+ uint64_t (*get_lifebytes)(proposal_substructure_t *this);
/**
* Get the first authentication method from the proposal (IKEv1 only).
* @return proposal_substructure_t object PLV1_PROPOSAL_SUBSTRUCTURE
*/
proposal_substructure_t *proposal_substructure_create_from_proposal_v1(
- proposal_t *proposal, u_int32_t lifetime, u_int64_t lifebytes,
+ proposal_t *proposal, uint32_t lifetime, uint64_t lifebytes,
auth_method_t auth, ipsec_mode_t mode, encap_t udp);
/**
* @return IKEv1 proposal_substructure_t PLV1_PROPOSAL_SUBSTRUCTURE
*/
proposal_substructure_t *proposal_substructure_create_from_proposals_v1(
- linked_list_t *proposals, u_int32_t lifetime, u_int64_t lifebytes,
+ linked_list_t *proposals, uint32_t lifetime, uint64_t lifebytes,
auth_method_t auth, ipsec_mode_t mode, encap_t udp);
/**
* @return IKEv1 proposal_substructure_t PLV1_PROPOSAL_SUBSTRUCTURE
*/
proposal_substructure_t *proposal_substructure_create_for_ipcomp_v1(
- u_int32_t lifetime, u_int64_t lifebytes, u_int16_t cpi,
- ipsec_mode_t mode, encap_t udp, u_int8_t proposal_number);
+ uint32_t lifetime, uint64_t lifebytes, uint16_t cpi,
+ ipsec_mode_t mode, encap_t udp, uint8_t proposal_number);
#endif /** PROPOSAL_SUBSTRUCTURE_H_ @}*/
/**
* Next payload type.
*/
- u_int8_t next_payload;
+ uint8_t next_payload;
/**
* Critical flag.
/**
* Length of this payload.
*/
- u_int16_t payload_length;
+ uint16_t payload_length;
/**
* Proposals in this payload are stored in a linked_list_t.
/**
* IKEv1 DOI
*/
- u_int32_t doi;
+ uint32_t doi;
/**
* IKEv1 situation
*/
- u_int32_t situation;
+ uint32_t situation;
};
/**
}
METHOD(sa_payload_t, get_ipcomp_proposals, linked_list_t*,
- private_sa_payload_t *this, u_int16_t *cpi)
+ private_sa_payload_t *this, uint16_t *cpi)
{
int current_proposal = -1, unsupported_proposal = -1;
enumerator_t *enumerator;
enumerator = this->proposals->create_enumerator(this->proposals);
while (enumerator->enumerate(enumerator, &substruct))
{
- u_int8_t proposal_number = substruct->get_proposal_number(substruct);
- u_int8_t protocol_id = substruct->get_protocol_id(substruct);
+ uint8_t proposal_number = substruct->get_proposal_number(substruct);
+ uint8_t protocol_id = substruct->get_protocol_id(substruct);
if (proposal_number == unsupported_proposal)
{
return this->proposals->create_enumerator(this->proposals);
}
-METHOD(sa_payload_t, get_lifetime, u_int32_t,
+METHOD(sa_payload_t, get_lifetime, uint32_t,
private_sa_payload_t *this)
{
proposal_substructure_t *substruct;
enumerator_t *enumerator;
- u_int32_t lifetime = 0;
+ uint32_t lifetime = 0;
enumerator = this->proposals->create_enumerator(this->proposals);
if (enumerator->enumerate(enumerator, &substruct))
return lifetime;
}
-METHOD(sa_payload_t, get_lifebytes, u_int64_t,
+METHOD(sa_payload_t, get_lifebytes, uint64_t,
private_sa_payload_t *this)
{
proposal_substructure_t *substruct;
enumerator_t *enumerator;
- u_int64_t lifebytes = 0;
+ uint64_t lifebytes = 0;
enumerator = this->proposals->create_enumerator(this->proposals);
if (enumerator->enumerate(enumerator, &substruct))
* Described in header.
*/
sa_payload_t *sa_payload_create_from_proposals_v1(linked_list_t *proposals,
- u_int32_t lifetime, u_int64_t lifebytes,
+ uint32_t lifetime, uint64_t lifebytes,
auth_method_t auth, ipsec_mode_t mode,
- encap_t udp, u_int16_t cpi)
+ encap_t udp, uint16_t cpi)
{
proposal_substructure_t *substruct;
private_sa_payload_t *this;
substruct->set_is_last_proposal(substruct, FALSE);
if (cpi)
{
- u_int8_t proposal_number = substruct->get_proposal_number(substruct);
+ uint8_t proposal_number = substruct->get_proposal_number(substruct);
substruct = proposal_substructure_create_for_ipcomp_v1(lifetime,
lifebytes, cpi, mode, udp, proposal_number);
* Described in header.
*/
sa_payload_t *sa_payload_create_from_proposal_v1(proposal_t *proposal,
- u_int32_t lifetime, u_int64_t lifebytes,
+ uint32_t lifetime, uint64_t lifebytes,
auth_method_t auth, ipsec_mode_t mode,
- encap_t udp, u_int16_t cpi)
+ encap_t udp, uint16_t cpi)
{
private_sa_payload_t *this;
linked_list_t *proposals;
* @param cpi the CPI of the first IPComp (sub)proposal
* @return a list containing proposal_ts
*/
- linked_list_t *(*get_ipcomp_proposals) (sa_payload_t *this, u_int16_t *cpi);
+ linked_list_t *(*get_ipcomp_proposals) (sa_payload_t *this, uint16_t *cpi);
/**
* Get the (shortest) lifetime of a proposal (IKEv1 only).
*
* @return lifetime, in seconds
*/
- u_int32_t (*get_lifetime)(sa_payload_t *this);
+ uint32_t (*get_lifetime)(sa_payload_t *this);
/**
* Get the (shortest) life duration of a proposal (IKEv1 only).
*
* @return life duration, in bytes
*/
- u_int64_t (*get_lifebytes)(sa_payload_t *this);
+ uint64_t (*get_lifebytes)(sa_payload_t *this);
/**
* Get the first authentication method from the proposal (IKEv1 only).
* @return sa_payload_t object
*/
sa_payload_t *sa_payload_create_from_proposals_v1(linked_list_t *proposals,
- u_int32_t lifetime, u_int64_t lifebytes,
+ uint32_t lifetime, uint64_t lifebytes,
auth_method_t auth, ipsec_mode_t mode, encap_t udp,
- u_int16_t cpi);
+ uint16_t cpi);
/**
* Creates an IKEv1 sa_payload_t object from a single proposal.
* @return sa_payload_t object
*/
sa_payload_t *sa_payload_create_from_proposal_v1(proposal_t *proposal,
- u_int32_t lifetime, u_int64_t lifebytes,
+ uint32_t lifetime, uint64_t lifebytes,
auth_method_t auth, ipsec_mode_t mode, encap_t udp,
- u_int16_t cpi);
+ uint16_t cpi);
#endif /** SA_PAYLOAD_H_ @}*/
/**
* Type of traffic selector.
*/
- u_int8_t ts_type;
+ uint8_t ts_type;
/**
* IP Protocol ID.
*/
- u_int8_t ip_protocol_id;
+ uint8_t ip_protocol_id;
/**
* Length of this payload.
*/
- u_int16_t payload_length;
+ uint16_t payload_length;
/**
* Start port number.
*/
- u_int16_t start_port;
+ uint16_t start_port;
/**
* End port number.
*/
- u_int16_t end_port;
+ uint16_t end_port;
/**
* Starting address.
* @return type of traffic selector
*
*/
- u_int8_t (*get_protocol_id) (traffic_selector_substructure_t *this);
+ uint8_t (*get_protocol_id) (traffic_selector_substructure_t *this);
/**
* Set the IP protocol ID of Traffic selector
* @param protocol_id protocol ID of traffic selector
*/
void (*set_protocol_id) (traffic_selector_substructure_t *this,
- u_int8_t protocol_id);
+ uint8_t protocol_id);
/**
* Get the start port and address as host_t object.
/**
* Type of the attribute.
*/
- u_int16_t attribute_type;
+ uint16_t attribute_type;
/**
* Attribute Length if attribute_format is 0, attribute Value otherwise.
*/
- u_int16_t attribute_length_or_value;
+ uint16_t attribute_length_or_value;
/**
* Attribute value as chunk if attribute_format is 0 (FALSE).
return this->attribute_value;
}
-METHOD(transform_attribute_t, get_value, u_int64_t,
+METHOD(transform_attribute_t, get_value, uint64_t,
private_transform_attribute_t *this)
{
- u_int64_t value = 0;
+ uint64_t value = 0;
if (this->attribute_format)
{
return untoh64((char*)&value);
}
-METHOD(transform_attribute_t, get_attribute_type, u_int16_t,
+METHOD(transform_attribute_t, get_attribute_type, uint16_t,
private_transform_attribute_t *this)
{
return this->attribute_type;
* Described in header.
*/
transform_attribute_t *transform_attribute_create_value(payload_type_t type,
- transform_attribute_type_t kind, u_int64_t value)
+ transform_attribute_type_t kind, uint64_t value)
{
private_transform_attribute_t *this;
}
else if (value <= UINT32_MAX)
{
- u_int32_t val32;
+ uint32_t val32;
val32 = htonl(value);
this->attribute_value = chunk_clone(chunk_from_thing(val32));
*
* @return value
*/
- u_int64_t (*get_value) (transform_attribute_t *this);
+ uint64_t (*get_value) (transform_attribute_t *this);
/**
* get the type of the attribute.
*
* @return type of the value
*/
- u_int16_t (*get_attribute_type) (transform_attribute_t *this);
+ uint16_t (*get_attribute_type) (transform_attribute_t *this);
/**
* Destroys an transform_attribute_t object.
* @return transform_attribute_t object
*/
transform_attribute_t *transform_attribute_create_value(payload_type_t type,
- transform_attribute_type_t kind, u_int64_t value);
+ transform_attribute_type_t kind, uint64_t value);
#endif /** TRANSFORM_ATTRIBUTE_H_ @}*/
/**
* Next payload type.
*/
- u_int8_t next_payload;
+ uint8_t next_payload;
/**
* Reserved byte
*/
- u_int8_t reserved[3];
+ uint8_t reserved[3];
/**
* Length of this payload.
*/
- u_int16_t transform_length;
+ uint16_t transform_length;
/**
* Type or number, Type of the transform in IKEv2, number in IKEv2.
*/
- u_int8_t transform_ton;
+ uint8_t transform_ton;
/**
* Transform ID, as encoded in IKEv1.
*/
- u_int8_t transform_id_v1;
+ uint8_t transform_id_v1;
/**
* Transform ID, as encoded in IKEv2.
*/
- u_int16_t transform_id_v2;
+ uint16_t transform_id_v2;
/**
* Transforms Attributes are stored in a linked_list_t.
{
}
-METHOD(transform_substructure_t, get_transform_type_or_number, u_int8_t,
+METHOD(transform_substructure_t, get_transform_type_or_number, uint8_t,
private_transform_substructure_t *this)
{
return this->transform_ton;
}
-METHOD(transform_substructure_t, get_transform_id, u_int16_t,
+METHOD(transform_substructure_t, get_transform_id, uint16_t,
private_transform_substructure_t *this)
{
if (this->type == PLV2_TRANSFORM_SUBSTRUCTURE)
* Described in header
*/
transform_substructure_t *transform_substructure_create_type(payload_type_t type,
- u_int8_t type_or_number, u_int16_t id)
+ uint8_t type_or_number, uint16_t id)
{
private_transform_substructure_t *this;
*
* @return Transform type of current transform substructure.
*/
- u_int8_t (*get_transform_type_or_number) (transform_substructure_t *this);
+ uint8_t (*get_transform_type_or_number) (transform_substructure_t *this);
/**
* Get transform id of the current transform.
*
* @return Transform id of current transform substructure.
*/
- u_int16_t (*get_transform_id) (transform_substructure_t *this);
+ uint16_t (*get_transform_id) (transform_substructure_t *this);
/**
* Create an enumerator over transform attributes.
* @return transform_substructure_t object
*/
transform_substructure_t *transform_substructure_create_type(payload_type_t type,
- u_int8_t type_or_number, u_int16_t id);
+ uint8_t type_or_number, uint16_t id);
#endif /** TRANSFORM_SUBSTRUCTURE_H_ @}*/
/**
* Next payload type.
*/
- u_int8_t next_payload;
+ uint8_t next_payload;
/**
* Critical flag.
/**
* Length of this payload.
*/
- u_int16_t payload_length;
+ uint16_t payload_length;
/**
* Number of traffic selectors
*/
- u_int8_t ts_num;
+ uint8_t ts_num;
/**
* Contains the traffic selectors of type traffic_selector_substructure_t.
/**
* Next payload type.
*/
- u_int8_t next_payload;
+ uint8_t next_payload;
/**
* Critical flag.
/**
* Length of this payload.
*/
- u_int16_t payload_length;
+ uint16_t payload_length;
/**
* The contained data.
/**
* Next payload type.
*/
- u_int8_t next_payload;
+ uint8_t next_payload;
/**
* Critical flag.
/**
* Length of this payload.
*/
- u_int16_t payload_length;
+ uint16_t payload_length;
/**
* The contained data.
/**
* convert an IP protocol identifier to the IKEv2 specific protocol identifier.
*/
-static inline protocol_id_t proto_ip2ike(u_int8_t protocol)
+static inline protocol_id_t proto_ip2ike(uint8_t protocol)
{
switch (protocol)
{
}
METHOD(kernel_listener_t, acquire, bool,
- private_kernel_handler_t *this, u_int32_t reqid,
+ private_kernel_handler_t *this, uint32_t reqid,
traffic_selector_t *src_ts, traffic_selector_t *dst_ts)
{
if (src_ts && dst_ts)
}
METHOD(kernel_listener_t, expire, bool,
- private_kernel_handler_t *this, u_int8_t protocol, u_int32_t spi,
+ private_kernel_handler_t *this, uint8_t protocol, uint32_t spi,
host_t *dst, bool hard)
{
protocol_id_t proto = proto_ip2ike(protocol);
}
METHOD(kernel_listener_t, mapping, bool,
- private_kernel_handler_t *this, u_int8_t protocol, u_int32_t spi,
+ private_kernel_handler_t *this, uint8_t protocol, uint32_t spi,
host_t *dst, host_t *remote)
{
protocol_id_t proto = proto_ip2ike(protocol);
}
METHOD(kernel_listener_t, migrate, bool,
- private_kernel_handler_t *this, u_int32_t reqid,
+ private_kernel_handler_t *this, uint32_t reqid,
traffic_selector_t *src_ts, traffic_selector_t *dst_ts,
policy_dir_t direction, host_t *local, host_t *remote)
{
/**
* Identifier specified in IKE
*/
- u_int16_t ike;
+ uint16_t ike;
/**
* Identifier as defined in pfkeyv2.h
*/
- u_int16_t kernel;
+ uint16_t kernel;
/**
* Name of the algorithm in linux crypto API
METHOD(kernel_interface_t, get_spi, status_t,
private_kernel_interface_t *this, host_t *src, host_t *dst,
- u_int8_t protocol, u_int32_t *spi)
+ uint8_t protocol, uint32_t *spi)
{
if (!this->ipsec)
{
METHOD(kernel_interface_t, get_cpi, status_t,
private_kernel_interface_t *this, host_t *src, host_t *dst,
- u_int16_t *cpi)
+ uint16_t *cpi)
{
if (!this->ipsec)
{
*/
typedef struct {
/** allocated reqid */
- u_int32_t reqid;
+ uint32_t reqid;
/** references to this entry */
u_int refs;
/** inbound mark used for SA */
METHOD(kernel_interface_t, alloc_reqid, status_t,
private_kernel_interface_t *this,
linked_list_t *local_ts, linked_list_t *remote_ts,
- mark_t mark_in, mark_t mark_out, u_int32_t *reqid)
+ mark_t mark_in, mark_t mark_out, uint32_t *reqid)
{
- static u_int32_t counter = 0;
+ static uint32_t counter = 0;
reqid_entry_t *entry = NULL, *tmpl;
status_t status = SUCCESS;
}
METHOD(kernel_interface_t, release_reqid, status_t,
- private_kernel_interface_t *this, u_int32_t reqid,
+ private_kernel_interface_t *this, uint32_t reqid,
mark_t mark_in, mark_t mark_out)
{
reqid_entry_t *entry, tmpl = {
METHOD(kernel_interface_t, add_sa, status_t,
private_kernel_interface_t *this, host_t *src, host_t *dst,
- u_int32_t spi, u_int8_t protocol, u_int32_t reqid, mark_t mark,
- u_int32_t tfc, lifetime_cfg_t *lifetime, u_int16_t enc_alg, chunk_t enc_key,
- u_int16_t int_alg, chunk_t int_key, ipsec_mode_t mode,
- u_int16_t ipcomp, u_int16_t cpi, u_int32_t replay_window,
+ uint32_t spi, uint8_t protocol, uint32_t reqid, mark_t mark,
+ uint32_t tfc, lifetime_cfg_t *lifetime, uint16_t enc_alg, chunk_t enc_key,
+ uint16_t int_alg, chunk_t int_key, ipsec_mode_t mode,
+ uint16_t ipcomp, uint16_t cpi, uint32_t replay_window,
bool initiator, bool encap, bool esn, bool inbound, bool update,
linked_list_t *src_ts, linked_list_t *dst_ts)
{
}
METHOD(kernel_interface_t, update_sa, status_t,
- private_kernel_interface_t *this, u_int32_t spi, u_int8_t protocol,
- u_int16_t cpi, host_t *src, host_t *dst, host_t *new_src, host_t *new_dst,
+ private_kernel_interface_t *this, uint32_t spi, uint8_t protocol,
+ uint16_t cpi, host_t *src, host_t *dst, host_t *new_src, host_t *new_dst,
bool encap, bool new_encap, mark_t mark)
{
if (!this->ipsec)
METHOD(kernel_interface_t, query_sa, status_t,
private_kernel_interface_t *this, host_t *src, host_t *dst,
- u_int32_t spi, u_int8_t protocol, mark_t mark,
- u_int64_t *bytes, u_int64_t *packets, time_t *time)
+ uint32_t spi, uint8_t protocol, mark_t mark,
+ uint64_t *bytes, uint64_t *packets, time_t *time)
{
if (!this->ipsec)
{
}
METHOD(kernel_interface_t, del_sa, status_t,
- private_kernel_interface_t *this, host_t *src, host_t *dst, u_int32_t spi,
- u_int8_t protocol, u_int16_t cpi, mark_t mark)
+ private_kernel_interface_t *this, host_t *src, host_t *dst, uint32_t spi,
+ uint8_t protocol, uint16_t cpi, mark_t mark)
{
if (!this->ipsec)
{
METHOD(kernel_interface_t, add_route, status_t,
private_kernel_interface_t *this, chunk_t dst_net,
- u_int8_t prefixlen, host_t *gateway, host_t *src_ip, char *if_name)
+ uint8_t prefixlen, host_t *gateway, host_t *src_ip, char *if_name)
{
if (!this->net)
{
METHOD(kernel_interface_t, del_route, status_t,
private_kernel_interface_t *this, chunk_t dst_net,
- u_int8_t prefixlen, host_t *gateway, host_t *src_ip, char *if_name)
+ uint8_t prefixlen, host_t *gateway, host_t *src_ip, char *if_name)
{
if (!this->net)
{
}
METHOD(kernel_interface_t, enable_udp_decap, bool,
- private_kernel_interface_t *this, int fd, int family, u_int16_t port)
+ private_kernel_interface_t *this, int fd, int family, uint16_t port)
{
if (!this->ipsec)
{
}
METHOD(kernel_interface_t, acquire, void,
- private_kernel_interface_t *this, u_int32_t reqid,
+ private_kernel_interface_t *this, uint32_t reqid,
traffic_selector_t *src_ts, traffic_selector_t *dst_ts)
{
kernel_listener_t *listener;
}
METHOD(kernel_interface_t, expire, void,
- private_kernel_interface_t *this, u_int8_t protocol, u_int32_t spi,
+ private_kernel_interface_t *this, uint8_t protocol, uint32_t spi,
host_t *dst, bool hard)
{
kernel_listener_t *listener;
}
METHOD(kernel_interface_t, mapping, void,
- private_kernel_interface_t *this, u_int8_t protocol, u_int32_t spi,
+ private_kernel_interface_t *this, uint8_t protocol, uint32_t spi,
host_t *dst, host_t *remote)
{
kernel_listener_t *listener;
}
METHOD(kernel_interface_t, migrate, void,
- private_kernel_interface_t *this, u_int32_t reqid,
+ private_kernel_interface_t *this, uint32_t reqid,
traffic_selector_t *src_ts, traffic_selector_t *dst_ts,
policy_dir_t direction, host_t *local, host_t *remote)
{
}
METHOD(kernel_interface_t, register_algorithm, void,
- private_kernel_interface_t *this, u_int16_t alg_id, transform_type_t type,
- u_int16_t kernel_id, char *kernel_name)
+ private_kernel_interface_t *this, uint16_t alg_id, transform_type_t type,
+ uint16_t kernel_id, char *kernel_name)
{
kernel_algorithm_t *algorithm;
}
METHOD(kernel_interface_t, lookup_algorithm, bool,
- private_kernel_interface_t *this, u_int16_t alg_id, transform_type_t type,
- u_int16_t *kernel_id, char **kernel_name)
+ private_kernel_interface_t *this, uint16_t alg_id, transform_type_t type,
+ uint16_t *kernel_id, char **kernel_name)
{
kernel_algorithm_t *algorithm;
enumerator_t *enumerator;
* @return SUCCESS if operation completed
*/
status_t (*get_spi)(kernel_interface_t *this, host_t *src, host_t *dst,
- u_int8_t protocol, u_int32_t *spi);
+ uint8_t protocol, uint32_t *spi);
/**
* Get a Compression Parameter Index (CPI) from the kernel.
* @return SUCCESS if operation completed
*/
status_t (*get_cpi)(kernel_interface_t *this, host_t *src, host_t *dst,
- u_int16_t *cpi);
+ uint16_t *cpi);
/**
* Allocate or confirm a reqid to use for a given SA pair.
status_t (*alloc_reqid)(kernel_interface_t *this,
linked_list_t *local_ts, linked_list_t *remote_ts,
mark_t mark_in, mark_t mark_out,
- u_int32_t *reqid);
+ uint32_t *reqid);
/**
* Release a previously allocated reqid.
* @param mark_out outbound mark on SA
* @return SUCCESS if reqid released
*/
- status_t (*release_reqid)(kernel_interface_t *this, u_int32_t reqid,
+ status_t (*release_reqid)(kernel_interface_t *this, uint32_t reqid,
mark_t mark_in, mark_t mark_out);
/**
* @return SUCCESS if operation completed
*/
status_t (*add_sa) (kernel_interface_t *this,
- host_t *src, host_t *dst, u_int32_t spi,
- u_int8_t protocol, u_int32_t reqid, mark_t mark,
- u_int32_t tfc, lifetime_cfg_t *lifetime,
- u_int16_t enc_alg, chunk_t enc_key,
- u_int16_t int_alg, chunk_t int_key,
- ipsec_mode_t mode, u_int16_t ipcomp, u_int16_t cpi,
- u_int32_t replay_window, bool initiator, bool encap,
+ host_t *src, host_t *dst, uint32_t spi,
+ uint8_t protocol, uint32_t reqid, mark_t mark,
+ uint32_t tfc, lifetime_cfg_t *lifetime,
+ uint16_t enc_alg, chunk_t enc_key,
+ uint16_t int_alg, chunk_t int_key,
+ ipsec_mode_t mode, uint16_t ipcomp, uint16_t cpi,
+ uint32_t replay_window, bool initiator, bool encap,
bool esn, bool inbound, bool update,
linked_list_t *src_ts, linked_list_t *dst_ts);
* the kernel interface can't update the SA
*/
status_t (*update_sa)(kernel_interface_t *this,
- u_int32_t spi, u_int8_t protocol, u_int16_t cpi,
+ uint32_t spi, uint8_t protocol, uint16_t cpi,
host_t *src, host_t *dst,
host_t *new_src, host_t *new_dst,
bool encap, bool new_encap, mark_t mark);
* @return SUCCESS if operation completed
*/
status_t (*query_sa) (kernel_interface_t *this, host_t *src, host_t *dst,
- u_int32_t spi, u_int8_t protocol, mark_t mark,
- u_int64_t *bytes, u_int64_t *packets, time_t *time);
+ uint32_t spi, uint8_t protocol, mark_t mark,
+ uint64_t *bytes, uint64_t *packets, time_t *time);
/**
* Delete a previously installed SA from the SAD.
* @return SUCCESS if operation completed
*/
status_t (*del_sa) (kernel_interface_t *this, host_t *src, host_t *dst,
- u_int32_t spi, u_int8_t protocol, u_int16_t cpi,
+ uint32_t spi, uint8_t protocol, uint16_t cpi,
mark_t mark);
/**
* ALREADY_DONE if the route already exists
*/
status_t (*add_route) (kernel_interface_t *this, chunk_t dst_net,
- u_int8_t prefixlen, host_t *gateway, host_t *src_ip,
+ uint8_t prefixlen, host_t *gateway, host_t *src_ip,
char *if_name);
/**
* @return SUCCESS if operation completed
*/
status_t (*del_route) (kernel_interface_t *this, chunk_t dst_net,
- u_int8_t prefixlen, host_t *gateway, host_t *src_ip,
+ uint8_t prefixlen, host_t *gateway, host_t *src_ip,
char *if_name);
/**
* @return TRUE if UDP decapsulation was enabled successfully
*/
bool (*enable_udp_decap)(kernel_interface_t *this, int fd, int family,
- u_int16_t port);
+ uint16_t port);
/**
* @param src_ts source traffic selector
* @param dst_ts destination traffic selector
*/
- void (*acquire)(kernel_interface_t *this, u_int32_t reqid,
+ void (*acquire)(kernel_interface_t *this, uint32_t reqid,
traffic_selector_t *src_ts, traffic_selector_t *dst_ts);
/**
* @param dst destination address of expired SA
* @param hard TRUE if it is a hard expire, FALSE otherwise
*/
- void (*expire)(kernel_interface_t *this, u_int8_t protocol, u_int32_t spi,
+ void (*expire)(kernel_interface_t *this, uint8_t protocol, uint32_t spi,
host_t *dst, bool hard);
/**
* @param dst original destination address of SA
* @param remote new remote host
*/
- void (*mapping)(kernel_interface_t *this, u_int8_t protocol, u_int32_t spi,
+ void (*mapping)(kernel_interface_t *this, uint8_t protocol, uint32_t spi,
host_t *dst, host_t *remote);
/**
* @param local local host address to be used in the IKE_SA
* @param remote remote host address to be used in the IKE_SA
*/
- void (*migrate)(kernel_interface_t *this, u_int32_t reqid,
+ void (*migrate)(kernel_interface_t *this, uint32_t reqid,
traffic_selector_t *src_ts, traffic_selector_t *dst_ts,
policy_dir_t direction, host_t *local, host_t *remote);
* @param kernel_id the kernel id of the algorithm
* @param kernel_name the kernel name of the algorithm
*/
- void (*register_algorithm)(kernel_interface_t *this, u_int16_t alg_id,
- transform_type_t type, u_int16_t kernel_id,
+ void (*register_algorithm)(kernel_interface_t *this, uint16_t alg_id,
+ transform_type_t type, uint16_t kernel_id,
char *kernel_name);
/**
* @param kernel_name the kernel name of the algorithm (optional)
* @return TRUE if algorithm was found
*/
- bool (*lookup_algorithm)(kernel_interface_t *this, u_int16_t alg_id,
- transform_type_t type, u_int16_t *kernel_id,
+ bool (*lookup_algorithm)(kernel_interface_t *this, uint16_t alg_id,
+ transform_type_t type, uint16_t *kernel_id,
char **kernel_name);
/**
* @return SUCCESS if operation completed
*/
status_t (*get_spi)(kernel_ipsec_t *this, host_t *src, host_t *dst,
- u_int8_t protocol, u_int32_t *spi);
+ uint8_t protocol, uint32_t *spi);
/**
* Get a Compression Parameter Index (CPI) from the kernel.
* @return SUCCESS if operation completed
*/
status_t (*get_cpi)(kernel_ipsec_t *this, host_t *src, host_t *dst,
- u_int16_t *cpi);
+ uint16_t *cpi);
/**
* Add an SA to the SAD.
* @return SUCCESS if operation completed
*/
status_t (*add_sa) (kernel_ipsec_t *this,
- host_t *src, host_t *dst, u_int32_t spi,
- u_int8_t protocol, u_int32_t reqid,
- mark_t mark, u_int32_t tfc, lifetime_cfg_t *lifetime,
- u_int16_t enc_alg, chunk_t enc_key,
- u_int16_t int_alg, chunk_t int_key,
- ipsec_mode_t mode, u_int16_t ipcomp, u_int16_t cpi,
- u_int32_t replay_window, bool initiator, bool encap,
+ host_t *src, host_t *dst, uint32_t spi,
+ uint8_t protocol, uint32_t reqid,
+ mark_t mark, uint32_t tfc, lifetime_cfg_t *lifetime,
+ uint16_t enc_alg, chunk_t enc_key,
+ uint16_t int_alg, chunk_t int_key,
+ ipsec_mode_t mode, uint16_t ipcomp, uint16_t cpi,
+ uint32_t replay_window, bool initiator, bool encap,
bool esn, bool inbound, bool update,
linked_list_t *src_ts, linked_list_t *dst_ts);
* the kernel interface can't update the SA
*/
status_t (*update_sa)(kernel_ipsec_t *this,
- u_int32_t spi, u_int8_t protocol, u_int16_t cpi,
+ uint32_t spi, uint8_t protocol, uint16_t cpi,
host_t *src, host_t *dst,
host_t *new_src, host_t *new_dst,
bool encap, bool new_encap, mark_t mark);
* @return SUCCESS if operation completed
*/
status_t (*query_sa) (kernel_ipsec_t *this, host_t *src, host_t *dst,
- u_int32_t spi, u_int8_t protocol, mark_t mark,
- u_int64_t *bytes, u_int64_t *packets, time_t *time);
+ uint32_t spi, uint8_t protocol, mark_t mark,
+ uint64_t *bytes, uint64_t *packets, time_t *time);
/**
* Delete a previusly installed SA from the SAD.
* @return SUCCESS if operation completed
*/
status_t (*del_sa) (kernel_ipsec_t *this, host_t *src, host_t *dst,
- u_int32_t spi, u_int8_t protocol, u_int16_t cpi,
+ uint32_t spi, uint8_t protocol, uint16_t cpi,
mark_t mark);
/**
* @return TRUE if UDP decapsulation was enabled successfully
*/
bool (*enable_udp_decap)(kernel_ipsec_t *this, int fd, int family,
- u_int16_t port);
+ uint16_t port);
/**
* Destroy the implementation.
* @param dst_ts destination traffic selector
* @return TRUE to remain registered, FALSE to unregister
*/
- bool (*acquire)(kernel_listener_t *this, u_int32_t reqid,
+ bool (*acquire)(kernel_listener_t *this, uint32_t reqid,
traffic_selector_t *src_ts, traffic_selector_t *dst_ts);
/**
* @param hard TRUE if it is a hard expire, FALSE otherwise
* @return TRUE to remain registered, FALSE to unregister
*/
- bool (*expire)(kernel_listener_t *this, u_int8_t protocol, u_int32_t spi,
+ bool (*expire)(kernel_listener_t *this, uint8_t protocol, uint32_t spi,
host_t *dst, bool hard);
/**
* @param remote new remote host
* @return TRUE to remain registered, FALSE to unregister
*/
- bool (*mapping)(kernel_listener_t *this, u_int8_t protocol, u_int32_t spi,
+ bool (*mapping)(kernel_listener_t *this, uint8_t protocol, uint32_t spi,
host_t *dst, host_t *remote);
/**
* @param remote remote host address to be used in the IKE_SA
* @return TRUE to remain registered, FALSE to unregister
*/
- bool (*migrate)(kernel_listener_t *this, u_int32_t reqid,
+ bool (*migrate)(kernel_listener_t *this, uint32_t reqid,
traffic_selector_t *src_ts, traffic_selector_t *dst_ts,
policy_dir_t direction, host_t *local, host_t *remote);
* ALREADY_DONE if the route already exists
*/
status_t (*add_route) (kernel_net_t *this, chunk_t dst_net,
- u_int8_t prefixlen, host_t *gateway, host_t *src_ip,
+ uint8_t prefixlen, host_t *gateway, host_t *src_ip,
char *if_name);
/**
* @return SUCCESS if operation completed
*/
status_t (*del_route) (kernel_net_t *this, chunk_t dst_net,
- u_int8_t prefixlen, host_t *gateway, host_t *src_ip,
+ uint8_t prefixlen, host_t *gateway, host_t *src_ip,
char *if_name);
/**
/**
* how many times we have used "secret" so far
*/
- u_int32_t secret_used;
+ uint32_t secret_used;
/**
* time we did the cookie switch
*/
- u_int32_t secret_switch;
+ uint32_t secret_switch;
/**
* time offset to use, hides our system time
*/
- u_int32_t secret_offset;
+ uint32_t secret_offset;
/**
* the RNG to use for secret generation
/**
* require cookies after this many half open IKE_SAs
*/
- u_int32_t cookie_threshold;
+ uint32_t cookie_threshold;
/**
* timestamp of last cookie requested
/**
* how many half open IKE_SAs per peer before blocking
*/
- u_int32_t block_threshold;
+ uint32_t block_threshold;
/**
* Drop IKE_SA_INIT requests if processor job load exceeds this limit
* build a cookie
*/
static bool cookie_build(private_receiver_t *this, message_t *message,
- u_int32_t t, chunk_t secret, chunk_t *cookie)
+ uint32_t t, chunk_t secret, chunk_t *cookie)
{
- u_int64_t spi = message->get_initiator_spi(message);
+ uint64_t spi = message->get_initiator_spi(message);
host_t *ip = message->get_source(message);
chunk_t input, hash;
static bool cookie_verify(private_receiver_t *this, message_t *message,
chunk_t cookie)
{
- u_int32_t t, now;
+ uint32_t t, now;
chunk_t reference;
chunk_t secret;
now = time_monotonic(NULL);
- t = *(u_int32_t*)cookie.ptr;
+ t = *(uint32_t*)cookie.ptr;
- if (cookie.len != sizeof(u_int32_t) +
+ if (cookie.len != sizeof(uint32_t) +
this->hasher->get_hash_size(this->hasher) ||
t < now - this->secret_offset - COOKIE_LIFETIME)
{
data = message->get_packet_data(message);
if (data.len <
IKE_HEADER_LENGTH + NOTIFY_PAYLOAD_HEADER_LENGTH +
- sizeof(u_int32_t) + this->hasher->get_hash_size(this->hasher) ||
+ sizeof(uint32_t) + this->hasher->get_hash_size(this->hasher) ||
*(data.ptr + 16) != PLV2_NOTIFY ||
- *(u_int16_t*)(data.ptr + IKE_HEADER_LENGTH + 6) != htons(COOKIE))
+ *(uint16_t*)(data.ptr + IKE_HEADER_LENGTH + 6) != htons(COOKIE))
{
/* no cookie found */
return FALSE;
}
data.ptr += IKE_HEADER_LENGTH + NOTIFY_PAYLOAD_HEADER_LENGTH;
- data.len = sizeof(u_int32_t) + this->hasher->get_hash_size(this->hasher);
+ data.len = sizeof(uint32_t) + this->hasher->get_hash_size(this->hasher);
if (!cookie_verify(this, message, data))
{
DBG2(DBG_NET, "found cookie, but content invalid");
* Check if we currently require cookies
*/
static bool cookie_required(private_receiver_t *this,
- u_int half_open, u_int32_t now)
+ u_int half_open, uint32_t now)
{
if (this->cookie_threshold && half_open >= this->cookie_threshold)
{
static bool drop_ike_sa_init(private_receiver_t *this, message_t *message)
{
u_int half_open, half_open_r;
- u_int32_t now;
+ uint32_t now;
now = time_monotonic(NULL);
half_open = charon->ike_sa_manager->get_half_open_count(
receiver_t *receiver_create()
{
private_receiver_t *this;
- u_int32_t now = time_monotonic(NULL);
+ uint32_t now = time_monotonic(NULL);
INIT(this,
.public = {
* @param nat_t TRUE to get the port used to float in case of NAT-T
* @return the port
*/
- u_int16_t (*get_port)(socket_t *this, bool nat_t);
+ uint16_t (*get_port)(socket_t *this, bool nat_t);
/**
* Get the address families this socket is listening on.
return status;
}
-METHOD(socket_manager_t, get_port, u_int16_t,
+METHOD(socket_manager_t, get_port, uint16_t,
private_socket_manager_t *this, bool nat_t)
{
- u_int16_t port = 0;
+ uint16_t port = 0;
this->lock->read_lock(this->lock);
if (this->socket)
{
* @param nat_t TRUE to get the port used to float in case of NAT-T
* @return the port, or 0, if no socket is registered
*/
- u_int16_t (*get_port)(socket_manager_t *this, bool nat_t);
+ uint16_t (*get_port)(socket_manager_t *this, bool nat_t);
/**
* Get the address families the registered socket is listening on.
{
if (family == AF_INET)
{ /* IPv4 attributes contain a subnet mask */
- u_int32_t netmask = 0;
+ uint32_t netmask = 0;
if (mask)
- { /* shifting u_int32_t by 32 or more is undefined */
+ { /* shifting uint32_t by 32 or more is undefined */
mask = 32 - mask;
netmask = htonl((0xFFFFFFFF >> mask) << mask);
}
static bool ts2in(traffic_selector_t *ts,
struct in_addr *addr, struct in_addr *mask)
{
- u_int8_t bits;
+ uint8_t bits;
host_t *net;
if (ts->get_type(ts) == TS_IPV4_ADDR_RANGE &&
*/
static bool manage_pre_esp_in_udp(private_connmark_listener_t *this,
struct iptc_handle *ipth, bool add,
- u_int mark, u_int32_t spi,
+ u_int mark, uint32_t spi,
host_t *dst, host_t *src)
{
- u_int16_t match_size = XT_ALIGN(sizeof(struct ipt_entry_match)) +
+ uint16_t match_size = XT_ALIGN(sizeof(struct ipt_entry_match)) +
XT_ALIGN(sizeof(struct xt_udp));
- u_int16_t target_offset = XT_ALIGN(sizeof(struct ipt_entry)) + match_size;
- u_int16_t target_size = XT_ALIGN(sizeof(struct ipt_entry_target)) +
+ uint16_t target_offset = XT_ALIGN(sizeof(struct ipt_entry)) + match_size;
+ uint16_t target_size = XT_ALIGN(sizeof(struct ipt_entry_target)) +
XT_ALIGN(sizeof(struct xt_mark_tginfo2));
- u_int16_t entry_size = target_offset + target_size;
+ uint16_t entry_size = target_offset + target_size;
u_char ipt[entry_size], *pos = ipt;
struct ipt_entry *e;
*/
static bool manage_pre_esp(private_connmark_listener_t *this,
struct iptc_handle *ipth, bool add,
- u_int mark, u_int32_t spi,
+ u_int mark, uint32_t spi,
host_t *dst, host_t *src)
{
- u_int16_t match_size = XT_ALIGN(sizeof(struct ipt_entry_match)) +
+ uint16_t match_size = XT_ALIGN(sizeof(struct ipt_entry_match)) +
XT_ALIGN(sizeof(struct xt_esp));
- u_int16_t target_offset = XT_ALIGN(sizeof(struct ipt_entry)) + match_size;
- u_int16_t target_size = XT_ALIGN(sizeof(struct ipt_entry_target)) +
+ uint16_t target_offset = XT_ALIGN(sizeof(struct ipt_entry)) + match_size;
+ uint16_t target_size = XT_ALIGN(sizeof(struct ipt_entry_target)) +
XT_ALIGN(sizeof(struct xt_mark_tginfo2));
- u_int16_t entry_size = target_offset + target_size;
+ uint16_t entry_size = target_offset + target_size;
u_char ipt[entry_size], *pos = ipt;
struct ipt_entry *e;
*/
static bool manage_pre(private_connmark_listener_t *this,
struct iptc_handle *ipth, bool add,
- u_int mark, u_int32_t spi, bool encap,
+ u_int mark, uint32_t spi, bool encap,
host_t *dst, host_t *src)
{
if (encap)
*/
static bool manage_in(private_connmark_listener_t *this,
struct iptc_handle *ipth, bool add,
- u_int mark, u_int32_t spi,
+ u_int mark, uint32_t spi,
traffic_selector_t *dst, traffic_selector_t *src)
{
- u_int16_t match_size = XT_ALIGN(sizeof(struct ipt_entry_match)) +
+ uint16_t match_size = XT_ALIGN(sizeof(struct ipt_entry_match)) +
XT_ALIGN(sizeof(struct xt_policy_info));
- u_int16_t target_offset = XT_ALIGN(sizeof(struct ipt_entry)) + match_size;
- u_int16_t target_size = XT_ALIGN(sizeof(struct ipt_entry_target)) +
+ uint16_t target_offset = XT_ALIGN(sizeof(struct ipt_entry)) + match_size;
+ uint16_t target_size = XT_ALIGN(sizeof(struct ipt_entry_target)) +
XT_ALIGN(sizeof(struct xt_connmark_tginfo1));
- u_int16_t entry_size = target_offset + target_size;
+ uint16_t entry_size = target_offset + target_size;
u_char ipt[entry_size], *pos = ipt;
struct ipt_entry *e;
struct iptc_handle *ipth, bool add,
traffic_selector_t *dst, traffic_selector_t *src)
{
- u_int16_t match_size = XT_ALIGN(sizeof(struct ipt_entry_match)) +
+ uint16_t match_size = XT_ALIGN(sizeof(struct ipt_entry_match)) +
XT_ALIGN(sizeof(struct xt_mark_mtinfo1));
- u_int16_t target_offset = XT_ALIGN(sizeof(struct ipt_entry)) + match_size;
- u_int16_t target_size = XT_ALIGN(sizeof(struct ipt_entry_target)) +
+ uint16_t target_offset = XT_ALIGN(sizeof(struct ipt_entry)) + match_size;
+ uint16_t target_size = XT_ALIGN(sizeof(struct ipt_entry_target)) +
XT_ALIGN(sizeof(struct xt_connmark_tginfo1));
- u_int16_t entry_size = target_offset + target_size;
+ uint16_t entry_size = target_offset + target_size;
u_char ipt[entry_size], *pos = ipt;
struct ipt_entry *e;
{
traffic_selector_t *local, *remote;
enumerator_t *enumerator;
- u_int32_t spi;
+ uint32_t spi;
u_int mark;
bool done = TRUE;
* DHCP option encoding, a TLV
*/
typedef struct __attribute__((packed)) {
- u_int8_t type;
- u_int8_t len;
+ uint8_t type;
+ uint8_t len;
char data[];
} dhcp_option_t;
* DHCP message format, with a maximum size options buffer
*/
typedef struct __attribute__((packed)) {
- u_int8_t opcode;
- u_int8_t hw_type;
- u_int8_t hw_addr_len;
- u_int8_t hop_count;
- u_int32_t transaction_id;
- u_int16_t number_of_seconds;
- u_int16_t flags;
- u_int32_t client_address;
- u_int32_t your_address;
- u_int32_t server_address;
- u_int32_t gateway_address;
+ uint8_t opcode;
+ uint8_t hw_type;
+ uint8_t hw_addr_len;
+ uint8_t hop_count;
+ uint32_t transaction_id;
+ uint16_t number_of_seconds;
+ uint16_t flags;
+ uint32_t client_address;
+ uint32_t your_address;
+ uint32_t server_address;
+ uint32_t gateway_address;
char client_hw_addr[6];
char client_hw_padding[10];
char server_hostname[64];
char boot_filename[128];
- u_int32_t magic_cookie;
+ uint32_t magic_cookie;
char options[252];
} dhcp_t;
dhcp_option_t *option;
int optlen = 0;
host_t *src;
- u_int32_t id;
+ uint32_t id;
memset(dhcp, 0, sizeof(*dhcp));
dhcp->opcode = BOOTREQUEST;
private_dhcp_socket_t *this, identification_t *identity)
{
dhcp_transaction_t *transaction;
- u_int32_t id;
+ uint32_t id;
int try;
- if (!this->rng->get_bytes(this->rng, sizeof(id), (u_int8_t*)&id))
+ if (!this->rng->get_bytes(this->rng, sizeof(id), (uint8_t*)&id))
{
DBG1(DBG_CFG, "DHCP DISCOVER failed, no transaction ID");
return NULL;
/**
* DHCP transaction ID
*/
- u_int32_t id;
+ uint32_t id;
/**
* Peer identity
chunk_t data;
} attribute_entry_t;
-METHOD(dhcp_transaction_t, get_id, u_int32_t,
+METHOD(dhcp_transaction_t, get_id, uint32_t,
private_dhcp_transaction_t *this)
{
return this->id;
/**
* See header
*/
-dhcp_transaction_t *dhcp_transaction_create(u_int32_t id,
+dhcp_transaction_t *dhcp_transaction_create(uint32_t id,
identification_t *identity)
{
private_dhcp_transaction_t *this;
*
* @return DHCP transaction identifier
*/
- u_int32_t (*get_id)(dhcp_transaction_t *this);
+ uint32_t (*get_id)(dhcp_transaction_t *this);
/**
* Get the peer identity this transaction is used for.
* @param identity peer identity this transaction is used for
* @return transaction instance
*/
-dhcp_transaction_t *dhcp_transaction_create(u_int32_t id,
+dhcp_transaction_t *dhcp_transaction_create(uint32_t id,
identification_t *identity);
#endif /** DHCP_TRANSACTION_H_ @}*/
/**
* Certificate type
*/
- u_int16_t cert_type;
+ uint16_t cert_type;
/**
* Key tag
*/
- u_int16_t key_tag;
+ uint16_t key_tag;
/**
* Algorithm
*/
- u_int8_t algorithm;
+ uint8_t algorithm;
/**
* Certificate
return this->cert_type;
}
-METHOD(dnscert_t, get_key_tag, u_int16_t,
+METHOD(dnscert_t, get_key_tag, uint16_t,
private_dnscert_t *this)
{
return this->key_tag;
*
* @return keytag
*/
- u_int16_t (*get_key_tag)(dnscert_t *this);
+ uint16_t (*get_key_tag)(dnscert_t *this);
/**
* Get the algorithm.
{
char buf[128];
int fd, len;
- u_int16_t msglen;
+ uint16_t msglen;
fd = make_connection();
if (fd < 0)
*/
struct duplicheck_msg_t {
/** length of the identity following, in network order (excluding len). */
- u_int16_t len;
+ uint16_t len;
/** identity string, not null terminated */
char identity[];
} __attribute__((__packed__));
{
enumerator_t *enumerator;
stream_t *stream;
- u_int16_t nlen;
+ uint16_t nlen;
char buf[512];
int len;
/**
* EAP message identifier
*/
- u_int8_t identifier;
+ uint8_t identifier;
/**
* MSK
/**
* Counter value if reauthentication is used
*/
- u_int16_t counter;
+ uint16_t counter;
};
/**
eap_payload_t **out)
{
simaka_message_t *message;
- u_int16_t encoded;
+ uint16_t encoded;
DBG1(DBG_IKE, "sending client error '%N'",
simaka_client_error_names, AKA_UNABLE_TO_PROCESS);
*/
static bool counter_too_small(private_eap_aka_peer_t *this, chunk_t chunk)
{
- u_int16_t counter;
+ uint16_t counter;
memcpy(&counter, chunk.ptr, sizeof(counter));
counter = htons(counter);
{
if (type == AT_NOTIFICATION)
{
- u_int16_t code;
+ uint16_t code;
memcpy(&code, data.ptr, sizeof(code));
code = ntohs(code);
}
METHOD(eap_method_t, get_type, eap_type_t,
- private_eap_aka_peer_t *this, u_int32_t *vendor)
+ private_eap_aka_peer_t *this, uint32_t *vendor)
{
*vendor = 0;
return EAP_AKA;
return FAILED;
}
-METHOD(eap_method_t, get_identifier, u_int8_t,
+METHOD(eap_method_t, get_identifier, uint8_t,
private_eap_aka_peer_t *this)
{
return this->identifier;
}
METHOD(eap_method_t, set_identifier, void,
- private_eap_aka_peer_t *this, u_int8_t identifier)
+ private_eap_aka_peer_t *this, uint8_t identifier)
{
this->identifier = identifier;
}
/**
* EAP message identifier
*/
- u_int8_t identifier;
+ uint8_t identifier;
/**
* Expected Result XRES
* Initiate EAP-AKA/Request/Re-authentication message
*/
static status_t reauthenticate(private_eap_aka_server_t *this,
- char mk[HASH_SIZE_SHA1], u_int16_t counter,
+ char mk[HASH_SIZE_SHA1], uint16_t counter,
eap_payload_t **out)
{
simaka_message_t *message;
if (this->use_reauth)
{
char mk[HASH_SIZE_SHA1];
- u_int16_t counter;
+ uint16_t counter;
permanent = this->mgr->provider_is_reauth(this->mgr, id, mk, &counter);
if (permanent)
{
if (type == AT_CLIENT_ERROR_CODE)
{
- u_int16_t code;
+ uint16_t code;
memcpy(&code, data.ptr, sizeof(code));
DBG1(DBG_IKE, "received EAP-AKA client error '%N'",
}
METHOD(eap_method_t, get_type, eap_type_t,
- private_eap_aka_server_t *this, u_int32_t *vendor)
+ private_eap_aka_server_t *this, uint32_t *vendor)
{
*vendor = 0;
return EAP_AKA;
return FAILED;
}
-METHOD(eap_method_t, get_identifier, u_int8_t,
+METHOD(eap_method_t, get_identifier, uint8_t,
private_eap_aka_server_t *this)
{
return this->identifier;
}
METHOD(eap_method_t, set_identifier, void,
- private_eap_aka_server_t *this, u_int8_t identifier)
+ private_eap_aka_server_t *this, uint8_t identifier)
{
this->identifier = identifier;
}
/**
* Binary represnation of the polynom T^160 + T^5 + T^3 + T^2 + 1
*/
-static u_int8_t g[] = {
+static uint8_t g[] = {
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x2d
/**
* Predefined random bits from the RAND Corporation book
*/
-static u_int8_t a[] = {
+static uint8_t a[] = {
0x9d, 0xe9, 0xc9, 0xc8, 0xef, 0xd5, 0x78, 0x11,
0x48, 0x23, 0x14, 0x01, 0x90, 0x1f, 0x2d, 0x49,
0x3f, 0x4c, 0x63, 0x65
/**
* Predefined random bits from the RAND Corporation book
*/
-static u_int8_t b[] = {
+static uint8_t b[] = {
0x75, 0xef, 0xd1, 0x5c, 0x4b, 0x8f, 0x8f, 0x51,
0x4e, 0xf3, 0xbc, 0xc3, 0x79, 0x4a, 0x76, 0x5e,
0x7e, 0xec, 0x45, 0xe0
* XOR the key into the SHA1 IV
*/
static bool step3(prf_t *prf, u_char k[AKA_K_LEN],
- u_char payload[AKA_PAYLOAD_LEN], u_int8_t h[HASH_SIZE_SHA1])
+ u_char payload[AKA_PAYLOAD_LEN], uint8_t h[HASH_SIZE_SHA1])
{
/* use the keyed hasher to build the hash */
return prf->set_key(prf, chunk_create(k, AKA_K_LEN)) &&
/**
* Calculation function of f1() and f1star()
*/
-static bool f1x(prf_t *prf, u_int8_t f, u_char k[AKA_K_LEN],
+static bool f1x(prf_t *prf, uint8_t f, u_char k[AKA_K_LEN],
u_char rand[AKA_RAND_LEN], u_char sqn[AKA_SQN_LEN],
u_char amf[AKA_AMF_LEN], u_char mac[AKA_MAC_LEN])
{
* Load the given EAP method
*/
static eap_method_t *load_method(private_eap_dynamic_t *this,
- eap_type_t type, u_int32_t vendor)
+ eap_type_t type, uint32_t vendor)
{
eap_method_t *method;
private_eap_dynamic_t *this, eap_payload_t *in, eap_payload_t **out)
{
eap_type_t received_type, type;
- u_int32_t received_vendor, vendor;
+ uint32_t received_vendor, vendor;
received_type = in->get_type(in, &received_vendor);
if (received_vendor == 0 && received_type == EAP_NAK)
}
METHOD(eap_method_t, get_type, eap_type_t,
- private_eap_dynamic_t *this, u_int32_t *vendor)
+ private_eap_dynamic_t *this, uint32_t *vendor)
{
if (this->method)
{
return FAILED;
}
-METHOD(eap_method_t, get_identifier, u_int8_t,
+METHOD(eap_method_t, get_identifier, uint8_t,
private_eap_dynamic_t *this)
{
if (this->method)
}
METHOD(eap_method_t, set_identifier, void,
- private_eap_dynamic_t *this, u_int8_t identifier)
+ private_eap_dynamic_t *this, uint8_t identifier)
{
if (this->method)
{
{
enumerator_t *enumerator;
eap_type_t type;
- u_int32_t vendor;
+ uint32_t vendor;
enumerator = charon->eap->create_enumerator(charon->eap, EAP_SERVER);
while (enumerator->enumerate(enumerator, &type, &vendor))
/**
* EAP message identififier
*/
- u_int8_t identifier;
+ uint8_t identifier;
};
typedef struct eap_gtc_header_t eap_gtc_header_t;
*/
struct eap_gtc_header_t {
/** EAP code (REQUEST/RESPONSE) */
- u_int8_t code;
+ uint8_t code;
/** unique message identifier */
- u_int8_t identifier;
+ uint8_t identifier;
/** length of whole message */
- u_int16_t length;
+ uint16_t length;
/** EAP type */
- u_int8_t type;
+ uint8_t type;
/** type data */
- u_int8_t data[];
+ uint8_t data[];
} __attribute__((__packed__));
METHOD(eap_method_t, initiate_peer, status_t,
}
METHOD(eap_method_t, get_type, eap_type_t,
- private_eap_gtc_t *this, u_int32_t *vendor)
+ private_eap_gtc_t *this, uint32_t *vendor)
{
*vendor = 0;
return EAP_GTC;
return FAILED;
}
-METHOD(eap_method_t, get_identifier, u_int8_t,
+METHOD(eap_method_t, get_identifier, uint8_t,
private_eap_gtc_t *this)
{
return this->identifier;
}
METHOD(eap_method_t, set_identifier, void,
- private_eap_gtc_t *this, u_int8_t identifier)
+ private_eap_gtc_t *this, uint8_t identifier)
{
this->identifier = identifier;
}
/**
* EAP identifier
*/
- u_int8_t identifier;
+ uint8_t identifier;
};
typedef struct eap_identity_header_t eap_identity_header_t;
*/
struct eap_identity_header_t {
/** EAP code (REQUEST/RESPONSE) */
- u_int8_t code;
+ uint8_t code;
/** unique message identifier */
- u_int8_t identifier;
+ uint8_t identifier;
/** length of whole message */
- u_int16_t length;
+ uint16_t length;
/** EAP type */
- u_int8_t type;
+ uint8_t type;
/** identity data */
- u_int8_t data[];
+ uint8_t data[];
} __attribute__((__packed__));
METHOD(eap_method_t, process_peer, status_t,
}
METHOD(eap_method_t, get_type, eap_type_t,
- private_eap_identity_t *this, u_int32_t *vendor)
+ private_eap_identity_t *this, uint32_t *vendor)
{
*vendor = 0;
return EAP_IDENTITY;
return FAILED;
}
-METHOD(eap_method_t, get_identifier, u_int8_t,
+METHOD(eap_method_t, get_identifier, uint8_t,
private_eap_identity_t *this)
{
return this->identifier;
}
METHOD(eap_method_t, set_identifier, void,
- private_eap_identity_t *this, u_int8_t identifier)
+ private_eap_identity_t *this, uint8_t identifier)
{
this->identifier = identifier;
}
/**
* EAP message identifier
*/
- u_int8_t identifier;
+ uint8_t identifier;
};
typedef struct eap_md5_header_t eap_md5_header_t;
*/
struct eap_md5_header_t {
/** EAP code (REQUEST/RESPONSE) */
- u_int8_t code;
+ uint8_t code;
/** unique message identifier */
- u_int8_t identifier;
+ uint8_t identifier;
/** length of whole message */
- u_int16_t length;
+ uint16_t length;
/** EAP type */
- u_int8_t type;
+ uint8_t type;
/** length of value (challenge) */
- u_int8_t value_size;
+ uint8_t value_size;
/** actual value */
- u_int8_t value[];
+ uint8_t value[];
} __attribute__((__packed__));
#define CHALLENGE_LEN 16
}
METHOD(eap_method_t, get_type, eap_type_t,
- private_eap_md5_t *this, u_int32_t *vendor)
+ private_eap_md5_t *this, uint32_t *vendor)
{
*vendor = 0;
return EAP_MD5;
return FALSE;
}
-METHOD(eap_method_t, get_identifier, u_int8_t,
+METHOD(eap_method_t, get_identifier, uint8_t,
private_eap_md5_t *this)
{
return this->identifier;
}
METHOD(eap_method_t, set_identifier, void,
- private_eap_md5_t *this, u_int8_t identifier)
+ private_eap_md5_t *this, uint8_t identifier)
{
this->identifier = identifier;
}
/**
* EAP message identifier
*/
- u_int8_t identifier;
+ uint8_t identifier;
/**
* MS-CHAPv2-ID (session ID, increases with each retry)
*/
- u_int8_t mschapv2id;
+ uint8_t mschapv2id;
/**
* Number of retries
struct eap_mschapv2_header_t
{
/** EAP code (REQUEST/RESPONSE) */
- u_int8_t code;
+ uint8_t code;
/** unique message identifier */
- u_int8_t identifier;
+ uint8_t identifier;
/** length of whole message */
- u_int16_t length;
+ uint16_t length;
/** EAP type */
- u_int8_t type;
+ uint8_t type;
/** MS-CHAPv2 OpCode */
- u_int8_t opcode;
+ uint8_t opcode;
/** MS-CHAPv2-ID (equals identifier) */
- u_int8_t ms_chapv2_id;
+ uint8_t ms_chapv2_id;
/** MS-Length (defined as length - 5) */
- u_int16_t ms_length;
+ uint16_t ms_length;
/** packet data (determined by OpCode) */
- u_int8_t data[];
+ uint8_t data[];
}__attribute__((__packed__));
/**
struct eap_mschapv2_challenge_t
{
/** Value-Size */
- u_int8_t value_size;
+ uint8_t value_size;
/** Challenge */
- u_int8_t challenge[CHALLENGE_LEN];
+ uint8_t challenge[CHALLENGE_LEN];
/** Name */
- u_int8_t name[];
+ uint8_t name[];
}__attribute__((__packed__));
/**
struct eap_mschapv2_response_t
{
/** Value-Size */
- u_int8_t value_size;
+ uint8_t value_size;
/** Response */
struct
{
/* Peer-Challenge*/
- u_int8_t peer_challenge[CHALLENGE_LEN];
+ uint8_t peer_challenge[CHALLENGE_LEN];
/* Reserved (=zero) */
- u_int8_t peer_reserved[8];
+ uint8_t peer_reserved[8];
/* NT-Response */
- u_int8_t nt_response[24];
+ uint8_t nt_response[24];
/* Flags (=zero) */
- u_int8_t flags;
+ uint8_t flags;
} response;
/** Name */
- u_int8_t name[];
+ uint8_t name[];
}__attribute__((__packed__));
/**
/**
* Set the ms_length field using aligned write
*/
-static void set_ms_length(eap_mschapv2_header_t *eap, u_int16_t len)
+static void set_ms_length(eap_mschapv2_header_t *eap, uint16_t len)
{
len = htons(len - 5);
- memcpy(&eap->ms_length, &len, sizeof(u_int16_t));
+ memcpy(&eap->ms_length, &len, sizeof(uint16_t));
}
METHOD(eap_method_t, initiate_peer, status_t,
eap_mschapv2_header_t *eap;
eap_mschapv2_challenge_t *cha;
const char *name = MSCHAPV2_HOST_NAME;
- u_int16_t len = CHALLENGE_PAYLOAD_LEN + sizeof(MSCHAPV2_HOST_NAME) - 1;
+ uint16_t len = CHALLENGE_PAYLOAD_LEN + sizeof(MSCHAPV2_HOST_NAME) - 1;
rng = lib->crypto->create_rng(lib->crypto, RNG_WEAK);
if (!rng || !rng->allocate_bytes(rng, CHALLENGE_LEN, &this->challenge))
eap_mschapv2_challenge_t *cha;
eap_mschapv2_response_t *res;
chunk_t data, peer_challenge, userid, username, nt_hash;
- u_int16_t len = RESPONSE_PAYLOAD_LEN;
+ uint16_t len = RESPONSE_PAYLOAD_LEN;
data = in->get_data(in);
eap = (eap_mschapv2_header_t*)data.ptr;
chunk_t data, auth_string = chunk_empty;
char *message, *token, *msg = NULL;
int message_len;
- u_int16_t len = SHORT_HEADER_LEN;
+ uint16_t len = SHORT_HEADER_LEN;
data = in->get_data(in);
eap = (eap_mschapv2_header_t*)data.ptr;
rng_t *rng;
chunk_t hex;
char msg[FAILURE_MESSAGE_LEN];
- u_int16_t len = HEADER_LEN + FAILURE_MESSAGE_LEN - 1; /* no null byte */
+ uint16_t len = HEADER_LEN + FAILURE_MESSAGE_LEN - 1; /* no null byte */
if (++this->retries > MAX_RETRIES)
{
{
chunk_t hex;
char msg[AUTH_RESPONSE_LEN + sizeof(SUCCESS_MESSAGE)];
- u_int16_t len = HEADER_LEN + AUTH_RESPONSE_LEN + sizeof(SUCCESS_MESSAGE);
+ uint16_t len = HEADER_LEN + AUTH_RESPONSE_LEN + sizeof(SUCCESS_MESSAGE);
eap = alloca(len);
eap->code = EAP_REQUEST;
}
METHOD(eap_method_t, get_type, eap_type_t,
- private_eap_mschapv2_t *this, u_int32_t *vendor)
+ private_eap_mschapv2_t *this, uint32_t *vendor)
{
*vendor = 0;
return EAP_MSCHAPV2;
return FAILED;
}
-METHOD(eap_method_t, get_identifier, u_int8_t,
+METHOD(eap_method_t, get_identifier, uint8_t,
private_eap_mschapv2_t *this)
{
return this->identifier;
}
METHOD(eap_method_t, set_identifier, void,
- private_eap_mschapv2_t *this, u_int8_t identifier)
+ private_eap_mschapv2_t *this, uint8_t identifier)
{
this->identifier = identifier;
}
}
METHOD(eap_method_t, get_type, eap_type_t,
- private_eap_peap_t *this, u_int32_t *vendor)
+ private_eap_peap_t *this, uint32_t *vendor)
{
*vendor = 0;
return EAP_PEAP;
return FAILED;
}
-METHOD(eap_method_t, get_identifier, u_int8_t,
+METHOD(eap_method_t, get_identifier, uint8_t,
private_eap_peap_t *this)
{
return this->tls_eap->get_identifier(this->tls_eap);
}
METHOD(eap_method_t, set_identifier, void,
- private_eap_peap_t *this, u_int8_t identifier)
+ private_eap_peap_t *this, uint8_t identifier)
{
this->tls_eap->set_identifier(this->tls_eap, identifier);
}
METHOD(eap_peap_avp_t, build, void,
private_eap_peap_avp_t *this, bio_writer_t *writer, chunk_t data)
{
- u_int8_t code;
+ uint8_t code;
eap_packet_t *pkt;
chunk_t avp_data;
METHOD(eap_peap_avp_t, process, status_t,
private_eap_peap_avp_t* this, bio_reader_t *reader, chunk_t *data,
- u_int8_t identifier)
+ uint8_t identifier)
{
- u_int8_t code;
- u_int16_t len;
+ uint8_t code;
+ uint16_t len;
eap_packet_t *pkt;
chunk_t avp_data;
* - NEED_MORE if another invocation of process/build needed
*/
status_t (*process)(eap_peap_avp_t *this, bio_reader_t *reader,
- chunk_t *data, u_int8_t identifier);
+ chunk_t *data, uint8_t identifier);
/**
* Build EAP-PEAP Message AVP to send out.
eap_payload_t *in;
eap_code_t code;
eap_type_t type, received_type;
- u_int32_t vendor, received_vendor;
+ uint32_t vendor, received_vendor;
status = this->avp->process(this->avp, reader, &data,
this->ph1_method->get_identifier(this->ph1_method));
chunk_t data;
eap_code_t code;
eap_type_t type;
- u_int32_t vendor;
+ uint32_t vendor;
if (this->out)
{
eap_payload_t *in;
eap_code_t code;
eap_type_t type = EAP_NAK, received_type;
- u_int32_t vendor, received_vendor;
+ uint32_t vendor, received_vendor;
status = this->avp->process(this->avp, reader, &data,
this->ph1_method->get_identifier(this->ph1_method));
chunk_t data;
eap_code_t code;
eap_type_t type;
- u_int32_t vendor;
+ uint32_t vendor;
if (this->ph2_method == NULL && this->start_phase2 && this->start_phase2_id)
{
/**
* EAP vendor, if any
*/
- u_int32_t vendor;
+ uint32_t vendor;
/**
* EAP message identifier
*/
- u_int8_t identifier;
+ uint8_t identifier;
/**
* RADIUS client instance
{
struct {
/** EAP code (REQUEST/RESPONSE) */
- u_int8_t code;
+ uint8_t code;
/** unique message identifier */
- u_int8_t identifier;
+ uint8_t identifier;
/** length of whole message */
- u_int16_t length;
+ uint16_t length;
/** EAP type */
- u_int8_t type;
+ uint8_t type;
/** identity data */
- u_int8_t data[];
+ uint8_t data[];
} __attribute__((__packed__)) *hdr;
chunk_t id, prefix;
size_t len;
ike_sa_t *ike_sa;
host_t *host;
char buf[40], *station_id_fmt;;
- u_int32_t value;
+ uint32_t value;
chunk_t chunk;
/* virtual NAS-Port-Type */
{
enumerator_t *enumerator;
int type;
- u_int8_t tunnel_tag;
- u_int32_t tunnel_type;
+ uint8_t tunnel_tag;
+ uint32_t tunnel_type;
chunk_t filter_id = chunk_empty, data;
bool is_esp_tunnel = FALSE;
/**
* Add a Cisco Unity configuration attribute
*/
-static void add_unity_attribute(eap_radius_provider_t *provider, u_int32_t id,
+static void add_unity_attribute(eap_radius_provider_t *provider, uint32_t id,
int type, chunk_t data)
{
switch (type)
* Add a DNS/NBNS configuration attribute
*/
static void add_nameserver_attribute(eap_radius_provider_t *provider,
- u_int32_t id, int type, chunk_t data)
+ uint32_t id, int type, chunk_t data)
{
/* these are from different vendors, but there is currently no conflict */
switch (type)
* Add a UNITY_LOCAL_LAN or UNITY_SPLIT_INCLUDE attribute
*/
static void add_unity_split_attribute(eap_radius_provider_t *provider,
- u_int32_t id, configuration_attribute_type_t type,
+ uint32_t id, configuration_attribute_type_t type,
chunk_t data)
{
enumerator_t *enumerator;
}
METHOD(eap_method_t, get_type, eap_type_t,
- private_eap_radius_t *this, u_int32_t *vendor)
+ private_eap_radius_t *this, uint32_t *vendor)
{
*vendor = this->vendor;
return this->type;
return FAILED;
}
-METHOD(eap_method_t, get_identifier, u_int8_t,
+METHOD(eap_method_t, get_identifier, uint8_t,
private_eap_radius_t *this)
{
return this->identifier;
}
METHOD(eap_method_t, set_identifier, void,
- private_eap_radius_t *this, u_int8_t identifier)
+ private_eap_radius_t *this, uint8_t identifier)
{
this->identifier = identifier;
}
/**
* Session ID prefix
*/
- u_int32_t prefix;
+ uint32_t prefix;
/**
* Format string we use for Called/Calling-Station-Id for a host
*/
typedef struct {
struct {
- u_int64_t sent;
- u_int64_t received;
+ uint64_t sent;
+ uint64_t received;
} bytes, packets;
} usage_t;
*/
typedef struct {
/** unique CHILD_SA identifier */
- u_int32_t id;
+ uint32_t id;
/** usage stats for this SA */
usage_t usage;
} sa_entry_t;
radius_acct_terminate_cause_t cause;
/* interim interval and timestamp of last update */
struct {
- u_int32_t interval;
+ uint32_t interval;
time_t last;
} interim;
/** did we send Accounting-Start */
/**
* Update or create usage counters of a cached SA
*/
-static void update_sa(entry_t *entry, u_int32_t id, usage_t usage)
+static void update_sa(entry_t *entry, uint32_t id, usage_t usage)
{
sa_entry_t *sa, lookup;
host_t *vip, *host;
char buf[MAX_RADIUS_ATTRIBUTE_SIZE + 1];
chunk_t data;
- u_int32_t value;
+ uint32_t value;
/* virtual NAS-Port-Type */
value = htonl(5);
* Get an existing or create a new entry from the locked session table
*/
static entry_t* get_or_create_entry(private_eap_radius_accounting_t *this,
- ike_sa_id_t *id, u_int32_t unique)
+ ike_sa_id_t *id, uint32_t unique)
{
entry_t *entry;
time_t now;
enumerator_t *enumerator;
ike_sa_t *ike_sa;
entry_t *entry;
- u_int32_t value;
+ uint32_t value;
array_t *stats;
sa_entry_t *sa, *found;
{
radius_message_t *message;
entry_t *entry;
- u_int32_t value;
+ uint32_t value;
if (this->acct_req_vip && !has_vip(ike_sa))
{
enumerator_t *enumerator;
entry_t *entry;
sa_entry_t *sa;
- u_int32_t value;
+ uint32_t value;
this->mutex->lock(this->mutex);
entry = this->sessions->remove(this->sessions, ike_sa->get_id(ike_sa));
METHOD(listener_t, children_migrate, bool,
private_eap_radius_accounting_t *this, ike_sa_t *ike_sa, ike_sa_id_t *new,
- u_int32_t unique)
+ uint32_t unique)
{
enumerator_t *enumerator;
sa_entry_t *sa, *sa_new, *cached;
.destroy = _destroy,
},
/* use system time as Session ID prefix */
- .prefix = (u_int32_t)time(NULL),
+ .prefix = (uint32_t)time(NULL),
.sessions = hashtable_create((hashtable_hash_t)hash,
(hashtable_equals_t)equals, 32),
.mutex = mutex_create(MUTEX_TYPE_DEFAULT),
/**
* See header
*/
-void eap_radius_accounting_start_interim(ike_sa_t *ike_sa, u_int32_t interval)
+void eap_radius_accounting_start_interim(ike_sa_t *ike_sa, uint32_t interval)
{
if (singleton)
{
* @param ike_sa IKE_SA to send updates for
* @param interval interval for interim updates
*/
-void eap_radius_accounting_start_interim(ike_sa_t *ike_sa, u_int32_t interval);
+void eap_radius_accounting_start_interim(ike_sa_t *ike_sa, uint32_t interval);
#endif /** EAP_RADIUS_ACCOUNTING_H_ @}*/
* Apply a new lifetime to an IKE_SA
*/
static void apply_lifetime(private_eap_radius_dae_t *this, ike_sa_id_t *id,
- u_int32_t lifetime)
+ uint32_t lifetime)
{
ike_sa_t *ike_sa;
ike_sa_id_t *id;
chunk_t data;
int type;
- u_int32_t lifetime = 0;
+ uint32_t lifetime = 0;
bool lifetime_seen = FALSE;
ids = get_matching_ike_sas(this, request, client);
*/
typedef struct {
/** vendor ID, 0 for standard attributes */
- u_int32_t vendor;
+ uint32_t vendor;
/** attribute type */
- u_int8_t type;
+ uint8_t type;
} attr_t;
/**
radius_attribute_type_t type, chunk_t data)
{
enumerator_t *enumerator;
- u_int32_t vendor = 0;
+ uint32_t vendor = 0;
attr_t *sel;
bool found = FALSE;
}
METHOD(eap_radius_provider_t, add_framed_ip, void,
- private_eap_radius_provider_t *this, u_int32_t id, host_t *ip)
+ private_eap_radius_provider_t *this, uint32_t id, host_t *ip)
{
this->listener.mutex->lock(this->listener.mutex);
add_addr(this, this->listener.unclaimed, id, ip);
}
METHOD(eap_radius_provider_t, add_attribute, void,
- private_eap_radius_provider_t *this, u_int32_t id,
+ private_eap_radius_provider_t *this, uint32_t id,
configuration_attribute_type_t type, chunk_t data)
{
attr_t *attr;
* @param id IKE_SA unique identifier
* @param ip IP address received from RADIUS server, gets owned
*/
- void (*add_framed_ip)(eap_radius_provider_t *this, u_int32_t id,
+ void (*add_framed_ip)(eap_radius_provider_t *this, uint32_t id,
host_t *ip);
/**
* @param type attribute type
* @param data attribute data
*/
- void (*add_attribute)(eap_radius_provider_t *this, u_int32_t id,
+ void (*add_attribute)(eap_radius_provider_t *this, uint32_t id,
configuration_attribute_type_t type, chunk_t data);
/**
/**
* EAP message identifier
*/
- u_int8_t identifier;
+ uint8_t identifier;
/**
* EAP-SIM crypto helper
/**
* Counter value if reauthentication is used
*/
- u_int16_t counter;
+ uint16_t counter;
};
/* version of SIM protocol we speak */
simaka_client_error_t code, eap_payload_t **out)
{
simaka_message_t *message;
- u_int16_t encoded;
+ uint16_t encoded;
DBG1(DBG_IKE, "sending client error '%N'", simaka_client_error_names, code);
*/
static bool counter_too_small(private_eap_sim_peer_t *this, chunk_t chunk)
{
- u_int16_t counter;
+ uint16_t counter;
memcpy(&counter, chunk.ptr, sizeof(counter));
counter = htons(counter);
{
if (type == AT_NOTIFICATION)
{
- u_int16_t code;
+ uint16_t code;
memcpy(&code, data.ptr, sizeof(code));
code = ntohs(code);
}
METHOD(eap_method_t, get_type, eap_type_t,
- private_eap_sim_peer_t *this, u_int32_t *vendor)
+ private_eap_sim_peer_t *this, uint32_t *vendor)
{
*vendor = 0;
return EAP_SIM;
return FAILED;
}
-METHOD(eap_method_t, get_identifier, u_int8_t,
+METHOD(eap_method_t, get_identifier, uint8_t,
private_eap_sim_peer_t *this)
{
return this->identifier;
}
METHOD(eap_method_t, set_identifier, void,
- private_eap_sim_peer_t *this, u_int8_t identifier)
+ private_eap_sim_peer_t *this, uint8_t identifier)
{
this->identifier = identifier;
}
/**
* unique EAP identifier
*/
- u_int8_t identifier;
+ uint8_t identifier;
/**
* concatenated SRES values
* Initiate EAP-SIM/Request/Re-authentication message
*/
static status_t reauthenticate(private_eap_sim_server_t *this,
- char mk[HASH_SIZE_SHA1], u_int16_t counter,
+ char mk[HASH_SIZE_SHA1], uint16_t counter,
eap_payload_t **out)
{
simaka_message_t *message;
if (this->use_reauth && !nonce.len)
{
char mk[HASH_SIZE_SHA1];
- u_int16_t counter;
+ uint16_t counter;
permanent = this->mgr->provider_is_reauth(this->mgr, id,
mk, &counter);
{
if (type == AT_CLIENT_ERROR_CODE)
{
- u_int16_t code;
+ uint16_t code;
memcpy(&code, data.ptr, sizeof(code));
DBG1(DBG_IKE, "received EAP-SIM client error '%N'",
}
METHOD(eap_method_t, get_type, eap_type_t,
- private_eap_sim_server_t *this, u_int32_t *vendor)
+ private_eap_sim_server_t *this, uint32_t *vendor)
{
*vendor = 0;
return EAP_SIM;
return FAILED;
}
-METHOD(eap_method_t, get_identifier, u_int8_t,
+METHOD(eap_method_t, get_identifier, uint8_t,
private_eap_sim_server_t *this)
{
return this->identifier;
}
METHOD(eap_method_t, set_identifier, void,
- private_eap_sim_server_t *this, u_int8_t identifier)
+ private_eap_sim_server_t *this, uint8_t identifier)
{
this->identifier = identifier;
}
/** associated permanent identity */
identification_t *permanent;
/** counter value */
- u_int16_t counter;
+ uint16_t counter;
/** master key */
char mk[HASH_SIZE_SHA1];
} reauth_data_t;
METHOD(simaka_card_t, get_reauth, identification_t*,
private_eap_simaka_reauth_card_t *this, identification_t *id,
- char mk[HASH_SIZE_SHA1], u_int16_t *counter)
+ char mk[HASH_SIZE_SHA1], uint16_t *counter)
{
reauth_data_t *data;
identification_t *reauth;
METHOD(simaka_card_t, set_reauth, void,
private_eap_simaka_reauth_card_t *this, identification_t *id,
- identification_t* next, char mk[HASH_SIZE_SHA1], u_int16_t counter)
+ identification_t* next, char mk[HASH_SIZE_SHA1], uint16_t counter)
{
reauth_data_t *data;
/** currently used reauthentication identity */
identification_t *id;
/** counter value */
- u_int16_t counter;
+ uint16_t counter;
/** master key */
char mk[HASH_SIZE_SHA1];
} reauth_data_t;
METHOD(simaka_provider_t, is_reauth, identification_t*,
private_eap_simaka_reauth_provider_t *this, identification_t *id,
- char mk[HASH_SIZE_SHA1], u_int16_t *counter)
+ char mk[HASH_SIZE_SHA1], uint16_t *counter)
{
identification_t *permanent;
reauth_data_t *data;
}
METHOD(eap_method_t, get_type, eap_type_t,
- private_eap_tls_t *this, u_int32_t *vendor)
+ private_eap_tls_t *this, uint32_t *vendor)
{
*vendor = 0;
return EAP_TLS;
return FAILED;
}
-METHOD(eap_method_t, get_identifier, u_int8_t,
+METHOD(eap_method_t, get_identifier, uint8_t,
private_eap_tls_t *this)
{
return this->tls_eap->get_identifier(this->tls_eap);
}
METHOD(eap_method_t, set_identifier, void,
- private_eap_tls_t *this, u_int8_t identifier)
+ private_eap_tls_t *this, uint8_t identifier)
{
this->tls_eap->set_identifier(this->tls_eap, identifier);
}
}
METHOD(eap_method_t, get_type, eap_type_t,
- private_eap_ttls_t *this, u_int32_t *vendor)
+ private_eap_ttls_t *this, uint32_t *vendor)
{
*vendor = 0;
return EAP_TTLS;
return FAILED;
}
-METHOD(eap_method_t, get_identifier, u_int8_t,
+METHOD(eap_method_t, get_identifier, uint8_t,
private_eap_ttls_t *this)
{
return this->tls_eap->get_identifier(this->tls_eap);
}
METHOD(eap_method_t, set_identifier, void,
- private_eap_ttls_t *this, u_int8_t identifier)
+ private_eap_ttls_t *this, uint8_t identifier)
{
this->tls_eap->set_identifier(this->tls_eap, identifier);
}
{
char zero_padding[] = { 0x00, 0x00, 0x00 };
chunk_t avp_padding;
- u_int8_t avp_flags;
- u_int32_t avp_len;
+ uint8_t avp_flags;
+ uint32_t avp_len;
avp_flags = 0x40;
avp_len = 8 + data.len;
if (this->process_header)
{
bio_reader_t *header;
- u_int32_t avp_code;
- u_int8_t avp_flags;
- u_int32_t avp_len;
+ uint32_t avp_code;
+ uint8_t avp_flags;
+ uint32_t avp_len;
bool success;
len = min(reader->remaining(reader), AVP_HEADER_LEN - this->inpos);
eap_packet_t *pkt;
eap_code_t code;
eap_type_t type, received_type;
- u_int32_t vendor, received_vendor;
- u_int16_t eap_len;
+ uint32_t vendor, received_vendor;
+ uint16_t eap_len;
size_t eap_pos = 0;
bool concatenated = FALSE;
chunk_t data;
eap_code_t code;
eap_type_t type;
- u_int32_t vendor;
+ uint32_t vendor;
if (this->method == NULL && this->start_phase2)
{
/** list of remote selectors */
linked_list_t *remote;
/** reqid of CHILD_SA */
- u_int32_t reqid;
+ uint32_t reqid;
} entry_t;
METHOD(listener_t, child_updown, bool,
* IP over Ethernet ARP message
*/
typedef struct __attribute__((packed)) {
- u_int16_t hardware_type;
- u_int16_t protocol_type;
- u_int8_t hardware_size;
- u_int8_t protocol_size;
- u_int16_t opcode;
- u_int8_t sender_mac[6];
- u_int8_t sender_ip[4];
- u_int8_t target_mac[6];
- u_int8_t target_ip[4];
+ uint16_t hardware_type;
+ uint16_t protocol_type;
+ uint8_t hardware_size;
+ uint8_t protocol_size;
+ uint16_t opcode;
+ uint8_t sender_mac[6];
+ uint8_t sender_ip[4];
+ uint8_t target_mac[6];
+ uint8_t target_ip[4];
} arp_t;
/**
/**
* current broadcast address of internal network
*/
- u_int32_t broadcast;
+ uint32_t broadcast;
/**
* LAN interface index
/**
* Send a broadcast/multicast packet to a peer
*/
-static void send_peer(private_forecast_forwarder_t *this, u_int32_t dst,
+static void send_peer(private_forecast_forwarder_t *this, uint32_t dst,
void *buf, size_t len, int mark)
{
struct sockaddr_in addr = {
/**
* Attach the socket filter to the socket
*/
-static bool attach_filter(int fd, u_int32_t broadcast)
+static bool attach_filter(int fd, uint32_t broadcast)
{
struct sock_filter filter_code[] = {
/* destination address: is ... */
/**
* Broadcast address on LAN interface, network order
*/
- u_int32_t broadcast;
+ uint32_t broadcast;
};
/**
/** remote IKE_SA endpoint */
host_t *rhost;
/** inbound SPI */
- u_int32_t spi;
+ uint32_t spi;
/** use UDP encapsulation */
bool encap;
/** whether we should allow reencapsulation of IPsec received forecasts */
bool reinject;
/** broadcast address used for that entry */
- u_int32_t broadcast;
+ uint32_t broadcast;
} entry_t;
/**
static bool ts2in(traffic_selector_t *ts,
struct in_addr *addr, struct in_addr *mask)
{
- u_int8_t bits;
+ uint8_t bits;
host_t *net;
if (ts->get_type(ts) == TS_IPV4_ADDR_RANGE &&
static bool manage_pre_esp_in_udp(struct iptc_handle *ipth,
entry_t *entry, bool add)
{
- u_int16_t match_size = XT_ALIGN(sizeof(struct ipt_entry_match)) +
+ uint16_t match_size = XT_ALIGN(sizeof(struct ipt_entry_match)) +
XT_ALIGN(sizeof(struct xt_udp));
- u_int16_t target_offset = XT_ALIGN(sizeof(struct ipt_entry)) + match_size;
- u_int16_t target_size = XT_ALIGN(sizeof(struct ipt_entry_target)) +
+ uint16_t target_offset = XT_ALIGN(sizeof(struct ipt_entry)) + match_size;
+ uint16_t target_size = XT_ALIGN(sizeof(struct ipt_entry_target)) +
XT_ALIGN(sizeof(struct xt_mark_tginfo2));
- u_int16_t entry_size = target_offset + target_size;
+ uint16_t entry_size = target_offset + target_size;
u_char ipt[entry_size], *pos = ipt;
struct ipt_entry *e;
*/
static bool manage_pre_esp(struct iptc_handle *ipth, entry_t *entry, bool add)
{
- u_int16_t match_size = XT_ALIGN(sizeof(struct ipt_entry_match)) +
+ uint16_t match_size = XT_ALIGN(sizeof(struct ipt_entry_match)) +
XT_ALIGN(sizeof(struct xt_esp));
- u_int16_t target_offset = XT_ALIGN(sizeof(struct ipt_entry)) + match_size;
- u_int16_t target_size = XT_ALIGN(sizeof(struct ipt_entry_target)) +
+ uint16_t target_offset = XT_ALIGN(sizeof(struct ipt_entry)) + match_size;
+ uint16_t target_size = XT_ALIGN(sizeof(struct ipt_entry_target)) +
XT_ALIGN(sizeof(struct xt_mark_tginfo2));
- u_int16_t entry_size = target_offset + target_size;
+ uint16_t entry_size = target_offset + target_size;
u_char ipt[entry_size], *pos = ipt;
struct ipt_entry *e;
*/
static bool manage_out(struct iptc_handle *ipth, entry_t *entry, bool add)
{
- u_int16_t target_offset = XT_ALIGN(sizeof(struct ipt_entry));
- u_int16_t target_size = XT_ALIGN(sizeof(struct ipt_entry_target)) +
+ uint16_t target_offset = XT_ALIGN(sizeof(struct ipt_entry));
+ uint16_t target_size = XT_ALIGN(sizeof(struct ipt_entry_target)) +
XT_ALIGN(sizeof(struct xt_mark_tginfo2));
- u_int16_t entry_size = target_offset + target_size;
+ uint16_t entry_size = target_offset + target_size;
u_char ipt[entry_size], *pos = ipt;
struct ipt_entry *e;
* Filter to map entries to ts/mark
*/
static bool ts_filter(entry_t *entry, traffic_selector_t **ts,
- traffic_selector_t **out, void *dummy, u_int32_t *mark,
+ traffic_selector_t **out, void *dummy, uint32_t *mark,
void *dummy2, bool *reinject)
{
*out = *ts;
{
chunk_t addr;
host_t *host;
- u_int32_t *pos;
+ uint32_t *pos;
if (offset > pool->size)
{
addr = chunk_clone(pool->base->get_address(pool->base));
if (pool->base->get_family(pool->base) == AF_INET6)
{
- pos = (u_int32_t*)(addr.ptr + 12);
+ pos = (uint32_t*)(addr.ptr + 12);
}
else
{
- pos = (u_int32_t*)addr.ptr;
+ pos = (uint32_t*)addr.ptr;
}
*pos = htonl(offset + ntohl(*pos));
host = host_create_from_chunk(pool->base->get_family(pool->base), addr, 0);
static int host2offset(pool_t *pool, host_t *addr)
{
chunk_t host, base;
- u_int32_t hosti, basei;
+ uint32_t hosti, basei;
if (addr->get_family(addr) != pool->base->get_family(pool->base))
{
host = chunk_skip(host, 12);
base = chunk_skip(base, 12);
}
- hosti = ntohl(*(u_int32_t*)(host.ptr));
- basei = ntohl(*(u_int32_t*)(base.ptr));
+ hosti = ntohl(*(uint32_t*)(host.ptr));
+ basei = ntohl(*(uint32_t*)(base.ptr));
if (hosti > basei + pool->size)
{
return -1;
linked_list_t *children;
struct {
protocol_id_t protocol;
- u_int32_t spi;
+ uint32_t spi;
} *info;
children = linked_list_create();
ha_message_t *m;
chunk_t secret;
proposal_t *proposal;
- u_int16_t alg, len;
+ uint16_t alg, len;
linked_list_t *local_ts, *remote_ts;
enumerator_t *enumerator;
traffic_selector_t *ts;
m = ha_message_create(HA_CHILD_ADD);
m->add_attribute(m, HA_IKE_ID, ike_sa->get_id(ike_sa));
- m->add_attribute(m, HA_INITIATOR, (u_int8_t)initiator);
+ m->add_attribute(m, HA_INITIATOR, (uint8_t)initiator);
m->add_attribute(m, HA_INBOUND_SPI, child_sa->get_spi(child_sa, TRUE));
m->add_attribute(m, HA_OUTBOUND_SPI, child_sa->get_spi(child_sa, FALSE));
m->add_attribute(m, HA_INBOUND_CPI, child_sa->get_cpi(child_sa, TRUE));
enumerator_t *enumerator;
ike_sa_t *ike_sa = NULL, *old_sa = NULL;
ike_version_t version = IKEV2;
- u_int16_t encr = 0, len = 0, integ = 0, prf = 0, old_prf = PRF_UNDEFINED;
- u_int16_t dh_grp = 0;
+ uint16_t encr = 0, len = 0, integ = 0, prf = 0, old_prf = PRF_UNDEFINED;
+ uint16_t dh_grp = 0;
chunk_t nonce_i = chunk_empty, nonce_r = chunk_empty;
chunk_t secret = chunk_empty, old_skd = chunk_empty;
chunk_t dh_local = chunk_empty, dh_remote = chunk_empty, psk = chunk_empty;
ha_message_value_t value;
enumerator_t *enumerator;
ike_sa_t *ike_sa = NULL;
- u_int32_t mid = 0;
+ uint32_t mid = 0;
enumerator = message->create_attribute_enumerator(message);
while (enumerator->enumerate(enumerator, &attribute, &value))
child_sa_t *child_sa;
proposal_t *proposal;
bool initiator = FALSE, failed = FALSE, ok = FALSE;
- u_int32_t inbound_spi = 0, outbound_spi = 0;
- u_int16_t inbound_cpi = 0, outbound_cpi = 0;
- u_int8_t mode = MODE_TUNNEL, ipcomp = 0;
- u_int16_t encr = 0, integ = 0, len = 0, dh_grp = 0;
- u_int16_t esn = NO_EXT_SEQ_NUMBERS;
+ uint32_t inbound_spi = 0, outbound_spi = 0;
+ uint16_t inbound_cpi = 0, outbound_cpi = 0;
+ uint8_t mode = MODE_TUNNEL, ipcomp = 0;
+ uint16_t encr = 0, integ = 0, len = 0, dh_grp = 0;
+ uint16_t esn = NO_EXT_SEQ_NUMBERS;
u_int seg_i, seg_o;
chunk_t nonce_i = chunk_empty, nonce_r = chunk_empty, secret = chunk_empty;
chunk_t encr_i, integ_i, encr_r, integ_r;
if (ike_sa->get_version(ike_sa) == IKEV1)
{
keymat_v1_t *keymat_v1 = (keymat_v1_t*)ike_sa->get_keymat(ike_sa);
- u_int32_t spi_i, spi_r;
+ uint32_t spi_i, spi_r;
spi_i = initiator ? inbound_spi : outbound_spi;
spi_r = initiator ? outbound_spi : inbound_spi;
enumerator_t *enumerator;
ike_sa_t *ike_sa = NULL;
child_sa_t *child_sa;
- u_int32_t spi = 0;
+ uint32_t spi = 0;
enumerator = message->create_attribute_enumerator(message);
while (enumerator->enumerate(enumerator, &attribute, &value))
ha_message_t *m;
chunk_t secret;
proposal_t *proposal;
- u_int16_t alg, len;
+ uint16_t alg, len;
if (this->tunnel && this->tunnel->is_sa(this->tunnel, ike_sa))
{ /* do not sync SA between nodes */
{
enumerator_t *enumerator;
peer_cfg_t *peer_cfg;
- u_int32_t extension, condition;
+ uint32_t extension, condition;
host_t *addr;
ike_sa_id_t *id;
identification_t *eap_id;
ha_message_t *m;
notify_payload_t *notify;
chunk_t data;
- u_int32_t seq;
+ uint32_t seq;
notify = message->get_notify(message, DPD_R_U_THERE);
if (notify)
#include "ha_kernel.h"
-typedef u_int32_t u32;
-typedef u_int8_t u8;
+typedef uint32_t u32;
+typedef uint8_t u8;
#include <sys/utsname.h>
#include <string.h>
/**
* jhash algorithm of two words, as used in kernel (using 0 as initval)
*/
-static u_int32_t jhash(jhash_version_t version, u_int32_t a, u_int32_t b)
+static uint32_t jhash(jhash_version_t version, uint32_t a, uint32_t b)
{
- u_int32_t c = 0;
+ uint32_t c = 0;
switch (version)
{
/**
* Segmentate a calculated hash
*/
-static u_int hash2segment(private_ha_kernel_t *this, u_int64_t hash)
+static u_int hash2segment(private_ha_kernel_t *this, uint64_t hash)
{
return ((hash * this->count) >> 32) + 1;
}
/**
* Get a host as an integer for hashing
*/
-static u_int32_t host2int(host_t *host)
+static uint32_t host2int(host_t *host)
{
if (host->get_family(host) == AF_INET)
{
- return *(u_int32_t*)host->get_address(host).ptr;
+ return *(uint32_t*)host->get_address(host).ptr;
}
return 0;
}
private_ha_kernel_t *this, host_t *host)
{
unsigned long hash;
- u_int32_t addr;
+ uint32_t addr;
addr = host2int(host);
hash = jhash(this->version, ntohl(addr), 0);
}
METHOD(ha_kernel_t, get_segment_spi, u_int,
- private_ha_kernel_t *this, host_t *host, u_int32_t spi)
+ private_ha_kernel_t *this, host_t *host, uint32_t spi)
{
unsigned long hash;
- u_int32_t addr;
+ uint32_t addr;
addr = host2int(host);
hash = jhash(this->version, ntohl(addr), ntohl(spi));
* @param spi SPI to include in hash
* @return segment number
*/
- u_int (*get_segment_spi)(ha_kernel_t *this, host_t *host, u_int32_t spi);
+ u_int (*get_segment_spi)(ha_kernel_t *this, host_t *host, uint32_t spi);
/**
* Get the segment an arbitrary integer is in.
* Encoding if an ike_sa_id_t
*/
struct ike_sa_id_encoding_t {
- u_int8_t ike_version;
- u_int64_t initiator_spi;
- u_int64_t responder_spi;
- u_int8_t initiator;
+ uint8_t ike_version;
+ uint64_t initiator_spi;
+ uint64_t responder_spi;
+ uint8_t initiator;
} __attribute__((packed));
typedef struct identification_encoding_t identification_encoding_t;
* Encoding of a identification_t
*/
struct identification_encoding_t {
- u_int8_t type;
- u_int8_t len;
+ uint8_t type;
+ uint8_t len;
char encoding[];
} __attribute__((packed));
* encoding of a host_t
*/
struct host_encoding_t {
- u_int16_t port;
- u_int8_t family;
+ uint16_t port;
+ uint8_t family;
char encoding[];
} __attribute__((packed));
* encoding of a traffic_selector_t
*/
struct ts_encoding_t {
- u_int8_t type;
- u_int8_t protocol;
- u_int16_t from_port;
- u_int16_t to_port;
- u_int8_t dynamic;
+ uint8_t type;
+ uint8_t protocol;
+ uint16_t from_port;
+ uint16_t to_port;
+ uint8_t dynamic;
char encoding[];
} __attribute__((packed));
size_t len;
va_list args;
- check_buf(this, sizeof(u_int8_t));
+ check_buf(this, sizeof(uint8_t));
this->buf.ptr[this->buf.len] = attribute;
- this->buf.len += sizeof(u_int8_t);
+ this->buf.len += sizeof(uint8_t);
va_start(args, attribute);
switch (attribute)
this->buf.len += len;
break;
}
- /* u_int8_t */
+ /* uint8_t */
case HA_IKE_VERSION:
case HA_INITIATOR:
case HA_IPSEC_MODE:
case HA_IPCOMP:
{
- u_int8_t val;
+ uint8_t val;
val = va_arg(args, u_int);
check_buf(this, sizeof(val));
this->buf.len += sizeof(val);
break;
}
- /* u_int16_t */
+ /* uint16_t */
case HA_ALG_DH:
case HA_ALG_PRF:
case HA_ALG_OLD_PRF:
case HA_SEGMENT:
case HA_ESN:
{
- u_int16_t val;
+ uint16_t val;
val = va_arg(args, u_int);
check_buf(this, sizeof(val));
- *(u_int16_t*)(this->buf.ptr + this->buf.len) = htons(val);
+ *(uint16_t*)(this->buf.ptr + this->buf.len) = htons(val);
this->buf.len += sizeof(val);
break;
}
- /** u_int32_t */
+ /** uint32_t */
case HA_CONDITIONS:
case HA_EXTENSIONS:
case HA_INBOUND_SPI:
case HA_OUTBOUND_SPI:
case HA_MID:
{
- u_int32_t val;
+ uint32_t val;
val = va_arg(args, u_int);
check_buf(this, sizeof(val));
- *(u_int32_t*)(this->buf.ptr + this->buf.len) = htonl(val);
+ *(uint32_t*)(this->buf.ptr + this->buf.len) = htonl(val);
this->buf.len += sizeof(val);
break;
}
chunk_t chunk;
chunk = va_arg(args, chunk_t);
- check_buf(this, chunk.len + sizeof(u_int16_t));
- *(u_int16_t*)(this->buf.ptr + this->buf.len) = htons(chunk.len);
- memcpy(this->buf.ptr + this->buf.len + sizeof(u_int16_t),
+ check_buf(this, chunk.len + sizeof(uint16_t));
+ *(uint16_t*)(this->buf.ptr + this->buf.len) = htons(chunk.len);
+ memcpy(this->buf.ptr + this->buf.len + sizeof(uint16_t),
chunk.ptr, chunk.len);
- this->buf.len += chunk.len + sizeof(u_int16_t);;
+ this->buf.len += chunk.len + sizeof(uint16_t);;
break;
}
/** traffic_selector_t */
default:
{
DBG1(DBG_CFG, "unable to encode, attribute %d unknown", attribute);
- this->buf.len -= sizeof(u_int8_t);
+ this->buf.len -= sizeof(uint8_t);
break;
}
}
this->buf = chunk_skip(this->buf, len + 1);
return TRUE;
}
- /* u_int8_t */
+ /* uint8_t */
case HA_IKE_VERSION:
case HA_INITIATOR:
case HA_IPSEC_MODE:
case HA_IPCOMP:
{
- if (this->buf.len < sizeof(u_int8_t))
+ if (this->buf.len < sizeof(uint8_t))
{
return FALSE;
}
- value->u8 = *(u_int8_t*)this->buf.ptr;
+ value->u8 = *(uint8_t*)this->buf.ptr;
*attr_out = attr;
- this->buf = chunk_skip(this->buf, sizeof(u_int8_t));
+ this->buf = chunk_skip(this->buf, sizeof(uint8_t));
return TRUE;
}
- /** u_int16_t */
+ /** uint16_t */
case HA_ALG_DH:
case HA_ALG_PRF:
case HA_ALG_OLD_PRF:
case HA_SEGMENT:
case HA_ESN:
{
- if (this->buf.len < sizeof(u_int16_t))
+ if (this->buf.len < sizeof(uint16_t))
{
return FALSE;
}
- value->u16 = ntohs(*(u_int16_t*)this->buf.ptr);
+ value->u16 = ntohs(*(uint16_t*)this->buf.ptr);
*attr_out = attr;
- this->buf = chunk_skip(this->buf, sizeof(u_int16_t));
+ this->buf = chunk_skip(this->buf, sizeof(uint16_t));
return TRUE;
}
- /** u_int32_t */
+ /** uint32_t */
case HA_CONDITIONS:
case HA_EXTENSIONS:
case HA_INBOUND_SPI:
case HA_OUTBOUND_SPI:
case HA_MID:
{
- if (this->buf.len < sizeof(u_int32_t))
+ if (this->buf.len < sizeof(uint32_t))
{
return FALSE;
}
- value->u32 = ntohl(*(u_int32_t*)this->buf.ptr);
+ value->u32 = ntohl(*(uint32_t*)this->buf.ptr);
*attr_out = attr;
- this->buf = chunk_skip(this->buf, sizeof(u_int32_t));
+ this->buf = chunk_skip(this->buf, sizeof(uint32_t));
return TRUE;
}
/** chunk_t */
{
size_t len;
- if (this->buf.len < sizeof(u_int16_t))
+ if (this->buf.len < sizeof(uint16_t))
{
return FALSE;
}
- len = ntohs(*(u_int16_t*)this->buf.ptr);
- this->buf = chunk_skip(this->buf, sizeof(u_int16_t));
+ len = ntohs(*(uint16_t*)this->buf.ptr);
+ this->buf = chunk_skip(this->buf, sizeof(uint16_t));
if (this->buf.len < len)
{
return FALSE;
HA_REMOTE_ADDR,
/** char*, name of configuration */
HA_CONFIG_NAME,
- /** u_int32_t, bitset of ike_condition_t */
+ /** uint32_t, bitset of ike_condition_t */
HA_CONDITIONS,
- /** u_int32_t, bitset of ike_extension_t */
+ /** uint32_t, bitset of ike_extension_t */
HA_EXTENSIONS,
/** host_t*, local virtual IP */
HA_LOCAL_VIP,
HA_REMOTE_VIP,
/** host_t*, known peer addresses (used for MOBIKE) */
HA_PEER_ADDR,
- /** u_int8_t, initiator of an exchange, TRUE for local */
+ /** uint8_t, initiator of an exchange, TRUE for local */
HA_INITIATOR,
/** chunk_t, initiators nonce */
HA_NONCE_I,
HA_SECRET,
/** chunk_t, SKd of old SA if rekeying */
HA_OLD_SKD,
- /** u_int16_t, pseudo random function */
+ /** uint16_t, pseudo random function */
HA_ALG_PRF,
- /** u_int16_t, old pseudo random function if rekeying */
+ /** uint16_t, old pseudo random function if rekeying */
HA_ALG_OLD_PRF,
- /** u_int16_t, encryption algorithm */
+ /** uint16_t, encryption algorithm */
HA_ALG_ENCR,
- /** u_int16_t, encryption key size in bytes */
+ /** uint16_t, encryption key size in bytes */
HA_ALG_ENCR_LEN,
- /** u_int16_t, integrity protection algorithm */
+ /** uint16_t, integrity protection algorithm */
HA_ALG_INTEG,
- /** u_int16_t, DH group */
+ /** uint16_t, DH group */
HA_ALG_DH,
- /** u_int8_t, IPsec mode, TUNNEL|TRANSPORT|... */
+ /** uint8_t, IPsec mode, TUNNEL|TRANSPORT|... */
HA_IPSEC_MODE,
- /** u_int8_t, IPComp protocol */
+ /** uint8_t, IPComp protocol */
HA_IPCOMP,
- /** u_int32_t, inbound security parameter index */
+ /** uint32_t, inbound security parameter index */
HA_INBOUND_SPI,
- /** u_int32_t, outbound security parameter index */
+ /** uint32_t, outbound security parameter index */
HA_OUTBOUND_SPI,
- /** u_int16_t, inbound security parameter index */
+ /** uint16_t, inbound security parameter index */
HA_INBOUND_CPI,
- /** u_int16_t, outbound security parameter index */
+ /** uint16_t, outbound security parameter index */
HA_OUTBOUND_CPI,
/** traffic_selector_t*, local traffic selector */
HA_LOCAL_TS,
/** traffic_selector_t*, remote traffic selector */
HA_REMOTE_TS,
- /** u_int32_t, message ID */
+ /** uint32_t, message ID */
HA_MID,
- /** u_int16_t, HA segment */
+ /** uint16_t, HA segment */
HA_SEGMENT,
- /** u_int16_t, Extended Sequence numbers */
+ /** uint16_t, Extended Sequence numbers */
HA_ESN,
- /** u_int8_t, IKE version */
+ /** uint8_t, IKE version */
HA_IKE_VERSION,
/** chunk_t, own DH public value */
HA_LOCAL_DH,
* Union to enumerate typed attributes in a message
*/
union ha_message_value_t {
- u_int8_t u8;
- u_int16_t u16;
- u_int32_t u32;
+ uint8_t u8;
+ uint16_t u16;
+ uint32_t u32;
char *str;
chunk_t chunk;
ike_sa_id_t *ike_sa_id;
typedef struct ha_segments_t ha_segments_t;
-typedef u_int16_t segment_mask_t;
+typedef uint16_t segment_mask_t;
/**
* maximum number of segments
/**
* Reqid of installed trap
*/
- u_int32_t trap;
+ uint32_t trap;
/**
* backend for HA SA
/**
* Precedence
*/
- u_int8_t precedence;
+ uint8_t precedence;
/**
* Gateway type
*/
- u_int8_t gateway_type;
+ uint8_t gateway_type;
/**
* Algorithm
*/
- u_int8_t algorithm;
+ uint8_t algorithm;
/**
* Gateway
chunk_t public_key;
};
-METHOD(ipseckey_t, get_precedence, u_int8_t,
+METHOD(ipseckey_t, get_precedence, uint8_t,
private_ipseckey_t *this)
{
return this->precedence;
{
private_ipseckey_t *this;
bio_reader_t *reader = NULL;
- u_int8_t label;
+ uint8_t label;
chunk_t tmp;
INIT(this,
*
* @return precedence
*/
- u_int8_t (*get_precedence)(ipseckey_t *this);
+ uint8_t (*get_precedence)(ipseckey_t *this);
/**
* Get the type of the gateway.
rr_set_t *rrset;
rr_t *rrsig;
bio_reader_t *reader;
- u_int32_t nBefore, nAfter;
+ uint32_t nBefore, nAfter;
chunk_t ignore;
char *fqdn;
* Add or remove a route
*/
static status_t manage_route(private_kernel_iph_net_t *this, bool add,
- chunk_t dst, u_int8_t prefixlen, host_t *gtw, char *name)
+ chunk_t dst, uint8_t prefixlen, host_t *gtw, char *name)
{
MIB_IPFORWARD_ROW2 row = {
.DestinationPrefix = {
}
METHOD(kernel_net_t, add_route, status_t,
- private_kernel_iph_net_t *this, chunk_t dst, u_int8_t prefixlen,
+ private_kernel_iph_net_t *this, chunk_t dst, uint8_t prefixlen,
host_t *gateway, host_t *src, char *name)
{
return manage_route(this, TRUE, dst, prefixlen, gateway, name);
}
METHOD(kernel_net_t, del_route, status_t,
- private_kernel_iph_net_t *this, chunk_t dst, u_int8_t prefixlen,
+ private_kernel_iph_net_t *this, chunk_t dst, uint8_t prefixlen,
host_t *gateway, host_t *src, char *name)
{
return manage_route(this, FALSE, dst, prefixlen, gateway, name);
/** Destination net */
chunk_t dst_net;
/** Destination net prefixlen */
- u_int8_t prefixlen;
+ uint8_t prefixlen;
/** Reference to exclude route, if any */
exclude_route_t *exclude;
};
*/
struct policy_entry_t {
/** Direction of this policy: in, out, forward */
- u_int8_t direction;
+ uint8_t direction;
/** Parameters of installed policy */
struct {
/** Subnet and port */
host_t *net;
/** Subnet mask */
- u_int8_t mask;
+ uint8_t mask;
/** Protocol */
- u_int8_t proto;
+ uint8_t proto;
} src, dst;
/** Associated route installed for this policy */
route_entry_t *route;
/**
* Expiration callback
*/
-static void expire(u_int8_t protocol, u_int32_t spi, host_t *dst, bool hard)
+static void expire(uint8_t protocol, uint32_t spi, host_t *dst, bool hard)
{
charon->kernel->expire(charon->kernel, protocol, spi, dst, hard);
}
METHOD(kernel_ipsec_t, get_spi, status_t,
private_kernel_libipsec_ipsec_t *this, host_t *src, host_t *dst,
- u_int8_t protocol, u_int32_t *spi)
+ uint8_t protocol, uint32_t *spi)
{
return ipsec->sas->get_spi(ipsec->sas, src, dst, protocol, spi);
}
METHOD(kernel_ipsec_t, get_cpi, status_t,
private_kernel_libipsec_ipsec_t *this, host_t *src, host_t *dst,
- u_int16_t *cpi)
+ uint16_t *cpi)
{
return NOT_SUPPORTED;
}
METHOD(kernel_ipsec_t, add_sa, status_t,
private_kernel_libipsec_ipsec_t *this, host_t *src, host_t *dst,
- u_int32_t spi, u_int8_t protocol, u_int32_t reqid, mark_t mark,
- u_int32_t tfc, lifetime_cfg_t *lifetime, u_int16_t enc_alg, chunk_t enc_key,
- u_int16_t int_alg, chunk_t int_key, ipsec_mode_t mode,
- u_int16_t ipcomp, u_int16_t cpi, u_int32_t replay_window,
+ uint32_t spi, uint8_t protocol, uint32_t reqid, mark_t mark,
+ uint32_t tfc, lifetime_cfg_t *lifetime, uint16_t enc_alg, chunk_t enc_key,
+ uint16_t int_alg, chunk_t int_key, ipsec_mode_t mode,
+ uint16_t ipcomp, uint16_t cpi, uint32_t replay_window,
bool initiator, bool encap, bool esn, bool inbound, bool update,
linked_list_t *src_ts, linked_list_t *dst_ts)
{
}
METHOD(kernel_ipsec_t, update_sa, status_t,
- private_kernel_libipsec_ipsec_t *this, u_int32_t spi, u_int8_t protocol,
- u_int16_t cpi, host_t *src, host_t *dst, host_t *new_src, host_t *new_dst,
+ private_kernel_libipsec_ipsec_t *this, uint32_t spi, uint8_t protocol,
+ uint16_t cpi, host_t *src, host_t *dst, host_t *new_src, host_t *new_dst,
bool encap, bool new_encap, mark_t mark)
{
return NOT_SUPPORTED;
METHOD(kernel_ipsec_t, query_sa, status_t,
private_kernel_libipsec_ipsec_t *this, host_t *src, host_t *dst,
- u_int32_t spi, u_int8_t protocol, mark_t mark, u_int64_t *bytes,
- u_int64_t *packets, time_t *time)
+ uint32_t spi, uint8_t protocol, mark_t mark, uint64_t *bytes,
+ uint64_t *packets, time_t *time)
{
return ipsec->sas->query_sa(ipsec->sas, src, dst, spi, protocol, mark,
bytes, packets, time);
METHOD(kernel_ipsec_t, del_sa, status_t,
private_kernel_libipsec_ipsec_t *this, host_t *src, host_t *dst,
- u_int32_t spi, u_int8_t protocol, u_int16_t cpi, mark_t mark)
+ uint32_t spi, uint8_t protocol, uint16_t cpi, mark_t mark)
{
return ipsec->sas->del_sa(ipsec->sas, src, dst, spi, protocol, cpi, mark);
}
}
METHOD(kernel_ipsec_t, enable_udp_decap, bool,
- private_kernel_libipsec_ipsec_t *this, int fd, int family, u_int16_t port)
+ private_kernel_libipsec_ipsec_t *this, int fd, int family, uint16_t port)
{
return NOT_SUPPORTED;
}
chunk_t dst_net;
/** Destination net prefixlen */
- u_int8_t prefixlen;
+ uint8_t prefixlen;
};
/**
*/
struct policy_sa_t {
/** Priority assigned to the policy when installed with this SA */
- u_int32_t priority;
+ uint32_t priority;
/** Type of the policy */
policy_type_t type;
struct policy_entry_t {
/** Direction of this policy: in, out, forward */
- u_int8_t direction;
+ uint8_t direction;
/** Parameters of installed policy */
struct xfrm_selector sel;
/** Optional mark */
- u_int32_t mark;
+ uint32_t mark;
/** Associated route installed for this policy */
route_entry_t *route;
linked_list_t *used_by;
/** reqid for this policy */
- u_int32_t reqid;
+ uint32_t reqid;
};
/**
/**
* Calculate the priority of a policy
*/
-static inline u_int32_t get_priority(policy_entry_t *policy,
+static inline uint32_t get_priority(policy_entry_t *policy,
policy_priority_t prio)
{
- u_int32_t priority = PRIO_BASE;
+ uint32_t priority = PRIO_BASE;
switch (prio)
{
case POLICY_PRIORITY_FALLBACK:
/**
* Convert the general ipsec mode to the one defined in xfrm.h
*/
-static u_int8_t mode2kernel(ipsec_mode_t mode)
+static uint8_t mode2kernel(ipsec_mode_t mode)
{
switch (mode)
{
/**
* Convert a struct xfrm_address to a host_t
*/
-static host_t* xfrm2host(int family, xfrm_address_t *xfrm, u_int16_t port)
+static host_t* xfrm2host(int family, xfrm_address_t *xfrm, uint16_t port)
{
chunk_t chunk;
* Convert a traffic selector address range to subnet and its mask.
*/
static void ts2subnet(traffic_selector_t* ts,
- xfrm_address_t *net, u_int8_t *mask)
+ xfrm_address_t *net, uint8_t *mask)
{
host_t *net_host;
chunk_t net_chunk;
* Convert a traffic selector port range to port/portmask
*/
static void ts2ports(traffic_selector_t* ts,
- u_int16_t *port, u_int16_t *mask)
+ uint16_t *port, uint16_t *mask)
{
uint16_t from, to, bitmask;
int bit;
traffic_selector_t *dst)
{
struct xfrm_selector sel;
- u_int16_t port;
+ uint16_t port;
memset(&sel, 0, sizeof(sel));
sel.family = (src->get_type(src) == TS_IPV4_ADDR_RANGE) ? AF_INET : AF_INET6;
static traffic_selector_t* selector2ts(struct xfrm_selector *sel, bool src)
{
u_char *addr;
- u_int8_t prefixlen;
- u_int16_t port = 0;
+ uint8_t prefixlen;
+ uint16_t port = 0;
host_t *host = NULL;
if (src)
struct rtattr *rta;
size_t rtasize;
traffic_selector_t *src_ts, *dst_ts;
- u_int32_t reqid = 0;
+ uint32_t reqid = 0;
int proto = 0;
acquire = NLMSG_DATA(hdr);
struct nlmsghdr *hdr)
{
struct xfrm_user_expire *expire;
- u_int32_t spi;
- u_int8_t protocol;
+ uint32_t spi;
+ uint8_t protocol;
host_t *dst;
expire = NLMSG_DATA(hdr);
host_t *local = NULL, *remote = NULL;
host_t *old_src = NULL, *old_dst = NULL;
host_t *new_src = NULL, *new_dst = NULL;
- u_int32_t reqid = 0;
+ uint32_t reqid = 0;
policy_dir_t dir;
policy_id = NLMSG_DATA(hdr);
struct nlmsghdr *hdr)
{
struct xfrm_user_mapping *mapping;
- u_int32_t spi;
+ uint32_t spi;
mapping = NLMSG_DATA(hdr);
spi = mapping->id.spi;
* Get an SPI for a specific protocol from the kernel.
*/
static status_t get_spi_internal(private_kernel_netlink_ipsec_t *this,
- host_t *src, host_t *dst, u_int8_t proto, u_int32_t min, u_int32_t max,
- u_int32_t *spi)
+ host_t *src, host_t *dst, uint8_t proto, uint32_t min, uint32_t max,
+ uint32_t *spi)
{
netlink_buf_t request;
struct nlmsghdr *hdr, *out;
struct xfrm_userspi_info *userspi;
- u_int32_t received_spi = 0;
+ uint32_t received_spi = 0;
size_t len;
memset(&request, 0, sizeof(request));
METHOD(kernel_ipsec_t, get_spi, status_t,
private_kernel_netlink_ipsec_t *this, host_t *src, host_t *dst,
- u_int8_t protocol, u_int32_t *spi)
+ uint8_t protocol, uint32_t *spi)
{
if (get_spi_internal(this, src, dst, protocol,
0xc0000000, 0xcFFFFFFF, spi) != SUCCESS)
METHOD(kernel_ipsec_t, get_cpi, status_t,
private_kernel_netlink_ipsec_t *this, host_t *src, host_t *dst,
- u_int16_t *cpi)
+ uint16_t *cpi)
{
- u_int32_t received_spi = 0;
+ uint32_t received_spi = 0;
if (get_spi_internal(this, src, dst, IPPROTO_COMP,
0x100, 0xEFFF, &received_spi) != SUCCESS)
return FAILED;
}
- *cpi = htons((u_int16_t)ntohl(received_spi));
+ *cpi = htons((uint16_t)ntohl(received_spi));
DBG2(DBG_KNL, "got CPI %.4x", ntohs(*cpi));
return SUCCESS;
METHOD(kernel_ipsec_t, add_sa, status_t,
private_kernel_netlink_ipsec_t *this, host_t *src, host_t *dst,
- u_int32_t spi, u_int8_t protocol, u_int32_t reqid, mark_t mark,
- u_int32_t tfc, lifetime_cfg_t *lifetime, u_int16_t enc_alg, chunk_t enc_key,
- u_int16_t int_alg, chunk_t int_key, ipsec_mode_t mode,
- u_int16_t ipcomp, u_int16_t cpi, u_int32_t replay_window,
+ uint32_t spi, uint8_t protocol, uint32_t reqid, mark_t mark,
+ uint32_t tfc, lifetime_cfg_t *lifetime, uint16_t enc_alg, chunk_t enc_key,
+ uint16_t int_alg, chunk_t int_key, ipsec_mode_t mode,
+ uint16_t ipcomp, uint16_t cpi, uint32_t replay_window,
bool initiator, bool encap, bool esn, bool inbound, bool update,
linked_list_t* src_ts, linked_list_t* dst_ts)
{
char *alg_name;
struct nlmsghdr *hdr;
struct xfrm_usersa_info *sa;
- u_int16_t icv_size = 64;
+ uint16_t icv_size = 64;
ipsec_mode_t original_mode = mode;
traffic_selector_t *first_src_ts, *first_dst_ts;
status_t status = FAILED;
if (tfc && protocol == IPPROTO_ESP && mode == MODE_TUNNEL)
{ /* the kernel supports TFC padding only for tunnel mode ESP SAs */
- u_int32_t *tfcpad;
+ uint32_t *tfcpad;
tfcpad = netlink_reserve(hdr, sizeof(request), XFRMA_TFCPAD,
sizeof(*tfcpad));
/* for ESN or larger replay windows we need the new
* XFRMA_REPLAY_ESN_VAL attribute to configure a bitmap */
struct xfrm_replay_state_esn *replay;
- u_int32_t bmp_size;
+ uint32_t bmp_size;
- bmp_size = round_up(replay_window, sizeof(u_int32_t) * 8) / 8;
+ bmp_size = round_up(replay_window, sizeof(uint32_t) * 8) / 8;
replay = netlink_reserve(hdr, sizeof(request), XFRMA_REPLAY_ESN_VAL,
sizeof(*replay) + bmp_size);
if (!replay)
goto failed;
}
/* bmp_len contains number uf __u32's */
- replay->bmp_len = bmp_size / sizeof(u_int32_t);
+ replay->bmp_len = bmp_size / sizeof(uint32_t);
replay->replay_window = replay_window;
DBG2(DBG_KNL, " using replay window of %u packets", replay_window);
* Allocates into one the replay state structure we get from the kernel.
*/
static void get_replay_state(private_kernel_netlink_ipsec_t *this,
- u_int32_t spi, u_int8_t protocol,
+ uint32_t spi, uint8_t protocol,
host_t *dst, mark_t mark,
struct xfrm_replay_state_esn **replay_esn,
- u_int32_t *replay_esn_len,
+ uint32_t *replay_esn_len,
struct xfrm_replay_state **replay,
struct xfrm_lifetime_cur **lifetime)
{
METHOD(kernel_ipsec_t, query_sa, status_t,
private_kernel_netlink_ipsec_t *this, host_t *src, host_t *dst,
- u_int32_t spi, u_int8_t protocol, mark_t mark,
- u_int64_t *bytes, u_int64_t *packets, time_t *time)
+ uint32_t spi, uint8_t protocol, mark_t mark,
+ uint64_t *bytes, uint64_t *packets, time_t *time)
{
netlink_buf_t request;
struct nlmsghdr *out = NULL, *hdr;
METHOD(kernel_ipsec_t, del_sa, status_t,
private_kernel_netlink_ipsec_t *this, host_t *src, host_t *dst,
- u_int32_t spi, u_int8_t protocol, u_int16_t cpi, mark_t mark)
+ uint32_t spi, uint8_t protocol, uint16_t cpi, mark_t mark)
{
netlink_buf_t request;
struct nlmsghdr *hdr;
}
METHOD(kernel_ipsec_t, update_sa, status_t,
- private_kernel_netlink_ipsec_t *this, u_int32_t spi, u_int8_t protocol,
- u_int16_t cpi, host_t *src, host_t *dst, host_t *new_src, host_t *new_dst,
+ private_kernel_netlink_ipsec_t *this, uint32_t spi, uint8_t protocol,
+ uint16_t cpi, host_t *src, host_t *dst, host_t *new_src, host_t *new_dst,
bool old_encap, bool new_encap, mark_t mark)
{
netlink_buf_t request;
struct xfrm_replay_state *replay = NULL;
struct xfrm_replay_state_esn *replay_esn = NULL;
struct xfrm_lifetime_cur *lifetime = NULL;
- u_int32_t replay_esn_len = 0;
+ uint32_t replay_esn_len = 0;
status_t status = FAILED;
/* if IPComp is used, we first update the IPComp SA */
struct nlmsghdr *hdr;
struct xfrm_usersa_flush *flush;
struct {
- u_int8_t proto;
+ uint8_t proto;
char *name;
} protos[] = {
{ IPPROTO_AH, "AH" },
{
struct xfrm_user_tmpl *tmpl;
struct {
- u_int8_t proto;
+ uint8_t proto;
bool use;
} protos[] = {
{ IPPROTO_COMP, ipsec->cfg.ipcomp.transform != IPCOMP_NONE },
struct nlmsghdr *hdr;
struct xfrm_userpolicy_id *policy_id;
bool is_installed = TRUE;
- u_int32_t priority;
+ uint32_t priority;
ipsec_sa_t assigned_sa = {
.src = src,
.dst = dst,
/** layer 4 protocol */
int proto;
/** port number, network order */
- u_int16_t port;
+ uint16_t port;
} bypass_t;
/**
}
METHOD(kernel_ipsec_t, enable_udp_decap, bool,
- private_kernel_netlink_ipsec_t *this, int fd, int family, u_int16_t port)
+ private_kernel_netlink_ipsec_t *this, int fd, int family, uint16_t port)
{
int type = UDP_ENCAP_ESPINUDP;
chunk_t dst_net;
/** Destination net prefixlen */
- u_int8_t prefixlen;
+ uint8_t prefixlen;
};
/**
/**
* MTU to set on installed routes
*/
- u_int32_t mtu;
+ uint32_t mtu;
/**
* MSS to set on installed routes
*/
- u_int32_t mss;
+ uint32_t mss;
};
/**
*/
static status_t manage_srcroute(private_kernel_netlink_net_t *this,
int nlmsg_type, int flags, chunk_t dst_net,
- u_int8_t prefixlen, host_t *gateway,
+ uint8_t prefixlen, host_t *gateway,
host_t *src_ip, char *if_name);
/**
struct rtmsg* msg = NLMSG_DATA(hdr);
struct rtattr *rta = RTM_RTA(msg);
size_t rtasize = RTM_PAYLOAD(hdr);
- u_int32_t rta_oif = 0;
+ uint32_t rta_oif = 0;
host_t *host = NULL;
/* ignore routes added by us or in the local routing table (local addrs) */
case RTA_OIF:
if (RTA_PAYLOAD(rta) == sizeof(rta_oif))
{
- rta_oif = *(u_int32_t*)RTA_DATA(rta);
+ rta_oif = *(uint32_t*)RTA_DATA(rta);
}
break;
}
chunk_t src;
chunk_t dst;
host_t *src_host;
- u_int8_t dst_len;
- u_int32_t table;
- u_int32_t oif;
- u_int32_t priority;
+ uint8_t dst_len;
+ uint32_t table;
+ uint32_t oif;
+ uint32_t priority;
} rt_entry_t;
/**
case RTA_OIF:
if (RTA_PAYLOAD(rta) == sizeof(route->oif))
{
- route->oif = *(u_int32_t*)RTA_DATA(rta);
+ route->oif = *(uint32_t*)RTA_DATA(rta);
}
break;
case RTA_PRIORITY:
if (RTA_PAYLOAD(rta) == sizeof(route->priority))
{
- route->priority = *(u_int32_t*)RTA_DATA(rta);
+ route->priority = *(uint32_t*)RTA_DATA(rta);
}
break;
#ifdef HAVE_RTA_TABLE
case RTA_TABLE:
if (RTA_PAYLOAD(rta) == sizeof(route->table))
{
- route->table = *(u_int32_t*)RTA_DATA(rta);
+ route->table = *(uint32_t*)RTA_DATA(rta);
}
break;
#endif /* HAVE_RTA_TABLE*/
*/
static status_t manage_srcroute(private_kernel_netlink_net_t *this,
int nlmsg_type, int flags, chunk_t dst_net,
- u_int8_t prefixlen, host_t *gateway,
+ uint8_t prefixlen, host_t *gateway,
host_t *src_ip, char *if_name)
{
netlink_buf_t request;
if (this->routing_table == 0 && prefixlen == 0)
{
chunk_t half_net;
- u_int8_t half_prefixlen;
+ uint8_t half_prefixlen;
status_t status;
half_net = chunk_alloca(dst_net.len);
if (this->mtu || this->mss)
{
chunk = chunk_alloca(RTA_LENGTH((sizeof(struct rtattr) +
- sizeof(u_int32_t)) * 2));
+ sizeof(uint32_t)) * 2));
chunk.len = 0;
rta = (struct rtattr*)chunk.ptr;
if (this->mtu)
{
rta->rta_type = RTAX_MTU;
- rta->rta_len = RTA_LENGTH(sizeof(u_int32_t));
- memcpy(RTA_DATA(rta), &this->mtu, sizeof(u_int32_t));
+ rta->rta_len = RTA_LENGTH(sizeof(uint32_t));
+ memcpy(RTA_DATA(rta), &this->mtu, sizeof(uint32_t));
chunk.len = rta->rta_len;
}
if (this->mss)
{
rta = (struct rtattr*)(chunk.ptr + RTA_ALIGN(chunk.len));
rta->rta_type = RTAX_ADVMSS;
- rta->rta_len = RTA_LENGTH(sizeof(u_int32_t));
- memcpy(RTA_DATA(rta), &this->mss, sizeof(u_int32_t));
+ rta->rta_len = RTA_LENGTH(sizeof(uint32_t));
+ memcpy(RTA_DATA(rta), &this->mss, sizeof(uint32_t));
chunk.len = RTA_ALIGN(chunk.len) + rta->rta_len;
}
netlink_add_attribute(hdr, RTA_METRICS, chunk, sizeof(request));
}
METHOD(kernel_net_t, add_route, status_t,
- private_kernel_netlink_net_t *this, chunk_t dst_net, u_int8_t prefixlen,
+ private_kernel_netlink_net_t *this, chunk_t dst_net, uint8_t prefixlen,
host_t *gateway, host_t *src_ip, char *if_name)
{
status_t status;
}
METHOD(kernel_net_t, del_route, status_t,
- private_kernel_netlink_net_t *this, chunk_t dst_net, u_int8_t prefixlen,
+ private_kernel_netlink_net_t *this, chunk_t dst_net, uint8_t prefixlen,
host_t *gateway, host_t *src_ip, char *if_name)
{
status_t status;
* create or delete a rule to use our routing table
*/
static status_t manage_rule(private_kernel_netlink_net_t *this, int nlmsg_type,
- int family, u_int32_t table, u_int32_t prio)
+ int family, uint32_t table, uint32_t prio)
{
netlink_buf_t request;
struct nlmsghdr *hdr;
#define SADB_X_EXT_NATT 0x002
struct sadb_sa_2 {
struct sadb_sa sa;
- u_int16_t sadb_sa_natt_port;
- u_int16_t sadb_reserved0;
- u_int32_t sadb_reserved1;
+ uint16_t sadb_sa_natt_port;
+ uint16_t sadb_reserved0;
+ uint32_t sadb_reserved1;
};
#endif
chunk_t dst_net;
/** destination net prefixlen */
- u_int8_t prefixlen;
+ uint8_t prefixlen;
/** reference to exclude route, if any */
exclude_route_t *exclude;
*/
struct policy_sa_t {
/** Priority assigned to the policy when installed with this SA */
- u_int32_t priority;
+ uint32_t priority;
/** Type of the policy */
policy_type_t type;
*/
struct policy_entry_t {
/** Index assigned by the kernel */
- u_int32_t index;
+ uint32_t index;
/** Direction of this policy: in, out, forward */
- u_int8_t direction;
+ uint8_t direction;
/** Parameters of installed policy */
struct {
/** Subnet and port */
host_t *net;
/** Subnet mask */
- u_int8_t mask;
+ uint8_t mask;
/** Protocol */
- u_int8_t proto;
+ uint8_t proto;
} src, dst;
/** Associated route installed for this policy */
INIT(policy,
.direction = dir,
);
- u_int16_t port;
- u_int8_t proto;
+ uint16_t port;
+ uint8_t proto;
src_ts->to_subnet(src_ts, &policy->src.net, &policy->src.mask);
dst_ts->to_subnet(dst_ts, &policy->dst.net, &policy->dst.mask);
* compare the given kernel index with that of a policy
*/
static inline bool policy_entry_match_byindex(policy_entry_t *current,
- u_int32_t *index)
+ uint32_t *index)
{
return current->index == *index;
}
/**
* Calculate the priority of a policy
*/
-static inline u_int32_t get_priority(policy_entry_t *policy,
+static inline uint32_t get_priority(policy_entry_t *policy,
policy_priority_t prio)
{
- u_int32_t priority = PRIO_BASE;
+ uint32_t priority = PRIO_BASE;
switch (prio)
{
case POLICY_PRIORITY_FALLBACK:
/**
* convert a protocol identifier to the PF_KEY sa type
*/
-static u_int8_t proto2satype(u_int8_t proto)
+static uint8_t proto2satype(uint8_t proto)
{
switch (proto)
{
/**
* convert a PF_KEY sa type to a protocol identifier
*/
-static u_int8_t satype2proto(u_int8_t satype)
+static uint8_t satype2proto(uint8_t satype)
{
switch (satype)
{
/**
* convert the general ipsec mode to the one defined in ipsec.h
*/
-static u_int8_t mode2kernel(ipsec_mode_t mode)
+static uint8_t mode2kernel(ipsec_mode_t mode)
{
switch (mode)
{
/**
* convert the general policy direction to the one defined in ipsec.h
*/
-static u_int8_t dir2kernel(policy_dir_t dir)
+static uint8_t dir2kernel(policy_dir_t dir)
{
switch (dir)
{
/**
* convert the policy type to the one defined in ipsec.h
*/
-static inline u_int16_t type2kernel(policy_type_t type)
+static inline uint16_t type2kernel(policy_type_t type)
{
switch (type)
{
/**
* convert the policy direction in ipsec.h to the general one.
*/
-static policy_dir_t kernel2dir(u_int8_t dir)
+static policy_dir_t kernel2dir(uint8_t dir)
{
switch (dir)
{
static int lookup_algorithm(transform_type_t type, int ikev2)
{
kernel_algorithm_t *list;
- u_int16_t alg = 0;
+ uint16_t alg = 0;
switch (type)
{
/**
* Helper to set a port in a sockaddr_t, the port has to be in host order
*/
-static void set_port(sockaddr_t *addr, u_int16_t port)
+static void set_port(sockaddr_t *addr, uint16_t port)
{
switch (addr->sa_family)
{
/**
* add a host to the given sadb_msg
*/
-static void add_addr_ext(struct sadb_msg *msg, host_t *host, u_int16_t type,
- u_int8_t proto, u_int8_t prefixlen, bool include_port)
+static void add_addr_ext(struct sadb_msg *msg, host_t *host, uint16_t type,
+ uint8_t proto, uint8_t prefixlen, bool include_port)
{
struct sadb_address *addr = (struct sadb_address*)PFKEY_EXT_ADD_NEXT(msg);
size_t len;
/**
* adds an empty address extension to the given sadb_msg
*/
-static void add_anyaddr_ext(struct sadb_msg *msg, int family, u_int8_t type)
+static void add_anyaddr_ext(struct sadb_msg *msg, int family, uint8_t type)
{
socklen_t len = (family == AF_INET) ? sizeof(struct sockaddr_in) :
sizeof(struct sockaddr_in6);
{
traffic_selector_t *ts;
host_t *host;
- u_int8_t proto;
+ uint8_t proto;
proto = address->sadb_address_proto;
proto = proto == IPSEC_PROTO_ANY ? 0 : proto;
struct sadb_msg* msg)
{
pfkey_msg_t response;
- u_int32_t index, reqid = 0;
+ uint32_t index, reqid = 0;
traffic_selector_t *src_ts, *dst_ts;
policy_entry_t *policy;
policy_sa_t *sa;
struct sadb_msg* msg)
{
pfkey_msg_t response;
- u_int8_t protocol;
- u_int32_t spi;
+ uint8_t protocol;
+ uint32_t spi;
host_t *dst;
bool hard;
pfkey_msg_t response;
traffic_selector_t *src_ts, *dst_ts;
policy_dir_t dir;
- u_int32_t reqid = 0;
+ uint32_t reqid = 0;
host_t *local = NULL, *remote = NULL;
DBG2(DBG_KNL, "received an SADB_X_MIGRATE");
if (response.x_kmaddress)
{
sockaddr_t *local_addr, *remote_addr;
- u_int32_t local_len;
+ uint32_t local_len;
local_addr = (sockaddr_t*)&response.x_kmaddress[1];
local = host_create_from_sockaddr(local_addr);
local_len = (local_addr->sa_family == AF_INET6)?
sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in);
- remote_addr = (sockaddr_t*)((u_int8_t*)local_addr + local_len);
+ remote_addr = (sockaddr_t*)((uint8_t*)local_addr + local_len);
remote = host_create_from_sockaddr(remote_addr);
DBG2(DBG_KNL, " kmaddress: %H...%H", local, remote);
}
struct sadb_msg* msg)
{
pfkey_msg_t response;
- u_int32_t spi;
+ uint32_t spi;
sockaddr_t *sa;
host_t *dst, *new;
*/
static status_t get_spi_internal(private_kernel_pfkey_ipsec_t *this,
- host_t *src, host_t *dst, u_int8_t proto, u_int32_t min, u_int32_t max,
- u_int32_t *spi)
+ host_t *src, host_t *dst, uint8_t proto, uint32_t min, uint32_t max,
+ uint32_t *spi)
{
unsigned char request[PFKEY_BUFFER_SIZE];
struct sadb_msg *msg, *out;
struct sadb_spirange *range;
pfkey_msg_t response;
- u_int32_t received_spi = 0;
+ uint32_t received_spi = 0;
size_t len;
memset(&request, 0, sizeof(request));
METHOD(kernel_ipsec_t, get_spi, status_t,
private_kernel_pfkey_ipsec_t *this, host_t *src, host_t *dst,
- u_int8_t protocol, u_int32_t *spi)
+ uint8_t protocol, uint32_t *spi)
{
if (get_spi_internal(this, src, dst, protocol,
0xc0000000, 0xcFFFFFFF, spi) != SUCCESS)
METHOD(kernel_ipsec_t, get_cpi, status_t,
private_kernel_pfkey_ipsec_t *this, host_t *src, host_t *dst,
- u_int16_t *cpi)
+ uint16_t *cpi)
{
- u_int32_t received_spi = 0;
+ uint32_t received_spi = 0;
DBG2(DBG_KNL, "getting CPI");
return FAILED;
}
- *cpi = htons((u_int16_t)ntohl(received_spi));
+ *cpi = htons((uint16_t)ntohl(received_spi));
DBG2(DBG_KNL, "got CPI %.4x", ntohs(*cpi));
return SUCCESS;
}
METHOD(kernel_ipsec_t, add_sa, status_t,
- private_kernel_pfkey_ipsec_t *this, host_t *src, host_t *dst, u_int32_t spi,
- u_int8_t protocol, u_int32_t reqid, mark_t mark, u_int32_t tfc,
- lifetime_cfg_t *lifetime, u_int16_t enc_alg, chunk_t enc_key,
- u_int16_t int_alg, chunk_t int_key, ipsec_mode_t mode,
- u_int16_t ipcomp, u_int16_t cpi, u_int32_t replay_window,
+ private_kernel_pfkey_ipsec_t *this, host_t *src, host_t *dst, uint32_t spi,
+ uint8_t protocol, uint32_t reqid, mark_t mark, uint32_t tfc,
+ lifetime_cfg_t *lifetime, uint16_t enc_alg, chunk_t enc_key,
+ uint16_t int_alg, chunk_t int_key, ipsec_mode_t mode,
+ uint16_t ipcomp, uint16_t cpi, uint32_t replay_window,
bool initiator, bool encap, bool esn, bool inbound, bool update,
linked_list_t *src_ts, linked_list_t *dst_ts)
{
}
METHOD(kernel_ipsec_t, update_sa, status_t,
- private_kernel_pfkey_ipsec_t *this, u_int32_t spi, u_int8_t protocol,
- u_int16_t cpi, host_t *src, host_t *dst, host_t *new_src, host_t *new_dst,
+ private_kernel_pfkey_ipsec_t *this, uint32_t spi, uint8_t protocol,
+ uint16_t cpi, host_t *src, host_t *dst, host_t *new_src, host_t *new_dst,
bool encap, bool new_encap, mark_t mark)
{
unsigned char request[PFKEY_BUFFER_SIZE];
METHOD(kernel_ipsec_t, query_sa, status_t,
private_kernel_pfkey_ipsec_t *this, host_t *src, host_t *dst,
- u_int32_t spi, u_int8_t protocol, mark_t mark,
- u_int64_t *bytes, u_int64_t *packets, time_t *time)
+ uint32_t spi, uint8_t protocol, mark_t mark,
+ uint64_t *bytes, uint64_t *packets, time_t *time)
{
unsigned char request[PFKEY_BUFFER_SIZE];
struct sadb_msg *msg, *out;
METHOD(kernel_ipsec_t, del_sa, status_t,
private_kernel_pfkey_ipsec_t *this, host_t *src, host_t *dst,
- u_int32_t spi, u_int8_t protocol, u_int16_t cpi, mark_t mark)
+ uint32_t spi, uint8_t protocol, uint16_t cpi, mark_t mark)
{
unsigned char request[PFKEY_BUFFER_SIZE];
struct sadb_msg *msg, *out;
unsigned char request[PFKEY_BUFFER_SIZE];
struct sadb_msg *msg, *out;
struct {
- u_int8_t proto;
+ uint8_t proto;
char *name;
} protos[] = {
{ SADB_SATYPE_AH, "AH" },
policy_sa_t *mapping, *to_remove = NULL;
enumerator_t *enumerator;
bool first = TRUE, is_installed = TRUE;
- u_int32_t priority;
+ uint32_t priority;
size_t len;
ipsec_sa_t assigned_sa = {
.src = src,
* Register a socket for ACQUIRE/EXPIRE messages
*/
static status_t register_pfkey_socket(private_kernel_pfkey_ipsec_t *this,
- u_int8_t satype)
+ uint8_t satype)
{
unsigned char request[PFKEY_BUFFER_SIZE];
struct sadb_msg *msg, *out;
}
memset(&policy, 0, sizeof(policy));
- policy.sadb_x_policy_len = sizeof(policy) / sizeof(u_int64_t);
+ policy.sadb_x_policy_len = sizeof(policy) / sizeof(uint64_t);
policy.sadb_x_policy_exttype = SADB_X_EXT_POLICY;
policy.sadb_x_policy_type = IPSEC_POLICY_BYPASS;
}
METHOD(kernel_ipsec_t, enable_udp_decap, bool,
- private_kernel_pfkey_ipsec_t *this, int fd, int family, u_int16_t port)
+ private_kernel_pfkey_ipsec_t *this, int fd, int family, uint16_t port)
{
#ifndef __APPLE__
int type = UDP_ENCAP_ESPINUDP;
chunk_t dst_net;
/** Destination net prefixlen */
- u_int8_t prefixlen;
+ uint8_t prefixlen;
};
/**
* Forward declaration
*/
static status_t manage_route(private_kernel_pfroute_net_t *this, int op,
- chunk_t dst_net, u_int8_t prefixlen,
+ chunk_t dst_net, uint8_t prefixlen,
host_t *gateway, char *if_name);
/**
* Add or remove a route
*/
static status_t manage_route(private_kernel_pfroute_net_t *this, int op,
- chunk_t dst_net, u_int8_t prefixlen,
+ chunk_t dst_net, uint8_t prefixlen,
host_t *gateway, char *if_name)
{
struct {
}
METHOD(kernel_net_t, add_route, status_t,
- private_kernel_pfroute_net_t *this, chunk_t dst_net, u_int8_t prefixlen,
+ private_kernel_pfroute_net_t *this, chunk_t dst_net, uint8_t prefixlen,
host_t *gateway, host_t *src_ip, char *if_name)
{
status_t status;
}
METHOD(kernel_net_t, del_route, status_t,
- private_kernel_pfroute_net_t *this, chunk_t dst_net, u_int8_t prefixlen,
+ private_kernel_pfroute_net_t *this, chunk_t dst_net, uint8_t prefixlen,
host_t *gateway, host_t *src_ip, char *if_name)
{
status_t status;
/**
* Mix value to distribute SPI allocation randomly
*/
- u_int32_t mixspi;
+ uint32_t mixspi;
/**
* IKE bypass filters, as UINT64 filter LUID
*/
typedef struct {
/** SPI for this SA */
- u_int32_t spi;
+ uint32_t spi;
/** protocol, IPPROTO_ESP/IPPROTO_AH */
- u_int8_t protocol;
+ uint8_t protocol;
/** hard lifetime of SA */
- u_int32_t lifetime;
+ uint32_t lifetime;
/** destination host address for this SPI */
host_t *dst;
struct {
/** algorithm */
- u_int16_t alg;
+ uint16_t alg;
/** key */
chunk_t key;
} integ, encr;
/** policy destinaiton addresses */
traffic_selector_t *dst;
/** WFP allocated LUID for inbound filter ID */
- u_int64_t policy_in;
+ uint64_t policy_in;
/** WFP allocated LUID for outbound filter ID */
- u_int64_t policy_out;
+ uint64_t policy_out;
/** WFP allocated LUID for forward inbound filter ID, tunnel mode only */
- u_int64_t policy_fwd_in;
+ uint64_t policy_fwd_in;
/** WFP allocated LUID for forward outbound filter ID, tunnel mode only */
- u_int64_t policy_fwd_out;
+ uint64_t policy_fwd_out;
/** have installed a route for it? */
bool route;
} sp_entry_t;
*/
typedef struct {
/** reqid of entry */
- u_int32_t reqid;
+ uint32_t reqid;
/** outer address on local host */
host_t *local;
/** outer address on remote host */
/** UDP encapsulation */
bool encap;
/** provider context, for tunnel mode only */
- u_int64_t provider;
+ uint64_t provider;
/** WFP allocated LUID for SA context */
- u_int64_t sa_id;
+ uint64_t sa_id;
/** WFP allocated LUID for tunnel mode IP-IPv4 inbound filter */
- u_int64_t ip_ipv4_in;
+ uint64_t ip_ipv4_in;
/** WFP allocated LUID for tunnel mode IP-IPv4 outbound filter */
- u_int64_t ip_ipv4_out;
+ uint64_t ip_ipv4_out;
/** WFP allocated LUID for tunnel mode IP-IPv6 inbound filter */
- u_int64_t ip_ipv6_in;
+ uint64_t ip_ipv6_in;
/** WFP allocated LUID for tunnel mode IP-IPv6 outbound filter */
- u_int64_t ip_ipv6_out;
+ uint64_t ip_ipv6_out;
} entry_t;
/**
/** destination net of route */
host_t *dst;
/** prefix length of dst */
- u_int8_t mask;
+ uint8_t mask;
/** source address for route */
host_t *src;
/** gateway of route, NULL if directly attached */
/**
* Convert an IPv4 prefix to a host order subnet mask
*/
-static u_int32_t prefix2mask(u_int8_t prefix)
+static uint32_t prefix2mask(uint8_t prefix)
{
- u_int8_t netmask[4] = {};
+ uint8_t netmask[4] = {};
int i;
for (i = 0; i < sizeof(netmask); i++)
* Convert a 16-bit range to a WFP condition
*/
static void range2cond(FWPM_FILTER_CONDITION0 *cond,
- u_int16_t from, u_int16_t to)
+ uint16_t from, uint16_t to)
{
if (from == to)
{
FWPM_FILTER_CONDITION0 *cond;
FWP_BYTE_ARRAY16 *addr;
FWP_RANGE0 *range;
- u_int16_t from_port, to_port;
+ uint16_t from_port, to_port;
void *from, *to;
- u_int8_t proto;
+ uint8_t proto;
host_t *net;
- u_int8_t prefix;
+ uint8_t prefix;
from = ts->get_from_address(ts).ptr;
to = ts->get_to_address(ts).ptr;
{
if (target == &FWPM_CONDITION_IP_LOCAL_ADDRESS)
{
- u_int8_t from_type, to_type, from_code, to_code;
+ uint8_t from_type, to_type, from_code, to_code;
from_type = traffic_selector_icmp_type(from_port);
to_type = traffic_selector_icmp_type(to_port);
*/
static bool install_ipip_ale(private_kernel_wfp_ipsec_t *this,
host_t *local, host_t *remote, GUID *context,
- bool inbound, int proto, u_int64_t *filter_id)
+ bool inbound, int proto, uint64_t *filter_id)
{
traffic_selector_t *lts, *rts;
FWPM_FILTER_CONDITION0 *conds = NULL;
.ipVersion = version,
};
struct {
- u_int16_t alg;
+ uint16_t alg;
chunk_t key;
} integ = {}, encr = {};
DWORD res;
*/
static void host2address6(host_t *host, void *out)
{
- u_int32_t *src, *dst = out;
+ uint32_t *src, *dst = out;
- src = (u_int32_t*)host->get_address(host).ptr;
+ src = (uint32_t*)host->get_address(host).ptr;
dst[0] = untoh32(&src[3]);
dst[1] = untoh32(&src[2]);
{
return FALSE;
}
- ok = rng->get_bytes(rng, sizeof(GUID), (u_int8_t*)guid);
+ ok = rng->get_bytes(rng, sizeof(GUID), (uint8_t*)guid);
rng->destroy(rng);
return ok;
}
* Reduce refcount, or uninstall a route if all refs gone
*/
static bool uninstall_route(private_kernel_wfp_ipsec_t *this,
- host_t *dst, u_int8_t mask, host_t *src, host_t *gtw)
+ host_t *dst, uint8_t mask, host_t *src, host_t *gtw)
{
route_t *route, key = {
.dst = dst,
* Install a single route, or refcount if exists
*/
static bool install_route(private_kernel_wfp_ipsec_t *this,
- host_t *dst, u_int8_t mask, host_t *src, host_t *gtw)
+ host_t *dst, uint8_t mask, host_t *src, host_t *gtw)
{
route_t *route, key = {
.dst = dst,
bool add)
{
host_t *src, *dst, *gtw;
- u_int8_t mask;
+ uint8_t mask;
bool done;
if (!dst_ts->to_subnet(dst_ts, &dst, &mask))
*/
typedef struct {
/** reqid this trap is installed for */
- u_int32_t reqid;
+ uint32_t reqid;
/** is this a forward policy trap for tunnel mode? */
bool fwd;
/** do we have installed a route for this trap policy? */
static void acquire(private_kernel_wfp_ipsec_t *this, UINT64 filter_id,
traffic_selector_t *src, traffic_selector_t *dst)
{
- u_int32_t reqid = 0;
+ uint32_t reqid = 0;
trap_t *trap, key = {
.filter_id = filter_id,
};
* Create a single host traffic selector from an FWP address definition
*/
static traffic_selector_t *addr2ts(FWP_IP_VERSION version, void *data,
- u_int8_t protocol, u_int16_t from_port, u_int16_t to_port)
+ uint8_t protocol, uint16_t from_port, uint16_t to_port)
{
ts_type_t type;
UINT32 ints[4];
{
private_kernel_wfp_ipsec_t *this = user;
traffic_selector_t *local = NULL, *remote = NULL;
- u_int8_t protocol = 0;
- u_int16_t from_local = 0, to_local = 65535;
- u_int16_t from_remote = 0, to_remote = 65535;
+ uint8_t protocol = 0;
+ uint16_t from_local = 0, to_local = 65535;
+ uint16_t from_remote = 0, to_remote = 65535;
if ((event->header.flags & FWPM_NET_EVENT_FLAG_LOCAL_ADDR_SET) &&
(event->header.flags & FWPM_NET_EVENT_FLAG_REMOTE_ADDR_SET))
* Create and install a new trap entry
*/
static bool add_trap(private_kernel_wfp_ipsec_t *this,
- u_int32_t reqid, bool fwd, host_t *local, host_t *remote,
+ uint32_t reqid, bool fwd, host_t *local, host_t *remote,
traffic_selector_t *src, traffic_selector_t *dst)
{
trap_t *trap;
* Uninstall and remove a new trap entry
*/
static bool remove_trap(private_kernel_wfp_ipsec_t *this,
- u_int32_t reqid, bool fwd,
+ uint32_t reqid, bool fwd,
traffic_selector_t *src, traffic_selector_t *dst)
{
enumerator_t *enumerator;
{
return FALSE;
}
- ok = rng->get_bytes(rng, sizeof(this->nextspi), (u_int8_t*)&this->nextspi);
+ ok = rng->get_bytes(rng, sizeof(this->nextspi), (uint8_t*)&this->nextspi);
if (ok)
{
- ok = rng->get_bytes(rng, sizeof(this->mixspi), (u_int8_t*)&this->mixspi);
+ ok = rng->get_bytes(rng, sizeof(this->mixspi), (uint8_t*)&this->mixspi);
}
rng->destroy(rng);
return ok;
u_int qr;
x = x % p;
- qr = ((u_int64_t)x * x) % p;
+ qr = ((uint64_t)x * x) % p;
if (x <= p / 2)
{
return qr;
METHOD(kernel_ipsec_t, get_spi, status_t,
private_kernel_wfp_ipsec_t *this, host_t *src, host_t *dst,
- u_int8_t protocol, u_int32_t *spi)
+ uint8_t protocol, uint32_t *spi)
{
/* To avoid sequencial SPIs, we use a one-to-one permuation function on
* an incrementing counter, that is a full period PRNG for the range we
METHOD(kernel_ipsec_t, get_cpi, status_t,
private_kernel_wfp_ipsec_t *this, host_t *src, host_t *dst,
- u_int16_t *cpi)
+ uint16_t *cpi)
{
return NOT_SUPPORTED;
}
/* backref to kernel backend */
private_kernel_wfp_ipsec_t *this;
/* SPI of expiring SA */
- u_int32_t spi;
+ uint32_t spi;
/* destination address of expiring SA */
host_t *dst;
/* is this a hard expire, or a rekey request? */
static job_requeue_t expire_job(expire_data_t *data)
{
private_kernel_wfp_ipsec_t *this = data->this;
- u_int8_t protocol;
+ uint8_t protocol;
entry_t *entry = NULL;
sa_entry_t key = {
.spi = data->spi,
/**
* Schedule an expire event for an SA
*/
-static void schedule_expire(private_kernel_wfp_ipsec_t *this, u_int32_t spi,
- host_t *dst, u_int32_t lifetime, bool hard)
+static void schedule_expire(private_kernel_wfp_ipsec_t *this, uint32_t spi,
+ host_t *dst, uint32_t lifetime, bool hard)
{
expire_data_t *data;
METHOD(kernel_ipsec_t, add_sa, status_t,
private_kernel_wfp_ipsec_t *this, host_t *src, host_t *dst,
- u_int32_t spi, u_int8_t protocol, u_int32_t reqid, mark_t mark,
- u_int32_t tfc, lifetime_cfg_t *lifetime, u_int16_t enc_alg, chunk_t enc_key,
- u_int16_t int_alg, chunk_t int_key, ipsec_mode_t mode,
- u_int16_t ipcomp, u_int16_t cpi, u_int32_t replay_window,
+ uint32_t spi, uint8_t protocol, uint32_t reqid, mark_t mark,
+ uint32_t tfc, lifetime_cfg_t *lifetime, uint16_t enc_alg, chunk_t enc_key,
+ uint16_t int_alg, chunk_t int_key, ipsec_mode_t mode,
+ uint16_t ipcomp, uint16_t cpi, uint32_t replay_window,
bool initiator, bool encap, bool esn, bool inbound, bool update,
linked_list_t *src_ts, linked_list_t *dst_ts)
{
}
METHOD(kernel_ipsec_t, update_sa, status_t,
- private_kernel_wfp_ipsec_t *this, u_int32_t spi, u_int8_t protocol,
- u_int16_t cpi, host_t *src, host_t *dst, host_t *new_src, host_t *new_dst,
+ private_kernel_wfp_ipsec_t *this, uint32_t spi, uint8_t protocol,
+ uint16_t cpi, host_t *src, host_t *dst, host_t *new_src, host_t *new_dst,
bool encap, bool new_encap, mark_t mark)
{
entry_t *entry;
METHOD(kernel_ipsec_t, query_sa, status_t,
private_kernel_wfp_ipsec_t *this, host_t *src, host_t *dst,
- u_int32_t spi, u_int8_t protocol, mark_t mark, u_int64_t *bytes,
- u_int64_t *packets, time_t *time)
+ uint32_t spi, uint8_t protocol, mark_t mark, uint64_t *bytes,
+ uint64_t *packets, time_t *time)
{
/* It does not seem that WFP provides any means of getting per-SA traffic
* statistics. IPsecGetStatistics0/1() provides global stats, and
METHOD(kernel_ipsec_t, del_sa, status_t,
private_kernel_wfp_ipsec_t *this, host_t *src, host_t *dst,
- u_int32_t spi, u_int8_t protocol, u_int16_t cpi, mark_t mark)
+ uint32_t spi, uint8_t protocol, uint16_t cpi, mark_t mark)
{
entry_t *entry;
sa_entry_t key = {
* Add a bypass policy for a specific UDP port
*/
static bool add_bypass(private_kernel_wfp_ipsec_t *this,
- int family, u_int16_t port, bool inbound, UINT64 *luid)
+ int family, uint16_t port, bool inbound, UINT64 *luid)
{
FWPM_FILTER_CONDITION0 *cond, *conds = NULL;
int count = 0;
} saddr;
int addrlen = sizeof(saddr);
UINT64 filter_out, filter_in = 0;
- u_int16_t port;
+ uint16_t port;
if (getsockname(fd, &saddr.sa, &addrlen) == SOCKET_ERROR)
{
}
METHOD(kernel_ipsec_t, enable_udp_decap, bool,
- private_kernel_wfp_ipsec_t *this, int fd, int family, u_int16_t port)
+ private_kernel_wfp_ipsec_t *this, int fd, int family, uint16_t port)
{
return FALSE;
}
/**
* Current port for unique initiator ports
*/
- u_int16_t unique_port;
+ uint16_t unique_port;
/**
* IKE_SA rekeying delay
/**
* Dynamic source port, if used
*/
- u_int16_t port;
+ uint16_t port;
/**
* IKE version to use for load testing
/**
* Parse a protoport specifier
*/
-static bool parse_protoport(char *token, u_int16_t *from_port,
- u_int16_t *to_port, u_int8_t *protocol)
+static bool parse_protoport(char *token, uint16_t *from_port,
+ uint16_t *to_port, uint8_t *protocol)
{
char *sep, *port = "", *endptr;
struct protoent *proto;
{
return FALSE;
}
- *protocol = (u_int8_t)p;
+ *protocol = (uint8_t)p;
}
}
if (streq(port, "%any"))
{
enumerator_t *enumerator;
char *subnet, *pos;
- u_int16_t from_port, to_port;
- u_int8_t proto;
+ uint16_t from_port, to_port;
+ uint8_t proto;
enumerator = enumerator_create_token(string, ",", " ");
while (enumerator->enumerate(enumerator, &subnet))
/**
* serial number to issue certificates
*/
- u_int32_t serial;
+ uint32_t serial;
/**
* Preshared key for IKE
identification_t *dn = NULL;
linked_list_t *sans;
char buf[128];
- u_int32_t serial;
+ uint32_t serial;
time_t now;
if (this->ca == NULL)
METHOD(kernel_ipsec_t, get_spi, status_t,
private_load_tester_ipsec_t *this, host_t *src, host_t *dst,
- u_int8_t protocol, u_int32_t *spi)
+ uint8_t protocol, uint32_t *spi)
{
*spi = (uint32_t)ref_get(&this->spi);
return SUCCESS;
METHOD(kernel_ipsec_t, get_cpi, status_t,
private_load_tester_ipsec_t *this, host_t *src, host_t *dst,
- u_int16_t *cpi)
+ uint16_t *cpi)
{
return FAILED;
}
METHOD(kernel_ipsec_t, add_sa, status_t,
private_load_tester_ipsec_t *this, host_t *src, host_t *dst,
- u_int32_t spi, u_int8_t protocol, u_int32_t reqid, mark_t mark,
- u_int32_t tfc, lifetime_cfg_t *lifetime, u_int16_t enc_alg, chunk_t enc_key,
- u_int16_t int_alg, chunk_t int_key, ipsec_mode_t mode,
- u_int16_t ipcomp, u_int16_t cpi, u_int32_t replay_window,
+ uint32_t spi, uint8_t protocol, uint32_t reqid, mark_t mark,
+ uint32_t tfc, lifetime_cfg_t *lifetime, uint16_t enc_alg, chunk_t enc_key,
+ uint16_t int_alg, chunk_t int_key, ipsec_mode_t mode,
+ uint16_t ipcomp, uint16_t cpi, uint32_t replay_window,
bool initiator, bool encap, bool esn, bool inbound, bool update,
linked_list_t *src_ts, linked_list_t *dst_ts)
{
}
METHOD(kernel_ipsec_t, update_sa, status_t,
- private_load_tester_ipsec_t *this, u_int32_t spi, u_int8_t protocol,
- u_int16_t cpi, host_t *src, host_t *dst, host_t *new_src,
+ private_load_tester_ipsec_t *this, uint32_t spi, uint8_t protocol,
+ uint16_t cpi, host_t *src, host_t *dst, host_t *new_src,
host_t *new_dst, bool encap, bool new_encap, mark_t mark)
{
return SUCCESS;
METHOD(kernel_ipsec_t, query_sa, status_t,
private_load_tester_ipsec_t *this, host_t *src, host_t *dst,
- u_int32_t spi, u_int8_t protocol, mark_t mark,
- u_int64_t *bytes, u_int64_t *packets, time_t *time)
+ uint32_t spi, uint8_t protocol, mark_t mark,
+ uint64_t *bytes, uint64_t *packets, time_t *time)
{
return NOT_SUPPORTED;
}
METHOD(kernel_ipsec_t, del_sa, status_t,
private_load_tester_ipsec_t *this, host_t *src, host_t *dst,
- u_int32_t spi, u_int8_t protocol, u_int16_t cpi, mark_t mark)
+ uint32_t spi, uint8_t protocol, uint16_t cpi, mark_t mark)
{
return SUCCESS;
}
xmlTextReaderNodeType(reader) == XML_READER_TYPE_TEXT)
{
const char *str;
- u_int32_t id;
+ uint32_t id;
status_t status;
str = xmlTextReaderConstValue(reader);
/**
* Configured port (or random, if initially 0)
*/
- u_int16_t port;
+ uint16_t port;
/**
* Configured port for NAT-T (or random, if initially 0)
*/
- u_int16_t natt;
+ uint16_t natt;
/**
* IPv4 socket (500 or port)
/**
* DSCP value set on IPv4 socket
*/
- u_int8_t dscp4;
+ uint8_t dscp4;
/**
* DSCP value set on IPv4 socket for NAT-T (4500 or natt)
*/
- u_int8_t dscp4_natt;
+ uint8_t dscp4_natt;
/**
* DSCP value set on IPv6 socket (500 or port)
*/
- u_int8_t dscp6;
+ uint8_t dscp6;
/**
* DSCP value set on IPv6 socket for NAT-T (4500 or natt)
*/
- u_int8_t dscp6_natt;
+ uint8_t dscp6_natt;
/**
* Maximum packet size to receive
*/
#ifdef IP_PKTINFO
-static host_t *get_dst_v4(struct cmsghdr *cmsgptr, u_int16_t port)
+static host_t *get_dst_v4(struct cmsghdr *cmsgptr, uint16_t port)
{
struct sockaddr_in dst = {
.sin_family = AF_INET,
#elif defined(IP_RECVDSTADDR)
-static host_t *get_dst_v4(struct cmsghdr *cmsgptr, u_int16_t port)
+static host_t *get_dst_v4(struct cmsghdr *cmsgptr, uint16_t port)
{
struct sockaddr_in dst = {
.sin_family = AF_INET,
#else /* IP_PKTINFO || IP_RECVDSTADDR */
-static host_t *get_dst_v4(struct cmsghdr *cmsgptr, u_int16_t port)
+static host_t *get_dst_v4(struct cmsghdr *cmsgptr, uint16_t port)
{
return NULL;
}
*/
#ifdef HAVE_IN6_PKTINFO
-static host_t *get_dst_v6(struct cmsghdr *cmsgptr, u_int16_t port)
+static host_t *get_dst_v6(struct cmsghdr *cmsgptr, uint16_t port)
{
struct in6_pktinfo *pktinfo;
struct sockaddr_in6 dst = {
#else /* HAVE_IN6_PKTINFO */
-static host_t *get_dst_v6(struct cmsghdr *cmsgptr, u_int16_t port)
+static host_t *get_dst_v6(struct cmsghdr *cmsgptr, uint16_t port)
{
return NULL;
}
host_t *source = NULL, *dest = NULL;
int i, rr, index, bytes_read = 0, selected = -1;
bool oldstate;
- u_int16_t port = 0;
+ uint16_t port = 0;
struct pollfd pfd[] = {
{ .fd = this->ipv4, .events = POLLIN },
{ .fd = this->ipv4_natt, .events = POLLIN },
host_t *src, *dst;
struct msghdr msg;
struct iovec iov;
- u_int8_t *dscp;
+ uint8_t *dscp;
src = packet->get_source(packet);
dst = packet->get_destination(packet);
{
if (family == AF_INET)
{
- u_int8_t ds4;
+ uint8_t ds4;
ds4 = packet->get_dscp(packet) << 2;
if (setsockopt(skt, SOL_IP, IP_TOS, &ds4, sizeof(ds4)) == 0)
return SUCCESS;
}
-METHOD(socket_t, get_port, u_int16_t,
+METHOD(socket_t, get_port, uint16_t,
private_socket_default_socket_t *this, bool nat_t)
{
return nat_t ? this->natt : this->port;
* open a socket to send and receive packets
*/
static int open_socket(private_socket_default_socket_t *this,
- int family, u_int16_t *port)
+ int family, uint16_t *port)
{
int on = TRUE;
union {
/**
* Bound source port
*/
- u_int16_t port;
+ uint16_t port;
};
/**
/**
* Get the port allocated dynamically using bind()
*/
-static bool get_dynamic_port(int fd, int family, u_int16_t *port)
+static bool get_dynamic_port(int fd, int family, uint16_t *port)
{
union {
struct sockaddr_storage ss;
* open a socket to send and receive packets
*/
static int open_socket(private_socket_dynamic_socket_t *this,
- int family, u_int16_t *port)
+ int family, uint16_t *port)
{
union {
struct sockaddr_storage ss;
* Find/Create a socket to send from host
*/
static dynsock_t *find_socket(private_socket_dynamic_socket_t *this,
- int family, u_int16_t port)
+ int family, uint16_t port)
{
dynsock_t *skt, lookup = {
.family = family,
return SUCCESS;
}
-METHOD(socket_t, get_port, u_int16_t,
+METHOD(socket_t, get_port, uint16_t,
private_socket_dynamic_socket_t *this, bool nat_t)
{
/* we return 0 here for users that have no explicit port configured, the
/**
* Port for each socket
*/
- u_int16_t ports[SOCKET_COUNT];
+ uint16_t ports[SOCKET_COUNT];
/**
* IPv4/IPv6 dual-use sockets
METHOD(socket_t, sender, status_t,
private_socket_win_socket_t *this, packet_t *packet)
{
- u_int16_t port;
+ uint16_t port;
int i = -1, j;
host_t *src, *dst;
WSAMSG msg;
return SUCCESS;
}
-METHOD(socket_t, get_port, u_int16_t,
+METHOD(socket_t, get_port, uint16_t,
private_socket_win_socket_t *this, bool nat)
{
return this->ports[nat != 0];
chunk_t local_spi, remote_spi;
host_t *local_host, *remote_host;
identification_t *local_id, *remote_id;
- u_int64_t ispi, rspi;
+ uint64_t ispi, rspi;
ike_sa_id_t *id;
id = ike_sa->get_id(ike_sa);
static ike_cfg_t *build_ike_cfg(private_stroke_config_t *this, stroke_msg_t *msg)
{
ike_cfg_t *ike_cfg;
- u_int16_t ikeport;
+ uint16_t ikeport;
char me[256], other[256];
swap_ends(msg);
identification_t *peer_id = NULL;
peer_cfg_t *mediated_by = NULL;
unique_policy_t unique;
- u_int32_t rekey = 0, reauth = 0, over, jitter;
+ uint32_t rekey = 0, reauth = 0, over, jitter;
peer_cfg_t *peer_cfg;
auth_cfg_t *auth_cfg;
/**
* Parse a protoport specifier
*/
-static bool parse_protoport(char *token, u_int16_t *from_port,
- u_int16_t *to_port, u_int8_t *protocol)
+static bool parse_protoport(char *token, uint16_t *from_port,
+ uint16_t *to_port, uint8_t *protocol)
{
char *sep, *port = "", *endptr;
struct protoent *proto;
{
return FALSE;
}
- *protocol = (u_int8_t)p;
+ *protocol = (uint8_t)p;
}
}
if (streq(port, "%any"))
{
enumerator_t *enumerator;
char *subnet, *pos;
- u_int16_t from_port, to_port;
- u_int8_t proto;
+ uint16_t from_port, to_port;
+ uint8_t proto;
enumerator = enumerator_create_token(end->subnets, ",", " ");
while (enumerator->enumerate(enumerator, &subnet))
/**
* Parse a terminate/rekey specifier
*/
-static bool parse_specifier(char *string, u_int32_t *id,
+static bool parse_specifier(char *string, uint32_t *id,
char **name, bool *child, bool *all)
{
int len;
* Report the result of a terminate() call to console
*/
static void report_terminate_status(private_stroke_control_t *this,
- status_t status, FILE *out, u_int32_t id, bool child)
+ status_t status, FILE *out, uint32_t id, bool child)
{
char *prefix, *postfix;
/**
* Call the charon controller to terminate a CHILD_SA
*/
-static void charon_terminate(private_stroke_control_t *this, u_int32_t id,
+static void charon_terminate(private_stroke_control_t *this, uint32_t id,
stroke_msg_t *msg, FILE *out, bool child)
{
if (msg->output_verbosity >= 0)
private_stroke_control_t *this, stroke_msg_t *msg, FILE *out)
{
char *name;
- u_int32_t id;
+ uint32_t id;
bool child, all;
ike_sa_t *ike_sa;
enumerator_t *enumerator;
private_stroke_control_t *this, stroke_msg_t *msg, FILE *out)
{
char *name;
- u_int32_t id;
+ uint32_t id;
bool child, all, finished = FALSE;
ike_sa_t *ike_sa;
enumerator_t *enumerator;
/**
* Find an existing CHILD_SA/reqid
*/
-static u_int32_t find_reqid(child_cfg_t *child_cfg)
+static uint32_t find_reqid(child_cfg_t *child_cfg)
{
enumerator_t *enumerator, *children;
child_sa_t *child_sa;
ike_sa_t *ike_sa;
char *name;
- u_int32_t reqid;
+ uint32_t reqid;
reqid = charon->traps->find_reqid(charon->traps, child_cfg);
if (reqid)
char *name, FILE *out)
{
ipsec_mode_t mode;
- u_int32_t reqid;
+ uint32_t reqid;
mode = child_cfg->get_mode(child_cfg);
if (mode == MODE_PASS || mode == MODE_DROP)
{
child_sa_t *child_sa;
enumerator_t *enumerator;
- u_int32_t id = 0;
+ uint32_t id = 0;
if (charon->shunts->uninstall(charon->shunts, msg->unroute.name))
{
/**
* Global counter values
*/
- u_int64_t counter[COUNTER_MAX];
+ uint64_t counter[COUNTER_MAX];
/**
* Counters for specific connection names, char* => entry_t
/** connection name */
char *name;
/** counter values for connection */
- u_int64_t counter[COUNTER_MAX];
+ uint64_t counter[COUNTER_MAX];
} entry_t;
/**
* Print a single counter value to out
*/
static void print_counter(FILE *out, stroke_counter_type_t type,
- u_int64_t counter)
+ uint64_t counter)
{
fprintf(out, "%-18N %12llu\n", stroke_counter_type_names, type, counter);
}
*/
static void print_one(private_stroke_counter_t *this, FILE *out, char *name)
{
- u_int64_t counter[COUNTER_MAX];
+ uint64_t counter[COUNTER_MAX];
entry_t *entry;
int i;
*/
static void print_global(private_stroke_counter_t *this, FILE *out)
{
- u_int64_t counter[COUNTER_MAX];
+ uint64_t counter[COUNTER_MAX];
int i;
this->lock->lock(this->lock);
static void log_child_sa(FILE *out, child_sa_t *child_sa, bool all)
{
time_t use_in, use_out, rekey, now;
- u_int64_t bytes_in, bytes_out, packets_in, packets_out;
+ uint64_t bytes_in, bytes_out, packets_in, packets_out;
proposal_t *proposal;
linked_list_t *my_ts, *other_ts;
child_cfg_t *config;
proposal = child_sa->get_proposal(child_sa);
if (proposal)
{
- u_int16_t alg, ks;
+ uint16_t alg, ks;
bool first = TRUE;
if (proposal->get_algorithm(proposal, ENCRYPTION_ALGORITHM,
{
fprintf(out, " (%" PRIu64 " pkt%s, %" PRIu64 "s ago)",
packets_in, (packets_in == 1) ? "": "s",
- (u_int64_t)(now - use_in));
+ (uint64_t)(now - use_in));
}
child_sa->get_usestats(child_sa, FALSE,
{
fprintf(out, " (%" PRIu64 " pkt%s, %" PRIu64 "s ago)",
packets_out, (packets_out == 1) ? "": "s",
- (u_int64_t)(now - use_out));
+ (uint64_t)(now - use_out));
}
fprintf(out, ", rekeying ");
ike_version_t ike_version;
char *pool;
host_t *host;
- u_int32_t dpd;
+ uint32_t dpd;
time_t since, now;
u_int size, online, offline, i;
struct utsname utsname;
static bool on_accept(private_stroke_socket_t *this, stream_t *stream)
{
stroke_msg_t *msg;
- u_int16_t len;
+ uint16_t len;
FILE *out;
/* read length */
{
private_tnc_ifmap_listener_t *this;
job_t *job;
- u_int32_t reschedule;
+ uint32_t reschedule;
INIT(this,
.public = {
/**
* Reschedule time interval in seconds
*/
- u_int32_t reschedule;
+ uint32_t reschedule;
};
METHOD(job_t, destroy, void,
* Described in header
*/
tnc_ifmap_renew_session_job_t *tnc_ifmap_renew_session_job_create(
- tnc_ifmap_soap_t *ifmap, u_int32_t reschedule)
+ tnc_ifmap_soap_t *ifmap, uint32_t reschedule)
{
private_tnc_ifmap_renew_session_job_t *this;
* @param reschedule reschedule time in seconds
*/
tnc_ifmap_renew_session_job_t *tnc_ifmap_renew_session_job_create(
- tnc_ifmap_soap_t *ifmap, u_int32_t reschedule);
+ tnc_ifmap_soap_t *ifmap, uint32_t reschedule);
#endif /** TNC_IFMAP_RENEW_SESSION_JOB_H_ @}*/
* Create an access-request based on device_name and ike_sa_id
*/
static xmlNodePtr create_access_request(private_tnc_ifmap_soap_t *this,
- u_int32_t id)
+ uint32_t id)
{
xmlNodePtr node;
char buf[BUF_LEN];
identification_t *id, *eap_id, *group;
host_t *host;
auth_cfg_t *auth;
- u_int32_t ike_sa_id;
+ uint32_t ike_sa_id;
bool is_user = FALSE, first = TRUE, success;
/* extract relevant data from IKE_SA*/
{
tnc_ifmap_soap_msg_t *soap_msg;
xmlNodePtr request, node;
- u_int32_t ike_sa_id;
+ uint32_t ike_sa_id;
enumerator_t *enumerator;
host_t *vip;
bool success;
/**
* PT-TLS port of the server
*/
- u_int16_t pt_tls_port;
+ uint16_t pt_tls_port;
/**
* PT-TLS IPv4 socket
/**
* Open IPv4 or IPv6 UDP socket
*/
-static int open_udp_socket(int family, u_int16_t port)
+static int open_udp_socket(int family, uint16_t port)
{
int on = TRUE;
struct sockaddr_storage addr;
/**
* Open IPv4 or IPv6 TCP socket
*/
-static int open_tcp_socket(int family, u_int16_t port)
+static int open_tcp_socket(int family, uint16_t port)
{
int on = TRUE;
struct sockaddr_storage addr;
/**
* Encrypt a MS-MPPE-Send/Recv-Key
*/
-static chunk_t encrypt_mppe_key(private_tnc_pdp_t *this, u_int8_t type,
- chunk_t key, u_int16_t *salt,
+static chunk_t encrypt_mppe_key(private_tnc_pdp_t *this, uint8_t type,
+ chunk_t key, uint16_t *salt,
radius_message_t *request)
{
chunk_t a, r, seed, data;
{
radius_message_t *response;
chunk_t data, recv, send;
- u_int32_t tunnel_type;
- u_int16_t salt = 0;
+ uint32_t tunnel_type;
+ uint16_t salt = 0;
response = radius_message_create(code);
data = eap->get_data(eap);
eap_payload_t *in, *out = NULL;
eap_method_t *method;
eap_type_t eap_type;
- u_int32_t eap_vendor;
+ uint32_t eap_vendor;
chunk_t data, message = chunk_empty, msk = chunk_empty;
chunk_t user_name = chunk_empty, nas_id = chunk_empty;
identification_t *group = NULL;
{
host_t *net, *mask;
chunk_t padding;
- u_int8_t bits;
+ uint8_t bits;
if (!ts->to_subnet(ts, &net, &bits))
{
*/
static bool use_ts(traffic_selector_t *ts)
{
- u_int8_t mask;
+ uint8_t mask;
host_t *net;
if (ts->get_type(ts) != TS_IPV4_ADDR_RANGE)
*/
struct cache_entry_t {
/** requid of the CHILD_SA */
- u_int32_t reqid;
+ uint32_t reqid;
/** cached interface name */
char *iface;
};
/**
* Insert an interface name to the cache
*/
-static void cache_iface(private_updown_listener_t *this, u_int32_t reqid,
+static void cache_iface(private_updown_listener_t *this, uint32_t reqid,
char *iface)
{
cache_entry_t *entry = malloc_thing(cache_entry_t);
/**
* Remove a cached interface name and return it.
*/
-static char* uncache_iface(private_updown_listener_t *this, u_int32_t reqid)
+static char* uncache_iface(private_updown_listener_t *this, uint32_t reqid)
{
enumerator_t *enumerator;
cache_entry_t *entry;
{
host_t *me, *other, *host;
char *iface;
- u_int8_t mask;
+ uint8_t mask;
mark_t mark;
bool is_host, is_ipv6;
int out;
/**
* Handle a command response message
*/
-static bool handle_response(vici_conn_t *conn, u_int32_t len)
+static bool handle_response(vici_conn_t *conn, uint32_t len)
{
chunk_t buf;
/**
* Dispatch received event message
*/
-static bool handle_event(vici_conn_t *conn, u_int32_t len)
+static bool handle_event(vici_conn_t *conn, uint32_t len)
{
vici_message_t *message;
event_t *event;
- u_int8_t namelen;
+ uint8_t namelen;
char name[257], *buf;
if (len < sizeof(namelen))
CALLBACK(on_read, bool,
vici_conn_t *conn, stream_t *stream)
{
- u_int32_t len;
- u_int8_t op;
+ uint32_t len;
+ uint8_t op;
ssize_t hlen;
hlen = stream->read(stream, &len, sizeof(len), FALSE);
vici_message_t *message;
vici_res_t *res;
chunk_t data;
- u_int32_t len;
- u_int8_t namelen, op;
+ uint32_t len;
+ uint8_t namelen, op;
message = req->b->finalize(req->b);
if (!message)
int vici_register(vici_conn_t *conn, char *name, vici_event_cb_t cb, void *user)
{
event_t *event;
- u_int32_t len;
- u_int8_t namelen, op;
+ uint32_t len;
+ uint8_t namelen, op;
int ret = 1;
op = cb ? VICI_EVENT_REGISTER : VICI_EVENT_UNREGISTER;
ck_assert_int_eq(data->id, id);
/* count number of bytes, including the header */
- data->bytes += buf.len + sizeof(u_int32_t);
+ data->bytes += buf.len + sizeof(uint32_t);
/* echo back data chunk */
data->s->send(data->s, id, chunk_clone(buf));
}
0x00,0x00,0x00,0x0A, 0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x02A,
);
char buf[m.len];
- u_int32_t len;
+ uint32_t len;
lib->processor->set_threads(lib->processor, 4);
enumerator_t *enumerator;
host_t *host;
chunk_t start, end, current;
- u_int32_t size;
+ uint32_t size;
bool found = FALSE;
host = pool->get_base(pool);
{
if (host->get_family(host) == AF_INET)
{ /* IPv4 attributes contain a subnet mask */
- u_int32_t netmask = 0;
+ uint32_t netmask = 0;
if (mask)
- { /* shifting u_int32_t by 32 or more is undefined */
+ { /* shifting uint32_t by 32 or more is undefined */
mask = 32 - mask;
netmask = htonl((0xFFFFFFFF >> mask) << mask);
}
/**
* Magic value for an undefined lifetime
*/
-#define LFT_UNDEFINED (~(u_int64_t)0)
+#define LFT_UNDEFINED (~(uint64_t)0)
/**
* Default IKE rekey time
/**
* Undefined replay window
*/
-#define REPLAY_UNDEFINED (~(u_int32_t)0)
+#define REPLAY_UNDEFINED (~(uint32_t)0)
typedef struct private_vici_config_t private_vici_config_t;
typedef struct {
request_data_t *request;
auth_cfg_t *cfg;
- u_int32_t round;
+ uint32_t round;
} auth_data_t;
/**
*/
typedef struct {
request_data_t *request;
- u_int32_t version;
+ uint32_t version;
bool aggressive;
bool encap;
bool mobike;
bool send_certreq;
bool pull;
cert_policy_t send_cert;
- u_int64_t dpd_delay;
- u_int64_t dpd_timeout;
+ uint64_t dpd_delay;
+ uint64_t dpd_timeout;
fragmentation_t fragmentation;
unique_policy_t unique;
- u_int32_t keyingtries;
- u_int32_t local_port;
- u_int32_t remote_port;
+ uint32_t keyingtries;
+ uint32_t local_port;
+ uint32_t remote_port;
char *local_addrs;
char *remote_addrs;
linked_list_t *local;
linked_list_t *children;
linked_list_t *vips;
char *pools;
- u_int64_t reauth_time;
- u_int64_t rekey_time;
- u_int64_t over_time;
- u_int64_t rand_time;
+ uint64_t reauth_time;
+ uint64_t rekey_time;
+ uint64_t over_time;
+ uint64_t rand_time;
} peer_data_t;
/**
bool ipcomp;
bool policies;
ipsec_mode_t mode;
- u_int32_t replay_window;
+ uint32_t replay_window;
action_t dpd_action;
action_t start_action;
action_t close_action;
- u_int32_t reqid;
- u_int32_t tfc;
+ uint32_t reqid;
+ uint32_t tfc;
mark_t mark_in;
mark_t mark_out;
- u_int64_t inactivity;
+ uint64_t inactivity;
linked_list_t *proposals;
linked_list_t *local_ts;
linked_list_t *remote_ts;
struct protoent *protoent;
struct servent *svc;
long int p;
- u_int16_t from = 0, to = 0xffff;
- u_int8_t proto = 0;
+ uint16_t from = 0, to = 0xffff;
+ uint8_t proto = 0;
if (!vici_stringify(v, buf, sizeof(buf)))
{
{
return FALSE;
}
- proto = (u_int8_t)p;
+ proto = (uint8_t)p;
}
}
if (streq(port, "opaque"))
}
/**
- * Parse a u_int32_t
+ * Parse a uint32_t
*/
CALLBACK(parse_uint32, bool,
- u_int32_t *out, chunk_t v)
+ uint32_t *out, chunk_t v)
{
char buf[16], *end;
u_long l;
}
/**
- * Parse a u_int64_t
+ * Parse a uint64_t
*/
CALLBACK(parse_uint64, bool,
- u_int64_t *out, chunk_t v)
+ uint64_t *out, chunk_t v)
{
char buf[16], *end;
unsigned long long l;
* Parse a relative time
*/
CALLBACK(parse_time, bool,
- u_int64_t *out, chunk_t v)
+ uint64_t *out, chunk_t v)
{
char buf[16], *end;
u_long l;
* Parse byte volume
*/
CALLBACK(parse_bytes, bool,
- u_int64_t *out, chunk_t v)
+ uint64_t *out, chunk_t v)
{
char buf[16], *end;
unsigned long long l;
* Parse TFC padding option
*/
CALLBACK(parse_tfc, bool,
- u_int32_t *out, chunk_t v)
+ uint32_t *out, chunk_t v)
{
if (chunk_equals(v, chunk_from_str("mtu")))
{
/**
* Find reqid of an existing CHILD_SA
*/
-static u_int32_t find_reqid(child_cfg_t *cfg)
+static uint32_t find_reqid(child_cfg_t *cfg)
{
enumerator_t *enumerator, *children;
child_sa_t *child_sa;
ike_sa_t *ike_sa;
- u_int32_t reqid;
+ uint32_t reqid;
reqid = charon->traps->find_reqid(charon->traps, cfg);
if (reqid)
enumerator_t *enumerator, *children;
child_sa_t *child_sa;
ike_sa_t *ike_sa;
- u_int32_t id = 0, others;
+ uint32_t id = 0, others;
array_t *ids = NULL, *ikeids = NULL;
char *name;
/**
* Find reqid of an existing CHILD_SA
*/
-static u_int32_t find_reqid(child_cfg_t *cfg)
+static uint32_t find_reqid(child_cfg_t *cfg)
{
enumerator_t *enumerator, *children;
child_sa_t *child_sa;
ike_sa_t *ike_sa;
- u_int32_t reqid;
+ uint32_t reqid;
reqid = charon->traps->find_reqid(charon->traps, cfg);
if (reqid)
{
child_sa_t *child_sa;
enumerator_t *enumerator;
- u_int32_t reqid = 0;
+ uint32_t reqid = 0;
char *child;
child = request->get_str(request, NULL, "child");
bio_writer_t *writer;
u_int len;
- len = sizeof(u_int8_t);
+ len = sizeof(uint8_t);
if (name)
{
- len += sizeof(u_int8_t) + strlen(name);
+ len += sizeof(uint8_t) + strlen(name);
}
if (message)
{
{
bio_reader_t *reader;
chunk_t chunk;
- u_int8_t type;
+ uint8_t type;
char name[257];
reader = bio_reader_create(data);
METHOD(enumerator_t, parse_enumerate, bool,
parse_enumerator_t *this, vici_type_t *out, char **name, chunk_t *value)
{
- u_int8_t type;
+ uint8_t type;
chunk_t data;
if (!this->reader->remaining(this->reader) ||
child_sa_t *child, time_t now)
{
time_t t;
- u_int64_t bytes, packets;
- u_int16_t alg, ks;
+ uint64_t bytes, packets;
+ uint16_t alg, ks;
proposal_t *proposal;
enumerator_t *enumerator;
traffic_selector_t *ts;
b->add_kv(b, "packets-in", "%" PRIu64, packets);
if (t)
{
- b->add_kv(b, "use-in", "%"PRIu64, (u_int64_t)(now - t));
+ b->add_kv(b, "use-in", "%"PRIu64, (uint64_t)(now - t));
}
child->get_usestats(child, FALSE, &t, &bytes, &packets);
b->add_kv(b, "packets-out", "%"PRIu64, packets);
if (t)
{
- b->add_kv(b, "use-out", "%"PRIu64, (u_int64_t)(now - t));
+ b->add_kv(b, "use-out", "%"PRIu64, (uint64_t)(now - t));
}
t = child->get_lifetime(child, FALSE);
ike_sa_id_t *id;
identification_t *eap;
proposal_t *proposal;
- u_int16_t alg, ks;
+ uint16_t alg, ks;
host_t *host;
b->add_kv(b, "uniqueid", "%u", ike_sa->get_unique_id(ike_sa));
/** bytes of length header sent/received */
u_char hdrlen;
/** bytes of length header */
- char hdr[sizeof(u_int32_t)];
+ char hdr[sizeof(uint32_t)];
/** send/receive buffer on heap */
chunk_t buf;
/** bytes sent/received in buffer */
- u_int32_t done;
+ uint32_t done;
} msg_buf_t;
/**
static bool do_read(private_vici_socket_t *this, entry_t *entry,
stream_t *stream, char *errmsg, size_t errlen)
{
- u_int32_t msglen;
+ uint32_t msglen;
ssize_t len;
/* assemble the length header first */
eap_payload_t *request, *response;
eap_method_t *frontend;
eap_type_t type;
- u_int32_t vendor;
+ uint32_t vendor;
status_t status;
if (backend->initiate(backend, &request) != NEED_MORE)
/**
* reqid of the child to rekey
*/
- u_int32_t reqid;
+ uint32_t reqid;
/**
* acquired source traffic selector
/*
* Described in header
*/
-acquire_job_t *acquire_job_create(u_int32_t reqid,
+acquire_job_t *acquire_job_create(uint32_t reqid,
traffic_selector_t *src_ts,
traffic_selector_t *dst_ts)
{
* @param dst_ts destination traffic selector
* @return acquire_job_t object
*/
-acquire_job_t *acquire_job_create(u_int32_t reqid,
+acquire_job_t *acquire_job_create(uint32_t reqid,
traffic_selector_t *src_ts,
traffic_selector_t *dst_ts);
ike_sa_id_t *id;
ike_sa_t *ike_sa;
child_sa_t *child_sa;
- u_int32_t unique;
+ uint32_t unique;
ike_sa = charon->ike_sa_manager->checkout(charon->ike_sa_manager, this->id);
if (ike_sa)
/**
* inbound SPI of the CHILD_SA
*/
- u_int32_t spi;
+ uint32_t spi;
/**
* SA destination address
* Described in header
*/
delete_child_sa_job_t *delete_child_sa_job_create(protocol_id_t protocol,
- u_int32_t spi, host_t *dst, bool expired)
+ uint32_t spi, host_t *dst, bool expired)
{
private_delete_child_sa_job_t *this;
* @return delete_child_sa_job_t object
*/
delete_child_sa_job_t *delete_child_sa_job_create(protocol_id_t protocol,
- u_int32_t spi, host_t *dst, bool expired);
+ uint32_t spi, host_t *dst, bool expired);
#endif /** DELETE_CHILD_SA_JOB_H_ @}*/
/**
* Unique CHILD_SA identifier to check
*/
- u_int32_t id;
+ uint32_t id;
/**
* Inactivity timeout
*/
- u_int32_t timeout;
+ uint32_t timeout;
/**
* Close IKE_SA if last remaining CHILD inactive?
private_inactivity_job_t *this)
{
ike_sa_t *ike_sa;
- u_int32_t reschedule = 0;
+ uint32_t reschedule = 0;
ike_sa = charon->child_sa_manager->checkout_by_id(charon->child_sa_manager,
this->id, NULL);
{
enumerator_t *enumerator;
child_sa_t *child_sa;
- u_int32_t delete = 0;
+ uint32_t delete = 0;
protocol_id_t proto = 0;
int children = 0;
status_t status = SUCCESS;
/**
* See header
*/
-inactivity_job_t *inactivity_job_create(u_int32_t unique_id, u_int32_t timeout,
+inactivity_job_t *inactivity_job_create(uint32_t unique_id, uint32_t timeout,
bool close_ike)
{
private_inactivity_job_t *this;
* @param close_ike close IKE_SA if the last remaining CHILD_SA is inactive?
* @return inactivity checking job
*/
-inactivity_job_t *inactivity_job_create(u_int32_t unique_id, u_int32_t timeout,
+inactivity_job_t *inactivity_job_create(uint32_t unique_id, uint32_t timeout,
bool close_ike);
#endif /** INACTIVITY_JOB_H_ @}*/
/**
* reqid of the CHILD_SA if it already exists
*/
- u_int32_t reqid;
+ uint32_t reqid;
/**
* source traffic selector
/*
* Described in header
*/
-migrate_job_t *migrate_job_create(u_int32_t reqid,
+migrate_job_t *migrate_job_create(uint32_t reqid,
traffic_selector_t *src_ts,
traffic_selector_t *dst_ts,
policy_dir_t dir,
* @param remote remote host address to be used in the IKE_SA
* @return migrate_job_t object
*/
-migrate_job_t *migrate_job_create(u_int32_t reqid,
+migrate_job_t *migrate_job_create(uint32_t reqid,
traffic_selector_t *src_ts, traffic_selector_t *dst_ts,
policy_dir_t dir, host_t *local, host_t *remote);
/**
* inbound SPI of the CHILD_SA
*/
- u_int32_t spi;
+ uint32_t spi;
/**
* SA destination address
* Described in header
*/
rekey_child_sa_job_t *rekey_child_sa_job_create(protocol_id_t protocol,
- u_int32_t spi, host_t *dst)
+ uint32_t spi, host_t *dst)
{
private_rekey_child_sa_job_t *this;
* @return rekey_child_sa_job_t object
*/
rekey_child_sa_job_t *rekey_child_sa_job_create(protocol_id_t protocol,
- u_int32_t spi, host_t *dst);
+ uint32_t spi, host_t *dst);
#endif /** REKEY_CHILD_SA_JOB_H_ @}*/
/**
* Check if we should delay a reauth, and by how many seconds
*/
-static u_int32_t get_retry_delay(ike_sa_t *ike_sa)
+static uint32_t get_retry_delay(ike_sa_t *ike_sa)
{
enumerator_t *enumerator;
child_sa_t *child_sa;
- u_int32_t retry = 0;
+ uint32_t retry = 0;
/* avoid reauth collisions for certain IKE_SA/CHILD_SA states */
if (ike_sa->get_state(ike_sa) != IKE_ESTABLISHED)
{
ike_sa_t *ike_sa;
status_t status = SUCCESS;
- u_int32_t retry = 0;
+ uint32_t retry = 0;
ike_sa = charon->ike_sa_manager->checkout(charon->ike_sa_manager,
this->ike_sa_id);
/**
* Message ID of the request to resend.
*/
- u_int32_t message_id;
+ uint32_t message_id;
/**
* ID of the IKE_SA which the message belongs to.
/*
* Described in header.
*/
-retransmit_job_t *retransmit_job_create(u_int32_t message_id,ike_sa_id_t *ike_sa_id)
+retransmit_job_t *retransmit_job_create(uint32_t message_id,ike_sa_id_t *ike_sa_id)
{
private_retransmit_job_t *this;
* @param ike_sa_id identification of the ike_sa as ike_sa_id_t
* @return retransmit_job_t object
*/
-retransmit_job_t *retransmit_job_create(u_int32_t message_id,
+retransmit_job_t *retransmit_job_create(uint32_t message_id,
ike_sa_id_t *ike_sa_id);
#endif /** RETRANSMIT_JOB_H_ @}*/
/**
* SPI of the CHILD_SA
*/
- u_int32_t spi;
+ uint32_t spi;
/**
* Old SA destination address
* Described in header
*/
update_sa_job_t *update_sa_job_create(protocol_id_t protocol,
- u_int32_t spi, host_t *dst, host_t *new)
+ uint32_t spi, host_t *dst, host_t *new)
{
private_update_sa_job_t *this;
* @return update_sa_job_t object
*/
update_sa_job_t *update_sa_job_create(protocol_id_t protocol,
- u_int32_t spi, host_t *dst, host_t *new);
+ uint32_t spi, host_t *dst, host_t *new);
#endif /** UPDATE_SA_JOB_H_ @}*/
/**
* our actually used SPI, 0 if unused
*/
- u_int32_t my_spi;
+ uint32_t my_spi;
/**
* others used SPI, 0 if unused
*/
- u_int32_t other_spi;
+ uint32_t other_spi;
/**
* our Compression Parameter Index (CPI) used, 0 if unused
*/
- u_int16_t my_cpi;
+ uint16_t my_cpi;
/**
* others Compression Parameter Index (CPI) used, 0 if unused
*/
- u_int16_t other_cpi;
+ uint16_t other_cpi;
/**
* Array for local traffic selectors
/**
* reqid used for this child_sa
*/
- u_int32_t reqid;
+ uint32_t reqid;
/**
* Did we allocate/confirm and must release the reqid?
/*
* Unique CHILD_SA identifier
*/
- u_int32_t unique_id;
+ uint32_t unique_id;
/**
* inbound mark used for this child_sa
/**
* last number of inbound bytes
*/
- u_int64_t my_usebytes;
+ uint64_t my_usebytes;
/**
* last number of outbound bytes
*/
- u_int64_t other_usebytes;
+ uint64_t other_usebytes;
/**
* last number of inbound packets
*/
- u_int64_t my_usepackets;
+ uint64_t my_usepackets;
/**
* last number of outbound bytes
*/
- u_int64_t other_usepackets;
+ uint64_t other_usepackets;
};
/**
* convert an IKEv2 specific protocol identifier to the IP protocol identifier.
*/
-static inline u_int8_t proto_ike2ip(protocol_id_t protocol)
+static inline uint8_t proto_ike2ip(protocol_id_t protocol)
{
switch (protocol)
{
return this->config->get_name(this->config);
}
-METHOD(child_sa_t, get_reqid, u_int32_t,
+METHOD(child_sa_t, get_reqid, uint32_t,
private_child_sa_t *this)
{
return this->reqid;
}
-METHOD(child_sa_t, get_unique_id, u_int32_t,
+METHOD(child_sa_t, get_unique_id, uint32_t,
private_child_sa_t *this)
{
return this->unique_id;
return this->state;
}
-METHOD(child_sa_t, get_spi, u_int32_t,
+METHOD(child_sa_t, get_spi, uint32_t,
private_child_sa_t *this, bool inbound)
{
return inbound ? this->my_spi : this->other_spi;
}
-METHOD(child_sa_t, get_cpi, u_int16_t,
+METHOD(child_sa_t, get_cpi, uint16_t,
private_child_sa_t *this, bool inbound)
{
return inbound ? this->my_cpi : this->other_cpi;
static status_t update_usebytes(private_child_sa_t *this, bool inbound)
{
status_t status = FAILED;
- u_int64_t bytes, packets;
+ uint64_t bytes, packets;
time_t time;
if (inbound)
METHOD(child_sa_t, get_usestats, void,
private_child_sa_t *this, bool inbound,
- time_t *time, u_int64_t *bytes, u_int64_t *packets)
+ time_t *time, uint64_t *bytes, uint64_t *packets)
{
if ((!bytes && !packets) || update_usebytes(this, inbound) != FAILED)
{
return this->install_time;
}
-METHOD(child_sa_t, alloc_spi, u_int32_t,
+METHOD(child_sa_t, alloc_spi, uint32_t,
private_child_sa_t *this, protocol_id_t protocol)
{
if (charon->kernel->get_spi(charon->kernel, this->other_addr, this->my_addr,
return 0;
}
-METHOD(child_sa_t, alloc_cpi, u_int16_t,
+METHOD(child_sa_t, alloc_cpi, uint16_t,
private_child_sa_t *this)
{
if (charon->kernel->get_cpi(charon->kernel, this->other_addr, this->my_addr,
}
METHOD(child_sa_t, install, status_t,
- private_child_sa_t *this, chunk_t encr, chunk_t integ, u_int32_t spi,
- u_int16_t cpi, bool initiator, bool inbound, bool tfcv3,
+ private_child_sa_t *this, chunk_t encr, chunk_t integ, uint32_t spi,
+ uint16_t cpi, bool initiator, bool inbound, bool tfcv3,
linked_list_t *my_ts, linked_list_t *other_ts)
{
- u_int16_t enc_alg = ENCR_UNDEFINED, int_alg = AUTH_UNDEFINED, size;
- u_int16_t esn = NO_EXT_SEQ_NUMBERS;
+ uint16_t enc_alg = ENCR_UNDEFINED, int_alg = AUTH_UNDEFINED, size;
+ uint16_t esn = NO_EXT_SEQ_NUMBERS;
linked_list_t *src_ts = NULL, *dst_ts = NULL;
time_t now;
lifetime_cfg_t *lifetime;
- u_int32_t tfc = 0;
+ uint32_t tfc = 0;
host_t *src, *dst;
status_t status;
bool update = FALSE;
static host_t* get_proxy_addr(child_cfg_t *config, host_t *ike, bool local)
{
host_t *host = NULL;
- u_int8_t mask;
+ uint8_t mask;
enumerator_t *enumerator;
linked_list_t *ts_list, *list;
traffic_selector_t *ts;
* Described in header.
*/
child_sa_t * child_sa_create(host_t *me, host_t* other,
- child_cfg_t *config, u_int32_t rekey, bool encap,
+ child_cfg_t *config, uint32_t rekey, bool encap,
u_int mark_in, u_int mark_out)
{
private_child_sa_t *this;
*
* @return reqid of the CHILD SA
*/
- u_int32_t (*get_reqid)(child_sa_t *this);
+ uint32_t (*get_reqid)(child_sa_t *this);
/**
* Get the unique numerical identifier for this CHILD_SA.
*
* @return unique CHILD_SA identifier
*/
- u_int32_t (*get_unique_id)(child_sa_t *this);
+ uint32_t (*get_unique_id)(child_sa_t *this);
/**
* Get the config used to set up this child sa.
* @param inbound TRUE to get inbound SPI, FALSE for outbound.
* @return SPI of the CHILD SA
*/
- u_int32_t (*get_spi) (child_sa_t *this, bool inbound);
+ uint32_t (*get_spi) (child_sa_t *this, bool inbound);
/**
* Get the CPI of this CHILD_SA.
* @param inbound TRUE to get inbound CPI, FALSE for outbound.
* @return CPI of the CHILD SA
*/
- u_int16_t (*get_cpi) (child_sa_t *this, bool inbound);
+ uint16_t (*get_cpi) (child_sa_t *this, bool inbound);
/**
* Get the protocol which this CHILD_SA uses to protect traffic.
* @param[out] packets number of processed packets (NULL to ignore)
*/
void (*get_usestats)(child_sa_t *this, bool inbound, time_t *time,
- u_int64_t *bytes, u_int64_t *packets);
+ uint64_t *bytes, uint64_t *packets);
/**
* Get the mark used with this CHILD_SA.
* @param spi SPI output pointer
* @return SPI, 0 on failure
*/
- u_int32_t (*alloc_spi)(child_sa_t *this, protocol_id_t protocol);
+ uint32_t (*alloc_spi)(child_sa_t *this, protocol_id_t protocol);
/**
* Allocate a CPI to use for IPComp.
*
* @return CPI, 0 on failure
*/
- u_int16_t (*alloc_cpi)(child_sa_t *this);
+ uint16_t (*alloc_cpi)(child_sa_t *this);
/**
* Install an IPsec SA for one direction.
* @return SUCCESS or FAILED
*/
status_t (*install)(child_sa_t *this, chunk_t encr, chunk_t integ,
- u_int32_t spi, u_int16_t cpi,
+ uint32_t spi, uint16_t cpi,
bool initiator, bool inbound, bool tfcv3,
linked_list_t *my_ts, linked_list_t *other_ts);
/**
* @return child_sa_t object
*/
child_sa_t * child_sa_create(host_t *me, host_t *other, child_cfg_t *config,
- u_int32_t reqid, bool encap,
+ uint32_t reqid, bool encap,
u_int mark_in, u_int mark_out);
#endif /** CHILD_SA_H_ @}*/
/** the associated IKE_SA */
ike_sa_id_t *ike_id;
/** unique CHILD_SA identifier */
- u_int32_t unique_id;
+ uint32_t unique_id;
/** inbound SPI */
- u_int32_t spi_in;
+ uint32_t spi_in;
/** outbound SPI */
- u_int32_t spi_out;
+ uint32_t spi_out;
/** inbound host address */
host_t *host_in;
/** outbound host address and port */
* Check out an IKE_SA for a given CHILD_SA
*/
static ike_sa_t *checkout_ikesa(private_child_sa_manager_t *this,
- ike_sa_id_t *id, u_int32_t unique_id, child_sa_t **child_sa)
+ ike_sa_id_t *id, uint32_t unique_id, child_sa_t **child_sa)
{
enumerator_t *enumerator;
child_sa_t *current;
}
METHOD(child_sa_manager_t, checkout_by_id, ike_sa_t*,
- private_child_sa_manager_t *this, u_int32_t unique_id,
+ private_child_sa_manager_t *this, uint32_t unique_id,
child_sa_t **child_sa)
{
ike_sa_id_t *id;
}
METHOD(child_sa_manager_t, checkout, ike_sa_t*,
- private_child_sa_manager_t *this, protocol_id_t protocol, u_int32_t spi,
+ private_child_sa_manager_t *this, protocol_id_t protocol, uint32_t spi,
host_t *dst, child_sa_t **child_sa)
{
ike_sa_id_t *id;
- u_int32_t unique_id;
+ uint32_t unique_id;
child_entry_t *entry, key = {
.spi_in = spi,
.spi_out = spi,
* @return IKE_SA, NULL if not found
*/
ike_sa_t *(*checkout)(child_sa_manager_t *this,
- protocol_id_t protocol, u_int32_t spi, host_t *dst,
+ protocol_id_t protocol, uint32_t spi, host_t *dst,
child_sa_t **child_sa);
/**
* @param child_sa returns CHILD_SA managed by IKE_SA
* @return IKE_SA, NULL if not found
*/
- ike_sa_t *(*checkout_by_id)(child_sa_manager_t *this, u_int32_t unique_id,
+ ike_sa_t *(*checkout_by_id)(child_sa_manager_t *this, uint32_t unique_id,
child_sa_t **child_sa);
/**
/**
* vendor ID, 0 for default EAP methods
*/
- u_int32_t vendor;
+ uint32_t vendor;
/**
* Role of the method returned by the constructor, EAP_SERVER or EAP_PEER
};
METHOD(eap_manager_t, add_method, void,
- private_eap_manager_t *this, eap_type_t type, u_int32_t vendor,
+ private_eap_manager_t *this, eap_type_t type, uint32_t vendor,
eap_role_t role, eap_constructor_t constructor)
{
eap_entry_t *entry = malloc_thing(eap_entry_t);
* filter the registered methods
*/
static bool filter_methods(uintptr_t role, eap_entry_t **entry,
- eap_type_t *type, void *in, u_int32_t *vendor)
+ eap_type_t *type, void *in, uint32_t *vendor)
{
if ((*entry)->role != (eap_role_t)role)
{
}
METHOD(eap_manager_t, create_instance, eap_method_t*,
- private_eap_manager_t *this, eap_type_t type, u_int32_t vendor,
+ private_eap_manager_t *this, eap_type_t type, uint32_t vendor,
eap_role_t role, identification_t *server, identification_t *peer)
{
enumerator_t *enumerator;
* @param role EAP role of the registered method
* @param constructor constructor function, returns an eap_method_t
*/
- void (*add_method)(eap_manager_t *this, eap_type_t type, u_int32_t vendor,
+ void (*add_method)(eap_manager_t *this, eap_type_t type, uint32_t vendor,
eap_role_t role, eap_constructor_t constructor);
/**
* even though it is registered as method with this manager).
*
* @param role EAP role of methods to enumerate
- * @return enumerator over (eap_type_t type, u_int32_t vendor)
+ * @return enumerator over (eap_type_t type, uint32_t vendor)
*/
enumerator_t* (*create_enumerator)(eap_manager_t *this, eap_role_t role);
* @return EAP method instance, NULL if no constructor found
*/
eap_method_t* (*create_instance)(eap_manager_t *this, eap_type_t type,
- u_int32_t vendor, eap_role_t role,
+ uint32_t vendor, eap_role_t role,
identification_t *server,
identification_t *peer);
* @param vendor pointer receiving vendor identifier for type, 0 for none
* @return type of the EAP method
*/
- eap_type_t (*get_type) (eap_method_t *this, u_int32_t *vendor);
+ eap_type_t (*get_type) (eap_method_t *this, uint32_t *vendor);
/**
* Check if this EAP method authenticates the server.
*
* @return current EAP identifier
*/
- u_int8_t (*get_identifier) (eap_method_t *this);
+ uint8_t (*get_identifier) (eap_method_t *this);
/**
* Set the EAP identifier to a deterministic value, overwriting
*
* @param identifier current EAP identifier
*/
- void (*set_identifier) (eap_method_t *this, u_int8_t identifier);
+ void (*set_identifier) (eap_method_t *this, uint8_t identifier);
/**
* Get authentication details performed by this EAP method.
/**
* unique numerical ID for this IKE_SA.
*/
- u_int32_t unique_id;
+ uint32_t unique_id;
/**
* Current state of the IKE_SA
/**
* number pending UPDATE_SA_ADDRESS (MOBIKE)
*/
- u_int32_t pending_updates;
+ uint32_t pending_updates;
/**
* NAT keep alive interval
*/
- u_int32_t keepalive_interval;
+ uint32_t keepalive_interval;
/**
* The schedueld keep alive job, if any
* interval for retries during initiation (e.g. if DNS resolution failed),
* 0 to disable (default)
*/
- u_int32_t retry_initiate_interval;
+ uint32_t retry_initiate_interval;
/**
* TRUE if a retry_initiate_job has been queued
/**
* Timestamps for this IKE_SA
*/
- u_int32_t stats[STAT_MAX];
+ uint32_t stats[STAT_MAX];
/**
* how many times we have retried so far (keyingtries)
*/
- u_int32_t keyingtry;
+ uint32_t keyingtry;
/**
* local host address to be used for IKE, set via MIGRATE kernel message
return use_time;
}
-METHOD(ike_sa_t, get_unique_id, u_int32_t,
+METHOD(ike_sa_t, get_unique_id, uint32_t,
private_ike_sa_t *this)
{
return this->unique_id;
return "(unnamed)";
}
-METHOD(ike_sa_t, get_statistic, u_int32_t,
+METHOD(ike_sa_t, get_statistic, uint32_t,
private_ike_sa_t *this, statistic_t kind)
{
if (kind < STAT_MAX)
}
METHOD(ike_sa_t, set_statistic, void,
- private_ike_sa_t *this, statistic_t kind, u_int32_t value)
+ private_ike_sa_t *this, statistic_t kind, uint32_t value)
{
if (kind < STAT_MAX)
{
}
METHOD(ike_sa_t, set_message_id, void,
- private_ike_sa_t *this, bool initiate, u_int32_t mid)
+ private_ike_sa_t *this, bool initiate, uint32_t mid)
{
if (initiate)
{
this->state == IKE_PASSIVE)
{
job_t *job;
- u_int32_t t;
+ uint32_t t;
/* calculate rekey, reauth and lifetime */
this->stats[STAT_ESTABLISHED] = time_monotonic(NULL);
}
METHOD(ike_sa_t, set_pending_updates, void,
- private_ike_sa_t *this, u_int32_t updates)
+ private_ike_sa_t *this, uint32_t updates)
{
this->pending_updates = updates;
}
-METHOD(ike_sa_t, get_pending_updates, u_int32_t,
+METHOD(ike_sa_t, get_pending_updates, uint32_t,
private_ike_sa_t *this)
{
return this->pending_updates;
}
METHOD(ike_sa_t, initiate, status_t,
- private_ike_sa_t *this, child_cfg_t *child_cfg, u_int32_t reqid,
+ private_ike_sa_t *this, child_cfg_t *child_cfg, uint32_t reqid,
traffic_selector_t *tsi, traffic_selector_t *tsr)
{
bool defer_initiate = FALSE;
}
METHOD(ike_sa_t, get_child_sa, child_sa_t*,
- private_ike_sa_t *this, protocol_id_t protocol, u_int32_t spi, bool inbound)
+ private_ike_sa_t *this, protocol_id_t protocol, uint32_t spi, bool inbound)
{
enumerator_t *enumerator;
child_sa_t *current, *found = NULL;
}
METHOD(ike_sa_t, rekey_child_sa, status_t,
- private_ike_sa_t *this, protocol_id_t protocol, u_int32_t spi)
+ private_ike_sa_t *this, protocol_id_t protocol, uint32_t spi)
{
if (this->state == IKE_PASSIVE)
{
}
METHOD(ike_sa_t, delete_child_sa, status_t,
- private_ike_sa_t *this, protocol_id_t protocol, u_int32_t spi, bool expired)
+ private_ike_sa_t *this, protocol_id_t protocol, uint32_t spi, bool expired)
{
if (this->state == IKE_PASSIVE)
{
}
METHOD(ike_sa_t, destroy_child_sa, status_t,
- private_ike_sa_t *this, protocol_id_t protocol, u_int32_t spi)
+ private_ike_sa_t *this, protocol_id_t protocol, uint32_t spi)
{
enumerator_t *enumerator;
child_sa_t *child_sa;
}
METHOD(ike_sa_t, retransmit, status_t,
- private_ike_sa_t *this, u_int32_t message_id)
+ private_ike_sa_t *this, uint32_t message_id)
{
if (this->state == IKE_PASSIVE)
{
case IKE_CONNECTING:
{
/* retry IKE_SA_INIT/Main Mode if we have multiple keyingtries */
- u_int32_t tries = this->peer_cfg->get_keyingtries(this->peer_cfg);
+ uint32_t tries = this->peer_cfg->get_keyingtries(this->peer_cfg);
charon->bus->alert(charon->bus, ALERT_PEER_INIT_UNREACHABLE,
this->keyingtry);
this->keyingtry++;
}
METHOD(ike_sa_t, set_auth_lifetime, status_t,
- private_ike_sa_t *this, u_int32_t lifetime)
+ private_ike_sa_t *this, uint32_t lifetime)
{
- u_int32_t diff, hard, soft, now;
+ uint32_t diff, hard, soft, now;
bool send_update;
diff = this->peer_cfg->get_over_time(this->peer_cfg);
*
* @return unique ID
*/
- u_int32_t (*get_unique_id) (ike_sa_t *this);
+ uint32_t (*get_unique_id) (ike_sa_t *this);
/**
* Get the state of the IKE_SA.
* @param kind kind of requested value
* @return value as integer
*/
- u_int32_t (*get_statistic)(ike_sa_t *this, statistic_t kind);
+ uint32_t (*get_statistic)(ike_sa_t *this, statistic_t kind);
/**
* Set statistic value of the IKE_SA.
* @param kind kind of value to update
* @param value value as integer
*/
- void (*set_statistic)(ike_sa_t *this, statistic_t kind, u_int32_t value);
+ void (*set_statistic)(ike_sa_t *this, statistic_t kind, uint32_t value);
/**
* Get the own host address.
* @param initiate TRUE to set message ID for initiating
* @param mid message id to set
*/
- void (*set_message_id)(ike_sa_t *this, bool initiate, u_int32_t mid);
+ void (*set_message_id)(ike_sa_t *this, bool initiate, uint32_t mid);
/**
* Add an additional address for the peer.
*
* @return number of pending updates
*/
- u_int32_t (*get_pending_updates)(ike_sa_t *this);
+ uint32_t (*get_pending_updates)(ike_sa_t *this);
/**
* Set the number of queued MOBIKE address updates.
*
* @param updates number of pending updates
*/
- void (*set_pending_updates)(ike_sa_t *this, u_int32_t updates);
+ void (*set_pending_updates)(ike_sa_t *this, uint32_t updates);
#ifdef ME
/**
* - DESTROY_ME if initialization failed
*/
status_t (*initiate) (ike_sa_t *this, child_cfg_t *child_cfg,
- u_int32_t reqid, traffic_selector_t *tsi,
+ uint32_t reqid, traffic_selector_t *tsi,
traffic_selector_t *tsr);
/**
* - SUCCESS
* - NOT_FOUND if request doesn't have to be retransmited
*/
- status_t (*retransmit) (ike_sa_t *this, u_int32_t message_id);
+ status_t (*retransmit) (ike_sa_t *this, uint32_t message_id);
/**
* Sends a DPD request to the peer.
* @return child_sa, or NULL if none found
*/
child_sa_t* (*get_child_sa) (ike_sa_t *this, protocol_id_t protocol,
- u_int32_t spi, bool inbound);
+ uint32_t spi, bool inbound);
/**
* Get the number of CHILD_SAs.
* - NOT_FOUND, if IKE_SA has no such CHILD_SA
* - SUCCESS, if rekeying initiated
*/
- status_t (*rekey_child_sa) (ike_sa_t *this, protocol_id_t protocol, u_int32_t spi);
+ status_t (*rekey_child_sa) (ike_sa_t *this, protocol_id_t protocol, uint32_t spi);
/**
* Close the CHILD SA with the specified protocol/SPI.
* - SUCCESS, if delete message sent
*/
status_t (*delete_child_sa)(ike_sa_t *this, protocol_id_t protocol,
- u_int32_t spi, bool expired);
+ uint32_t spi, bool expired);
/**
* Destroy a CHILD SA with the specified protocol/SPI.
* - NOT_FOUND, if IKE_SA has no such CHILD_SA
* - SUCCESS
*/
- status_t (*destroy_child_sa) (ike_sa_t *this, protocol_id_t protocol, u_int32_t spi);
+ status_t (*destroy_child_sa) (ike_sa_t *this, protocol_id_t protocol, uint32_t spi);
/**
* Rekey the IKE_SA.
* @param lifetime lifetime in seconds
* @return DESTROY_ME to destroy the IKE_SA
*/
- status_t (*set_auth_lifetime)(ike_sa_t *this, u_int32_t lifetime);
+ status_t (*set_auth_lifetime)(ike_sa_t *this, uint32_t lifetime);
/**
* Add a virtual IP to use for this IKE_SA and its children.
/**
* Major IKE version of IKE_SA.
*/
- u_int8_t ike_version;
+ uint8_t ike_version;
/**
* SPI of initiator.
*/
- u_int64_t initiator_spi;
+ uint64_t initiator_spi;
/**
* SPI of responder.
*/
- u_int64_t responder_spi;
+ uint64_t responder_spi;
/**
* Role for specific IKE_SA.
bool is_initiator_flag;
};
-METHOD(ike_sa_id_t, get_ike_version, u_int8_t,
+METHOD(ike_sa_id_t, get_ike_version, uint8_t,
private_ike_sa_id_t *this)
{
return this->ike_version;
}
METHOD(ike_sa_id_t, set_responder_spi, void,
- private_ike_sa_id_t *this, u_int64_t responder_spi)
+ private_ike_sa_id_t *this, uint64_t responder_spi)
{
this->responder_spi = responder_spi;
}
METHOD(ike_sa_id_t, set_initiator_spi, void,
- private_ike_sa_id_t *this, u_int64_t initiator_spi)
+ private_ike_sa_id_t *this, uint64_t initiator_spi)
{
this->initiator_spi = initiator_spi;
}
-METHOD(ike_sa_id_t, get_initiator_spi, u_int64_t,
+METHOD(ike_sa_id_t, get_initiator_spi, uint64_t,
private_ike_sa_id_t *this)
{
return this->initiator_spi;
}
-METHOD(ike_sa_id_t, get_responder_spi, u_int64_t,
+METHOD(ike_sa_id_t, get_responder_spi, uint64_t,
private_ike_sa_id_t *this)
{
return this->responder_spi;
/*
* Described in header.
*/
-ike_sa_id_t * ike_sa_id_create(u_int8_t ike_version, u_int64_t initiator_spi,
- u_int64_t responder_spi, bool is_initiator_flag)
+ike_sa_id_t * ike_sa_id_create(uint8_t ike_version, uint64_t initiator_spi,
+ uint64_t responder_spi, bool is_initiator_flag)
{
private_ike_sa_id_t *this;
*
* @return IKE version
*/
- u_int8_t (*get_ike_version) (ike_sa_id_t *this);
+ uint8_t (*get_ike_version) (ike_sa_id_t *this);
/**
* Set the SPI of the responder.
*
* @param responder_spi SPI of responder to set
*/
- void (*set_responder_spi) (ike_sa_id_t *this, u_int64_t responder_spi);
+ void (*set_responder_spi) (ike_sa_id_t *this, uint64_t responder_spi);
/**
* Set the SPI of the initiator.
*
* @param initiator_spi SPI to set
*/
- void (*set_initiator_spi) (ike_sa_id_t *this, u_int64_t initiator_spi);
+ void (*set_initiator_spi) (ike_sa_id_t *this, uint64_t initiator_spi);
/**
* Get the initiator SPI.
*
* @return SPI of the initiator
*/
- u_int64_t (*get_initiator_spi) (ike_sa_id_t *this);
+ uint64_t (*get_initiator_spi) (ike_sa_id_t *this);
/**
* Get the responder SPI.
*
* @return SPI of the responder
*/
- u_int64_t (*get_responder_spi) (ike_sa_id_t *this);
+ uint64_t (*get_responder_spi) (ike_sa_id_t *this);
/**
* Check if two ike_sa_id_t objects are equal.
* @param is_initiaor TRUE if we are the original initiator
* @return ike_sa_id_t object
*/
-ike_sa_id_t * ike_sa_id_create(u_int8_t ike_version, u_int64_t initiator_spi,
- u_int64_t responder_spi, bool is_initiaor);
+ike_sa_id_t * ike_sa_id_create(uint8_t ike_version, uint64_t initiator_spi,
+ uint64_t responder_spi, bool is_initiaor);
#endif /** IKE_SA_ID_H_ @}*/
/**
* message ID or hash of currently processing message, -1 if none
*/
- u_int32_t processing;
+ uint32_t processing;
};
/**
chunk_t hash;
/** our SPI allocated for the IKE_SA based on this message */
- u_int64_t our_spi;
+ uint64_t our_spi;
};
typedef struct segment_t segment_t;
/**
* Get a random SPI for new IKE_SAs
*/
-static u_int64_t get_spi(private_ike_sa_manager_t *this)
+static uint64_t get_spi(private_ike_sa_manager_t *this)
{
- u_int64_t spi;
+ uint64_t spi;
this->spi_lock->read_lock(this->spi_lock);
if (this->spi_cb.cb)
spi = this->spi_cb.cb(this->spi_cb.data);
}
else if (!this->rng ||
- !this->rng->get_bytes(this->rng, sizeof(spi), (u_int8_t*)&spi))
+ !this->rng->get_bytes(this->rng, sizeof(spi), (uint8_t*)&spi))
{
spi = 0;
}
if (message->get_first_payload_type(message) == PLV1_FRAGMENT)
{ /* only hash the source IP, port and SPI for fragmented init messages */
- u_int16_t port;
- u_int64_t spi;
+ uint16_t port;
+ uint64_t spi;
src = message->get_source(message);
if (!hasher->allocate_hash(hasher, src->get_address(src), NULL))
* FAILED if the SPI allocation failed
*/
static status_t check_and_put_init_hash(private_ike_sa_manager_t *this,
- chunk_t init_hash, u_int64_t *our_spi)
+ chunk_t init_hash, uint64_t *our_spi)
{
table_item_t *item;
u_int row, segment;
mutex_t *mutex;
init_hash_t *init;
- u_int64_t spi;
+ uint64_t spi;
row = chunk_hash(init_hash) & this->table_mask;
segment = row & this->segment_mask;
{
ike_sa_id_t *ike_sa_id;
ike_sa_t *ike_sa;
- u_int8_t ike_version;
- u_int64_t spi;
+ uint8_t ike_version;
+ uint64_t spi;
ike_version = version == IKEV1 ? IKEV1_MAJOR_VERSION : IKEV2_MAJOR_VERSION;
/**
* Get the message ID or message hash to detect early retransmissions
*/
-static u_int32_t get_message_id_or_hash(message_t *message)
+static uint32_t get_message_id_or_hash(message_t *message)
{
if (message->get_major_version(message) == IKEV1_MAJOR_VERSION)
{
if (is_init)
{
hasher_t *hasher;
- u_int64_t our_spi;
+ uint64_t our_spi;
chunk_t hash;
hasher = lib->crypto->create_hasher(lib->crypto, HASH_SHA1);
}
METHOD(ike_sa_manager_t, checkout_by_id, ike_sa_t*,
- private_ike_sa_manager_t *this, u_int32_t id)
+ private_ike_sa_manager_t *this, uint32_t id)
{
enumerator_t *enumerator;
entry_t *entry;
* @param data data supplied during registration of the callback
* @return allocated SPI, 0 on failure
*/
-typedef u_int64_t (*spi_cb_t)(void *data);
+typedef uint64_t (*spi_cb_t)(void *data);
/**
* Manages and synchronizes access to all IKE_SAs.
* - checked out IKE_SA, if found
* - NULL, if not found
*/
- ike_sa_t* (*checkout_by_id) (ike_sa_manager_t* this, u_int32_t id);
+ ike_sa_t* (*checkout_by_id) (ike_sa_manager_t* this, uint32_t id);
/**
* Check out an IKE_SA by the policy/connection name.
*/
typedef struct {
/** message ID */
- u_int32_t mid;
+ uint32_t mid;
/** current IV */
chunk_t iv;
/** last block of encrypted message */
*/
typedef struct {
/** message ID */
- u_int32_t mid;
+ uint32_t mid;
/** Ni_b (Nonce from first message) */
chunk_t n_i;
/** Nr_b (Nonce from second message) */
static aead_t *create_aead(proposal_t *proposal, prf_t *prf, chunk_t skeyid_e)
{
private_aead_t *this;
- u_int16_t alg, key_size;
+ uint16_t alg, key_size;
crypter_t *crypter;
chunk_t ka;
/**
* Converts integrity algorithm to PRF algorithm
*/
-static u_int16_t auth_to_prf(u_int16_t alg)
+static uint16_t auth_to_prf(uint16_t alg)
{
switch (alg)
{
/**
* Converts integrity algorithm to hash algorithm
*/
-static u_int16_t auth_to_hash(u_int16_t alg)
+static uint16_t auth_to_hash(uint16_t alg)
{
switch (alg)
{
/**
* Adjust the key length for PRF algorithms that expect a fixed key length.
*/
-static void adjust_keylen(u_int16_t alg, chunk_t *key)
+static void adjust_keylen(uint16_t alg, chunk_t *key)
{
switch (alg)
{
{
chunk_t g_xy, g_xi, g_xr, dh_me, spi_i, spi_r, nonces, data, skeyid_e;
chunk_t skeyid;
- u_int16_t alg;
+ uint16_t alg;
- spi_i = chunk_alloca(sizeof(u_int64_t));
- spi_r = chunk_alloca(sizeof(u_int64_t));
+ spi_i = chunk_alloca(sizeof(uint64_t));
+ spi_r = chunk_alloca(sizeof(uint64_t));
if (!proposal->get_algorithm(proposal, PSEUDO_RANDOM_FUNCTION, &alg, NULL))
{ /* no PRF negotiated, use HMAC version of integrity algorithm instead */
}
DBG4(DBG_IKE, "shared Diffie Hellman secret %B", &g_xy);
- *((u_int64_t*)spi_i.ptr) = id->get_initiator_spi(id);
- *((u_int64_t*)spi_r.ptr) = id->get_responder_spi(id);
+ *((uint64_t*)spi_i.ptr) = id->get_initiator_spi(id);
+ *((uint64_t*)spi_r.ptr) = id->get_responder_spi(id);
nonces = chunk_cata("cc", nonce_i, nonce_r);
switch (auth)
METHOD(keymat_v1_t, derive_child_keys, bool,
private_keymat_v1_t *this, proposal_t *proposal, diffie_hellman_t *dh,
- u_int32_t spi_i, u_int32_t spi_r, chunk_t nonce_i, chunk_t nonce_r,
+ uint32_t spi_i, uint32_t spi_r, chunk_t nonce_i, chunk_t nonce_r,
chunk_t *encr_i, chunk_t *integ_i, chunk_t *encr_r, chunk_t *integ_r)
{
- u_int16_t enc_alg, int_alg, enc_size = 0, int_size = 0;
- u_int8_t protocol;
+ uint16_t enc_alg, int_alg, enc_size = 0, int_size = 0;
+ uint8_t protocol;
prf_plus_t *prf_plus;
chunk_t seed, secret = chunk_empty;
bool success = FALSE;
METHOD(keymat_v1_t, create_hasher, bool,
private_keymat_v1_t *this, proposal_t *proposal)
{
- u_int16_t alg;
+ uint16_t alg;
if (!proposal->get_algorithm(proposal, INTEGRITY_ALGORITHM, &alg, NULL) ||
(alg = auth_to_hash(alg)) == HASH_UNKNOWN)
{
ike_sa_id_t *ike_sa_id, chunk_t sa_i, chunk_t id, chunk_t *hash)
{
chunk_t data;
- u_int64_t spi, spi_other;
+ uint64_t spi, spi_other;
/* HASH_I = prf(SKEYID, g^xi | g^xr | CKY-I | CKY-R | SAi_b | IDii_b )
* HASH_R = prf(SKEYID, g^xr | g^xi | CKY-R | CKY-I | SAi_b | IDir_b )
{
payload_t *payload, *next;
enumerator_t *enumerator;
- u_int32_t *lenpos;
+ uint32_t *lenpos;
if (message->is_encoded(message))
{ /* inbound, although the message is generated, we cannot access the
* Try to find data about a Quick Mode with the given message ID,
* if none is found, state is generated.
*/
-static qm_data_t *lookup_quick_mode(private_keymat_v1_t *this, u_int32_t mid)
+static qm_data_t *lookup_quick_mode(private_keymat_v1_t *this, uint32_t mid)
{
enumerator_t *enumerator;
qm_data_t *qm, *found = NULL;
METHOD(keymat_v1_t, get_hash_phase2, bool,
private_keymat_v1_t *this, message_t *message, chunk_t *hash)
{
- u_int32_t mid, mid_n;
+ uint32_t mid, mid_n;
chunk_t data = chunk_empty;
bool add_message = TRUE;
char *name = "Hash";
else
{
/* initial phase 2 IV = hash(last_phase1_block | mid) */
- u_int32_t net;;
+ uint32_t net;;
chunk_t data;
net = htonl(iv->mid);
/**
* Try to find an IV for the given message ID, if not found, generate it.
*/
-static iv_data_t *lookup_iv(private_keymat_v1_t *this, u_int32_t mid)
+static iv_data_t *lookup_iv(private_keymat_v1_t *this, uint32_t mid)
{
enumerator_t *enumerator;
iv_data_t *iv, *found = NULL;
}
METHOD(keymat_v1_t, get_iv, bool,
- private_keymat_v1_t *this, u_int32_t mid, chunk_t *out)
+ private_keymat_v1_t *this, uint32_t mid, chunk_t *out)
{
iv_data_t *iv;
}
METHOD(keymat_v1_t, update_iv, bool,
- private_keymat_v1_t *this, u_int32_t mid, chunk_t last_block)
+ private_keymat_v1_t *this, uint32_t mid, chunk_t last_block)
{
iv_data_t *iv = lookup_iv(this, mid);
if (iv)
}
METHOD(keymat_v1_t, confirm_iv, bool,
- private_keymat_v1_t *this, u_int32_t mid)
+ private_keymat_v1_t *this, uint32_t mid)
{
iv_data_t *iv = lookup_iv(this, mid);
if (iv)
* @param integ_r allocated responders integrity key
*/
bool (*derive_child_keys)(keymat_v1_t *this, proposal_t *proposal,
- diffie_hellman_t *dh, u_int32_t spi_i, u_int32_t spi_r,
+ diffie_hellman_t *dh, uint32_t spi_i, uint32_t spi_r,
chunk_t nonce_i, chunk_t nonce_r,
chunk_t *encr_i, chunk_t *integ_i,
chunk_t *encr_r, chunk_t *integ_r);
* @param iv chunk receiving IV, internal data
* @return TRUE if IV allocated successfully
*/
- bool (*get_iv)(keymat_v1_t *this, u_int32_t mid, chunk_t *iv);
+ bool (*get_iv)(keymat_v1_t *this, uint32_t mid, chunk_t *iv);
/**
* Updates the IV for the next message with the given message ID.
* @param last_block last block of encrypted message (gets cloned)
* @return TRUE if IV updated successfully
*/
- bool (*update_iv)(keymat_v1_t *this, u_int32_t mid, chunk_t last_block);
+ bool (*update_iv)(keymat_v1_t *this, uint32_t mid, chunk_t last_block);
/**
* Confirms the updated IV for the given message ID.
* @param mid message ID
* @return TRUE if IV confirmed successfully
*/
- bool (*confirm_iv)(keymat_v1_t *this, u_int32_t mid);
+ bool (*confirm_iv)(keymat_v1_t *this, uint32_t mid);
};
/**
/**
* Message ID used for this transaction
*/
- u_int32_t mid;
+ uint32_t mid;
/**
* generated packet for retransmission
/**
* Message ID of the last response
*/
- u_int32_t mid;
+ uint32_t mid;
/**
* Hash of a previously received message
*/
- u_int32_t hash;
+ uint32_t hash;
/**
* packet(s) for retransmission
/**
* Sequence number of the last sent message
*/
- u_int32_t seqnr;
+ uint32_t seqnr;
/**
* how many times we have retransmitted so far
/**
* Message ID of the exchange
*/
- u_int32_t mid;
+ uint32_t mid;
/**
* Hashes of old responses we can ignore
*/
- u_int32_t old_hashes[MAX_OLD_HASHES];
+ uint32_t old_hashes[MAX_OLD_HASHES];
/**
* Position in old hash array
/**
* Sequence number of the last sent message
*/
- u_int32_t seqnr;
+ uint32_t seqnr;
/**
* how many times we have retransmitted so far
/**
* Sequence number for sending DPD requests
*/
- u_int32_t dpd_send;
+ uint32_t dpd_send;
/**
* Sequence number for received DPD requests
*/
- u_int32_t dpd_recv;
+ uint32_t dpd_recv;
};
/**
/**
* Retransmit a packet (or its fragments)
*/
-static status_t retransmit_packet(private_task_manager_t *this, u_int32_t seqnr,
+static status_t retransmit_packet(private_task_manager_t *this, uint32_t seqnr,
u_int mid, u_int retransmitted, array_t *packets)
{
packet_t *packet;
- u_int32_t t;
+ uint32_t t;
array_get(packets, 0, &packet);
if (retransmitted > this->retransmit_tries)
charon->bus->alert(charon->bus, ALERT_RETRANSMIT_SEND_TIMEOUT, packet);
return DESTROY_ME;
}
- t = (u_int32_t)(this->retransmit_timeout * 1000.0 *
+ t = (uint32_t)(this->retransmit_timeout * 1000.0 *
pow(this->retransmit_base, retransmitted));
if (retransmitted)
{
}
METHOD(task_manager_t, retransmit, status_t,
- private_task_manager_t *this, u_int32_t seqnr)
+ private_task_manager_t *this, uint32_t seqnr)
{
status_t status = SUCCESS;
message_t *response;
array_t *packets = NULL;
host_t *me, *other;
- u_int32_t mid;
+ uint32_t mid;
if (request->get_exchange_type(request) == INFORMATIONAL_V1)
{ /* don't respond to INFORMATIONAL requests to avoid a notify war */
{
notify_payload_t *notify;
notify_type_t type;
- u_int32_t seq;
+ uint32_t seq;
chunk_t data;
type = DPD_R_U_THERE;
* Check if we already have a quick mode task queued for the exchange with the
* given message ID
*/
-static bool have_quick_mode_task(private_task_manager_t *this, u_int32_t mid)
+static bool have_quick_mode_task(private_task_manager_t *this, uint32_t mid)
{
enumerator_t *enumerator;
quick_mode_t *qm;
METHOD(task_manager_t, process_message, status_t,
private_task_manager_t *this, message_t *msg)
{
- u_int32_t hash, mid, i;
+ uint32_t hash, mid, i;
host_t *me, *other;
status_t status;
}
METHOD(task_manager_t, queue_child, void,
- private_task_manager_t *this, child_cfg_t *cfg, u_int32_t reqid,
+ private_task_manager_t *this, child_cfg_t *cfg, uint32_t reqid,
traffic_selector_t *tsi, traffic_selector_t *tsr)
{
quick_mode_t *task;
}
METHOD(task_manager_t, queue_child_rekey, void,
- private_task_manager_t *this, protocol_id_t protocol, u_int32_t spi)
+ private_task_manager_t *this, protocol_id_t protocol, uint32_t spi)
{
child_sa_t *child_sa;
child_cfg_t *cfg;
}
METHOD(task_manager_t, queue_child_delete, void,
- private_task_manager_t *this, protocol_id_t protocol, u_int32_t spi,
+ private_task_manager_t *this, protocol_id_t protocol, uint32_t spi,
bool expired)
{
queue_task(this, (task_t*)quick_delete_create(this->ike_sa, protocol,
private_task_manager_t *this)
{
peer_cfg_t *peer_cfg;
- u_int32_t t, retransmit;
+ uint32_t t, retransmit;
queue_task(this, (task_t*)isakmp_dpd_create(this->ike_sa, DPD_R_U_THERE,
this->dpd_send++));
/* use the same timeout as a retransmitting IKE message would have */
for (retransmit = 0; retransmit <= this->retransmit_tries; retransmit++)
{
- t += (u_int32_t)(this->retransmit_timeout * 1000.0 *
+ t += (uint32_t)(this->retransmit_timeout * 1000.0 *
pow(this->retransmit_base, retransmit));
}
}
}
METHOD(task_manager_t, reset, void,
- private_task_manager_t *this, u_int32_t initiate, u_int32_t respond)
+ private_task_manager_t *this, uint32_t initiate, uint32_t respond)
{
enumerator_t *enumerator;
task_t *task;
/**
* Negotiated SA lifetime
*/
- u_int32_t lifetime;
+ uint32_t lifetime;
/**
* Negotiated authentication method
{
notify_payload_t *notify;
ike_sa_id_t *ike_sa_id;
- u_int64_t spi_i, spi_r;
+ uint64_t spi_i, spi_r;
chunk_t spi;
notify = notify_payload_create_from_protocol_and_type(PLV1_NOTIFY,
linked_list_t *proposals;
identification_t *id;
packet_t *packet;
- u_int16_t group;
+ uint16_t group;
DBG0(DBG_IKE, "initiating Aggressive Mode IKE_SA %s[%d] to %H",
this->ike_sa->get_name(this->ike_sa),
id_payload_t *id_payload;
identification_t *id;
linked_list_t *list;
- u_int16_t group;
+ uint16_t group;
this->ike_cfg = this->ike_sa->get_ike_cfg(this->ike_sa);
DBG0(DBG_IKE, "%H is initiating a Aggressive Mode IKE_SA",
id_payload_t *id_payload;
identification_t *id, *cid;
linked_list_t *list;
- u_int32_t lifetime;
+ uint32_t lifetime;
sa_payload = (sa_payload_t*)message->get_payload(message,
PLV1_SECURITY_ASSOCIATION);
payload_t *payload;
delete_payload_t *delete_payload;
ike_sa_id_t *id;
- u_int64_t spi_i, spi_r;
+ uint64_t spi_i, spi_r;
bool found = FALSE;
/* some peers send DELETE payloads for other IKE_SAs, e.g. those for expired
/**
* Sequence number.
*/
- u_int32_t seqnr;
+ uint32_t seqnr;
/**
* DPD notify type
{
notify_payload_t *notify;
ike_sa_id_t *ike_sa_id;
- u_int64_t spi_i, spi_r;
- u_int32_t seqnr;
+ uint64_t spi_i, spi_r;
+ uint32_t seqnr;
chunk_t spi;
notify = notify_payload_create_from_protocol_and_type(PLV1_NOTIFY,
* Described in header.
*/
isakmp_dpd_t *isakmp_dpd_create(ike_sa_t *ike_sa, notify_type_t type,
- u_int32_t seqnr)
+ uint32_t seqnr)
{
private_isakmp_dpd_t *this;
* @return ISAKMP_DPD task to handle by the task_manager
*/
isakmp_dpd_t *isakmp_dpd_create(ike_sa_t *ike_sa, notify_type_t type,
- u_int32_t seqnr);
+ uint32_t seqnr);
#endif /** ISAKMP_DPD_H_ @}*/
{
hasher_t *hasher;
chunk_t natd_chunk, natd_hash;
- u_int64_t spi_i, spi_r;
- u_int16_t port;
+ uint64_t spi_i, spi_r;
+ uint16_t port;
hasher = this->keymat->get_hasher(this->keymat);
if (!hasher)
* for fragmentation of base ISAKMP messages (Cisco adds that and thus sends
* 0xc0000000)
*/
-static const u_int32_t fragmentation_ike = 0x80000000;
+static const uint32_t fragmentation_ike = 0x80000000;
static bool is_known_vid(chunk_t data, int i)
{
/**
* Negotiated SA lifetime
*/
- u_int32_t lifetime;
+ uint32_t lifetime;
/**
* Negotiated authentication method
{
notify_payload_t *notify;
ike_sa_id_t *ike_sa_id;
- u_int64_t spi_i, spi_r;
+ uint64_t spi_i, spi_r;
chunk_t spi;
notify = notify_payload_create_from_protocol_and_type(PLV1_NOTIFY,
host_t *host;
notify_payload_t *notify;
ike_sa_id_t *ike_sa_id;
- u_int64_t spi_i, spi_r;
+ uint64_t spi_i, spi_r;
chunk_t spi;
idr = this->ph1->get_id(this->ph1, this->peer_cfg, FALSE);
}
case MM_SA:
{
- u_int16_t group;
+ uint16_t group;
if (!this->ph1->create_hasher(this->ph1))
{
}
case MM_SA:
{
- u_int16_t group;
+ uint16_t group;
if (!this->ph1->create_hasher(this->ph1))
{
linked_list_t *list;
sa_payload_t *sa_payload;
auth_method_t method;
- u_int32_t lifetime;
+ uint32_t lifetime;
bool private;
sa_payload = (sa_payload_t*)message->get_payload(message,
/**
* Identifier to include in response
*/
- u_int16_t identifier;
+ uint16_t identifier;
};
/**
/**
* Inbound SPI of CHILD_SA to delete
*/
- u_int32_t spi;
+ uint32_t spi;
/**
* Send delete even if SA does not exist
* Delete the specified CHILD_SA, if found
*/
static bool delete_child(private_quick_delete_t *this, protocol_id_t protocol,
- u_int32_t spi, bool remote_close)
+ uint32_t spi, bool remote_close)
{
- u_int64_t bytes_in, bytes_out;
+ uint64_t bytes_in, bytes_out;
child_sa_t *child_sa;
linked_list_t *my_ts, *other_ts;
child_cfg_t *child_cfg;
payload_t *payload;
delete_payload_t *delete_payload;
protocol_id_t protocol;
- u_int32_t spi;
+ uint32_t spi;
payloads = message->create_payload_enumerator(message);
while (payloads->enumerate(payloads, &payload))
* Described in header.
*/
quick_delete_t *quick_delete_create(ike_sa_t *ike_sa, protocol_id_t protocol,
- u_int32_t spi, bool force, bool expired)
+ uint32_t spi, bool force, bool expired)
{
private_quick_delete_t *this;
* @return quick_delete task to handle by the task_manager
*/
quick_delete_t *quick_delete_create(ike_sa_t *ike_sa, protocol_id_t protocol,
- u_int32_t spi, bool force, bool expired);
+ uint32_t spi, bool force, bool expired);
#endif /** QUICK_DELETE_H_ @}*/
/**
* Initiators ESP SPI
*/
- u_int32_t spi_i;
+ uint32_t spi_i;
/**
* Responder ESP SPI
*/
- u_int32_t spi_r;
+ uint32_t spi_r;
/**
* Initiators IPComp CPI
*/
- u_int16_t cpi_i;
+ uint16_t cpi_i;
/**
* Responders IPComp CPI
*/
- u_int16_t cpi_r;
+ uint16_t cpi_r;
/**
* selected CHILD_SA proposal
/**
* Negotiated lifetime of new SA
*/
- u_int32_t lifetime;
+ uint32_t lifetime;
/**
* Negotaited lifebytes of new SA
*/
- u_int64_t lifebytes;
+ uint64_t lifebytes;
/**
* Reqid to use, 0 for auto-allocate
*/
- u_int32_t reqid;
+ uint32_t reqid;
/**
* Explicit inbound mark value to use, if any
/**
* SPI of SA we rekey
*/
- u_int32_t rekey;
+ uint32_t rekey;
/**
* Delete old child after successful rekey
/**
* Message ID of handled quick mode exchange
*/
- u_int32_t mid;
+ uint32_t mid;
/** states of quick mode */
enum {
*/
static void schedule_inactivity_timeout(private_quick_mode_t *this)
{
- u_int32_t timeout;
+ uint32_t timeout;
bool close_ike;
timeout = this->config->get_inactivity(this->config);
*/
static void apply_lifetimes(private_quick_mode_t *this, sa_payload_t *sa_payload)
{
- u_int32_t lifetime;
- u_int64_t lifebytes;
+ uint32_t lifetime;
+ uint64_t lifebytes;
lifetime = sa_payload->get_lifetime(sa_payload);
lifebytes = sa_payload->get_lifebytes(sa_payload);
if (group != MODP_NONE)
{
proposal_t *proposal;
- u_int16_t preferred_group;
+ uint16_t preferred_group;
proposal = this->ike_sa->get_proposal(this->ike_sa);
proposal->get_algorithm(proposal, DIFFIE_HELLMAN_GROUP,
sa_payload_t *sa_payload;
linked_list_t *tsi, *tsr, *hostsi, *hostsr, *list = NULL;
peer_cfg_t *peer_cfg;
- u_int16_t group;
+ uint16_t group;
bool private;
sa_payload = (sa_payload_t*)message->get_payload(message,
return TASK_QUICK_MODE;
}
-METHOD(quick_mode_t, get_mid, u_int32_t,
+METHOD(quick_mode_t, get_mid, uint32_t,
private_quick_mode_t *this)
{
return this->mid;
}
METHOD(quick_mode_t, use_reqid, void,
- private_quick_mode_t *this, u_int32_t reqid)
+ private_quick_mode_t *this, uint32_t reqid)
{
this->reqid = reqid;
}
}
METHOD(quick_mode_t, rekey, void,
- private_quick_mode_t *this, u_int32_t spi)
+ private_quick_mode_t *this, uint32_t spi)
{
this->rekey = spi;
}
*
* @return message ID, or 0 (not defined yet or as initiator)
*/
- u_int32_t (*get_mid)(quick_mode_t *this);
+ uint32_t (*get_mid)(quick_mode_t *this);
/**
* Use a specific reqid to install this CHILD_SA.
*
* @param reqid reqid to use
*/
- void (*use_reqid)(quick_mode_t *this, u_int32_t reqid);
+ void (*use_reqid)(quick_mode_t *this, uint32_t reqid);
/**
* Use specific mark values, overriding configuration.
*
* @param spi spi of SA to rekey
*/
- void (*rekey)(quick_mode_t *this, u_int32_t spi);
+ void (*rekey)(quick_mode_t *this, uint32_t spi);
};
/**
/**
* received identifier
*/
- u_int16_t identifier;
+ uint16_t identifier;
/**
* status of Xauth exchange
* load an EAP method
*/
static eap_method_t *load_method(private_eap_authenticator_t *this,
- eap_type_t type, u_int32_t vendor, eap_role_t role)
+ eap_type_t type, uint32_t vendor, eap_role_t role)
{
identification_t *server, *peer, *aaa;
auth_cfg_t *auth;
auth_cfg_t *auth;
eap_type_t type;
identification_t *id;
- u_int32_t vendor;
+ uint32_t vendor;
eap_payload_t *out;
char *action;
eap_payload_t *in)
{
eap_type_t type, received_type, conf_type;
- u_int32_t vendor, received_vendor, conf_vendor;
+ uint32_t vendor, received_vendor, conf_vendor;
eap_payload_t *out;
auth_cfg_t *auth;
eap_payload_t *in)
{
eap_type_t type, conf_type;
- u_int32_t vendor, conf_vendor;
+ uint32_t vendor, conf_vendor;
auth_cfg_t *auth;
eap_payload_t *out;
identification_t *id;
auth_cfg_t *auth;
keymat_v2_t *keymat;
eap_type_t type;
- u_int32_t vendor;
+ uint32_t vendor;
auth_payload = (auth_payload_t*)message->get_payload(message,
PLV2_AUTH);
}
if (this->require_mutual && !this->method->is_mutual(this->method))
{ /* we require mutual authentication due to EAP-only */
- u_int32_t vendor;
+ uint32_t vendor;
DBG1(DBG_IKE, "EAP-only authentication requires a mutual and "
"MSK deriving EAP method, but %N is not",
case EAP_SUCCESS:
{
eap_type_t type;
- u_int32_t vendor;
+ uint32_t vendor;
auth_cfg_t *cfg;
if (this->method->get_msk(this->method, &this->msk) == SUCCESS)
{
if (this->method)
{
- u_int32_t vendor;
+ uint32_t vendor;
if (this->method->get_type(this->method, &vendor) != EAP_IDENTITY ||
vendor != 0)
static bool parse_signature_auth_data(chunk_t *auth_data, key_type_t *key_type,
signature_scheme_t *scheme)
{
- u_int8_t len;
+ uint8_t len;
int oid;
if (!auth_data->len)
signature_scheme_t scheme)
{
chunk_t data;
- u_int8_t len;
+ uint8_t len;
int oid;
oid = signature_scheme_to_oid(scheme);
*/
struct endpoint_pair_t {
/** pair id */
- u_int32_t id;
+ uint32_t id;
/** priority */
- u_int64_t priority;
+ uint64_t priority;
/** local endpoint */
host_t *local;
check_state_t state;
/** number of retransmissions */
- u_int32_t retransmitted;
+ uint32_t retransmitted;
/** the generated packet */
packet_t *packet;
{
endpoint_pair_t *this;
- u_int32_t pi = initiator->get_priority(initiator);
- u_int32_t pr = responder->get_priority(responder);
+ uint32_t pi = initiator->get_priority(initiator);
+ uint32_t pr = responder->get_priority(responder);
INIT(this,
.priority = pow(2, 32) * min(pi, pr) + 2 * max(pi, pr)
*/
struct check_t {
/** message id */
- u_int32_t mid;
+ uint32_t mid;
/** source of the connectivity check */
host_t *src;
chunk_t connect_id;
/** message (pair) id */
- u_int32_t mid;
+ uint32_t mid;
};
/**
* Creates a new retransmission data object
*/
static callback_data_t *retransmit_data_create(private_connect_manager_t *connect_manager,
- chunk_t connect_id, u_int32_t mid)
+ chunk_t connect_id, uint32_t mid)
{
callback_data_t *this = callback_data_create(connect_manager, connect_id);
this->mid = mid;
(void**)pair, local, remote);
}
-static bool match_pair_by_id(endpoint_pair_t *current, u_int32_t *id)
+static bool match_pair_by_id(endpoint_pair_t *current, uint32_t *id)
{
return current->id == *id;
}
/**
* Searches for a pair with a specific id
*/
-static status_t get_pair_by_id(check_list_t *checklist, u_int32_t id,
+static status_t get_pair_by_id(check_list_t *checklist, uint32_t id,
endpoint_pair_t **pair)
{
return checklist->pairs->find_first(checklist->pairs,
{
enumerator_t *enumerator, *search;
endpoint_pair_t *current, *other;
- u_int32_t id = 0;
+ uint32_t id = 0;
enumerator = pairs->create_enumerator(pairs);
search = pairs->create_enumerator(pairs);
static chunk_t build_signature(private_connect_manager_t *this,
check_list_t *checklist, check_t *check, bool outbound)
{
- u_int32_t mid;
+ uint32_t mid;
chunk_t mid_chunk, key_chunk, sig_chunk;
chunk_t sig_hash;
}
static void queue_retransmission(private_connect_manager_t *this, check_list_t *checklist, endpoint_pair_t *pair);
-static void schedule_checks(private_connect_manager_t *this, check_list_t *checklist, u_int32_t time);
+static void schedule_checks(private_connect_manager_t *this, check_list_t *checklist, uint32_t time);
static void finish_checks(private_connect_manager_t *this, check_list_t *checklist);
/**
job = (job_t*)callback_job_create((callback_job_cb_t)retransmit, data,
(callback_job_cleanup_t)callback_data_destroy, NULL);
- u_int32_t retransmission = pair->retransmitted + 1;
- u_int32_t rto = ME_INTERVAL;
+ uint32_t retransmission = pair->retransmitted + 1;
+ uint32_t rto = ME_INTERVAL;
if (retransmission > ME_BOOST)
{
- rto = (u_int32_t)(ME_INTERVAL * pow(ME_RETRANS_BASE, retransmission - ME_BOOST));
+ rto = (uint32_t)(ME_INTERVAL * pow(ME_RETRANS_BASE, retransmission - ME_BOOST));
}
DBG2(DBG_IKE, "scheduling retransmission %d of pair '%d' in %dms",
retransmission, pair->id, rto);
* Schedules checks for a checklist (time in ms)
*/
static void schedule_checks(private_connect_manager_t *this,
- check_list_t *checklist, u_int32_t time)
+ check_list_t *checklist, uint32_t time)
{
callback_data_t *data = callback_data_create(this, checklist->connect_id);
checklist->sender = (job_t*)callback_job_create((callback_job_cb_t)sender,
/**
* Derive IKE keys for a combined AEAD algorithm
*/
-static bool derive_ike_aead(private_keymat_v2_t *this, u_int16_t alg,
- u_int16_t key_size, prf_plus_t *prf_plus)
+static bool derive_ike_aead(private_keymat_v2_t *this, uint16_t alg,
+ uint16_t key_size, prf_plus_t *prf_plus)
{
aead_t *aead_i, *aead_r;
chunk_t key = chunk_empty;
/**
* Derive IKE keys for traditional encryption and MAC algorithms
*/
-static bool derive_ike_traditional(private_keymat_v2_t *this, u_int16_t enc_alg,
- u_int16_t enc_size, u_int16_t int_alg, prf_plus_t *prf_plus)
+static bool derive_ike_traditional(private_keymat_v2_t *this, uint16_t enc_alg,
+ uint16_t enc_size, uint16_t int_alg, prf_plus_t *prf_plus)
{
crypter_t *crypter_i = NULL, *crypter_r = NULL;
signer_t *signer_i, *signer_r;
chunk_t skeyseed, key, secret, full_nonce, fixed_nonce, prf_plus_seed;
chunk_t spi_i, spi_r;
prf_plus_t *prf_plus = NULL;
- u_int16_t alg, key_size, int_alg;
+ uint16_t alg, key_size, int_alg;
prf_t *rekey_prf = NULL;
- spi_i = chunk_alloca(sizeof(u_int64_t));
- spi_r = chunk_alloca(sizeof(u_int64_t));
+ spi_i = chunk_alloca(sizeof(uint64_t));
+ spi_r = chunk_alloca(sizeof(uint64_t));
if (!dh->get_shared_secret(dh, &secret))
{
break;
}
fixed_nonce = chunk_cat("cc", nonce_i, nonce_r);
- *((u_int64_t*)spi_i.ptr) = id->get_initiator_spi(id);
- *((u_int64_t*)spi_r.ptr) = id->get_responder_spi(id);
+ *((uint64_t*)spi_i.ptr) = id->get_initiator_spi(id);
+ *((uint64_t*)spi_r.ptr) = id->get_responder_spi(id);
prf_plus_seed = chunk_cat("ccc", full_nonce, spi_i, spi_r);
/* KEYMAT = prf+ (SKEYSEED, Ni | Nr | SPIi | SPIr)
chunk_t nonce_i, chunk_t nonce_r, chunk_t *encr_i, chunk_t *integ_i,
chunk_t *encr_r, chunk_t *integ_r)
{
- u_int16_t enc_alg, int_alg, enc_size = 0, int_size = 0;
+ uint16_t enc_alg, int_alg, enc_size = 0, int_size = 0;
chunk_t seed, secret = chunk_empty;
prf_plus_t *prf_plus;
/**
* Message ID used for this transaction
*/
- u_int32_t mid;
+ uint32_t mid;
/**
* generated packet for retransmission
/**
* Message ID of the exchange
*/
- u_int32_t mid;
+ uint32_t mid;
/**
* packet(s) for retransmission
/**
* Message ID of the exchange
*/
- u_int32_t mid;
+ uint32_t mid;
/**
* how many times we have retransmitted so far
}
METHOD(task_manager_t, retransmit, status_t,
- private_task_manager_t *this, u_int32_t message_id)
+ private_task_manager_t *this, uint32_t message_id)
{
if (message_id == this->initiating.mid &&
array_count(this->initiating.packets))
{
- u_int32_t timeout;
+ uint32_t timeout;
job_t *job;
enumerator_t *enumerator;
packet_t *packet;
{
if (this->initiating.retransmitted <= this->retransmit_tries)
{
- timeout = (u_int32_t)(this->retransmit_timeout * 1000.0 *
+ timeout = (uint32_t)(this->retransmit_timeout * 1000.0 *
pow(this->retransmit_base, this->initiating.retransmitted));
}
else
host_t *me, *other;
bool delete = FALSE, hook = FALSE;
ike_sa_id_t *id = NULL;
- u_int64_t responder_spi = 0;
+ uint64_t responder_spi = 0;
bool result;
me = request->get_destination(request);
static status_t parse_message(private_task_manager_t *this, message_t *msg)
{
status_t status;
- u_int8_t type = 0;
+ uint8_t type = 0;
status = msg->parse_body(msg, this->ike_sa->get_keymat(this->ike_sa));
{
host_t *me, *other;
status_t status;
- u_int32_t mid;
+ uint32_t mid;
bool schedule_delete_job = FALSE;
charon->bus->message(charon->bus, msg, TRUE, FALSE);
}
METHOD(task_manager_t, queue_child, void,
- private_task_manager_t *this, child_cfg_t *cfg, u_int32_t reqid,
+ private_task_manager_t *this, child_cfg_t *cfg, uint32_t reqid,
traffic_selector_t *tsi, traffic_selector_t *tsr)
{
child_create_t *task;
}
METHOD(task_manager_t, queue_child_rekey, void,
- private_task_manager_t *this, protocol_id_t protocol, u_int32_t spi)
+ private_task_manager_t *this, protocol_id_t protocol, uint32_t spi)
{
queue_task(this, (task_t*)child_rekey_create(this->ike_sa, protocol, spi));
}
METHOD(task_manager_t, queue_child_delete, void,
- private_task_manager_t *this, protocol_id_t protocol, u_int32_t spi,
+ private_task_manager_t *this, protocol_id_t protocol, uint32_t spi,
bool expired)
{
queue_task(this, (task_t*)child_delete_create(this->ike_sa,
}
METHOD(task_manager_t, reset, void,
- private_task_manager_t *this, u_int32_t initiate, u_int32_t respond)
+ private_task_manager_t *this, uint32_t initiate, uint32_t respond)
{
enumerator_t *enumerator;
task_t *task;
/**
* Own allocated SPI
*/
- u_int32_t my_spi;
+ uint32_t my_spi;
/**
* SPI received in proposal
*/
- u_int32_t other_spi;
+ uint32_t other_spi;
/**
* Own allocated Compression Parameter Index (CPI)
*/
- u_int16_t my_cpi;
+ uint16_t my_cpi;
/**
* Other Compression Parameter Index (CPI), received via IPCOMP_SUPPORTED
*/
- u_int16_t other_cpi;
+ uint16_t other_cpi;
/**
* reqid to use if we are rekeying
*/
- u_int32_t reqid;
+ uint32_t reqid;
/**
* Explicit inbound mark value
*/
static void schedule_inactivity_timeout(private_child_create_t *this)
{
- u_int32_t timeout, id;
+ uint32_t timeout, id;
bool close_ike;
timeout = this->config->get_inactivity(this->config);
linked_list_t *out;
traffic_selector_t *ts;
host_t *ike, *first = NULL;
- u_int8_t mask;
+ uint8_t mask;
if (local)
{
if (!this->proposal->has_dh_group(this->proposal, this->dh_group))
{
- u_int16_t group;
+ uint16_t group;
if (this->proposal->get_algorithm(this->proposal, DIFFIE_HELLMAN_GROUP,
&group, NULL))
* Adds an IPCOMP_SUPPORTED notify to the message, allocating a CPI
*/
static void add_ipcomp_notify(private_child_create_t *this,
- message_t *message, u_int8_t ipcomp)
+ message_t *message, uint8_t ipcomp)
{
this->my_cpi = this->child_sa->alloc_cpi(this->child_sa);
if (this->my_cpi)
case IPCOMP_SUPPORTED:
{
ipcomp_transform_t ipcomp;
- u_int16_t cpi;
+ uint16_t cpi;
chunk_t data;
data = notify->get_notification_data(notify);
- cpi = *(u_int16_t*)data.ptr;
+ cpi = *(uint16_t*)data.ptr;
ipcomp = (ipcomp_transform_t)(*(data.ptr + 2));
switch (ipcomp)
{
return SUCCESS;
case INVALID_ARG:
{
- u_int16_t group = htons(this->dh_group);
+ uint16_t group = htons(this->dh_group);
message->add_notify(message, FALSE, INVALID_KE_PAYLOAD,
chunk_from_thing(group));
handle_child_sa_failure(this, message);
case INVALID_KE_PAYLOAD:
{
chunk_t data;
- u_int16_t group = MODP_NONE;
+ uint16_t group = MODP_NONE;
data = notify->get_notification_data(notify);
if (data.len == sizeof(group))
}
METHOD(child_create_t, use_reqid, void,
- private_child_create_t *this, u_int32_t reqid)
+ private_child_create_t *this, uint32_t reqid)
{
this->reqid = reqid;
}
*
* @param reqid reqid to use
*/
- void (*use_reqid) (child_create_t *this, u_int32_t reqid);
+ void (*use_reqid) (child_create_t *this, uint32_t reqid);
/**
* Use specific mark values to override configuration.
/**
* Inbound SPI of CHILD_SA to delete
*/
- u_int32_t spi;
+ uint32_t spi;
/**
* whether to enforce delete action policy
while (enumerator->enumerate(enumerator, (void**)&child_sa))
{
protocol_id_t protocol = child_sa->get_protocol(child_sa);
- u_int32_t spi = child_sa->get_spi(child_sa, TRUE);
+ uint32_t spi = child_sa->get_spi(child_sa, TRUE);
switch (protocol)
{
enumerator_t *payloads, *spis;
payload_t *payload;
delete_payload_t *delete_payload;
- u_int32_t spi;
+ uint32_t spi;
protocol_id_t protocol;
child_sa_t *child_sa;
child_sa_t *child_sa;
child_cfg_t *child_cfg;
protocol_id_t protocol;
- u_int32_t spi, reqid;
+ uint32_t spi, reqid;
action_t action;
status_t status = SUCCESS;
linked_list_t *my_ts, *other_ts;
enumerator_t *enumerator;
child_sa_t *child_sa;
- u_int64_t bytes_in, bytes_out;
+ uint64_t bytes_in, bytes_out;
enumerator = this->child_sas->create_enumerator(this->child_sas);
while (enumerator->enumerate(enumerator, (void**)&child_sa))
* Described in header.
*/
child_delete_t *child_delete_create(ike_sa_t *ike_sa, protocol_id_t protocol,
- u_int32_t spi, bool expired)
+ uint32_t spi, bool expired)
{
private_child_delete_t *this;
* @return child_delete task to handle by the task_manager
*/
child_delete_t *child_delete_create(ike_sa_t *ike_sa, protocol_id_t protocol,
- u_int32_t spi, bool expired);
+ uint32_t spi, bool expired);
#endif /** CHILD_DELETE_H_ @}*/
/**
* Inbound SPI of CHILD_SA to rekey
*/
- u_int32_t spi;
+ uint32_t spi;
/**
* the CHILD_CREATE task which is reused to simplify rekeying
*/
static void schedule_delayed_rekey(private_child_rekey_t *this)
{
- u_int32_t retry;
+ uint32_t retry;
job_t *job;
retry = RETRY_INTERVAL - (random() % RETRY_JITTER);
{
notify_payload_t *notify;
protocol_id_t protocol;
- u_int32_t spi;
+ uint32_t spi;
notify = message->get_notify(message, REKEY_SA);
if (notify)
private_child_rekey_t *this, message_t *message)
{
notify_payload_t *notify;
- u_int32_t reqid;
+ uint32_t reqid;
child_cfg_t *config;
this->child_sa = this->ike_sa->get_child_sa(this->ike_sa, this->protocol,
private_child_rekey_t *this, message_t *message)
{
child_cfg_t *config;
- u_int32_t reqid;
+ uint32_t reqid;
if (this->child_sa == NULL ||
this->child_sa->get_state(this->child_sa) == CHILD_DELETING)
private_child_rekey_t *this, message_t *message)
{
protocol_id_t protocol;
- u_int32_t spi;
+ uint32_t spi;
child_sa_t *to_delete;
if (message->get_notify(message, NO_ADDITIONAL_SAS))
* Described in header.
*/
child_rekey_t *child_rekey_create(ike_sa_t *ike_sa, protocol_id_t protocol,
- u_int32_t spi)
+ uint32_t spi)
{
private_child_rekey_t *this;
* @return child_rekey task to handle by the task_manager
*/
child_rekey_t *child_rekey_create(ike_sa_t *ike_sa, protocol_id_t protocol,
- u_int32_t spi);
+ uint32_t spi);
#endif /** CHILD_REKEY_H_ @}*/
*/
static void get_reserved_id_bytes(private_ike_auth_t *this, id_payload_t *id)
{
- u_int8_t *byte;
+ uint8_t *byte;
int i;
for (i = 0; i < countof(this->reserved); i++)
static void add_auth_lifetime(private_ike_auth_lifetime_t *this, message_t *message)
{
chunk_t chunk;
- u_int32_t lifetime;
+ uint32_t lifetime;
lifetime = this->ike_sa->get_statistic(this->ike_sa, STAT_REAUTH);
if (lifetime)
{
lifetime -= time_monotonic(NULL);
chunk = chunk_from_thing(lifetime);
- *(u_int32_t*)chunk.ptr = htonl(lifetime);
+ *(uint32_t*)chunk.ptr = htonl(lifetime);
message->add_notify(message, FALSE, AUTH_LIFETIME, chunk);
}
}
{
notify_payload_t *notify;
chunk_t data;
- u_int32_t lifetime;
+ uint32_t lifetime;
notify = message->get_notify(message, AUTH_LIFETIME);
if (notify)
{
data = notify->get_notification_data(notify);
- lifetime = ntohl(*(u_int32_t*)data.ptr);
+ lifetime = ntohl(*(uint32_t*)data.ptr);
this->ike_sa->set_auth_lifetime(this->ike_sa, lifetime);
}
}
notify_payload_t *notify)
{
bio_reader_t *reader;
- u_int16_t algo;
+ uint16_t algo;
bool added = FALSE;
reader = bio_reader_create(notify->get_notification_data(notify));
if (this->dh == NULL ||
!this->proposal->has_dh_group(this->proposal, this->dh_group))
{
- u_int16_t group;
+ uint16_t group;
if (this->proposal->get_algorithm(this->proposal, DIFFIE_HELLMAN_GROUP,
&group, NULL))
bad_group = this->dh_group;
data = notify->get_notification_data(notify);
- this->dh_group = ntohs(*((u_int16_t*)data.ptr));
+ this->dh_group = ntohs(*((uint16_t*)data.ptr));
DBG1(DBG_IKE, "peer didn't accept DH group %N, "
"it requested %N", diffie_hellman_group_names,
bad_group, diffie_hellman_group_names, this->dh_group);
{
enumerator_t *enumerator;
host_t *addr, *host;
- u_int16_t port;
+ uint16_t port;
/* get the port that is used to communicate with the ms */
host = this->ike_sa->get_my_host(this->ike_sa);
/**
* Apply the port of the old host, if its ip equals the new, use port otherwise.
*/
-static void apply_port(host_t *host, host_t *old, u_int16_t port, bool local)
+static void apply_port(host_t *host, host_t *old, uint16_t port, bool local)
{
if (host->ip_equals(host, old))
{
{
chunk_t natd_chunk, spi_i_chunk, spi_r_chunk, addr_chunk, port_chunk;
chunk_t natd_hash;
- u_int64_t spi_i, spi_r;
- u_int16_t port;
+ uint64_t spi_i, spi_r;
+ uint16_t port;
/* prepare all required chunks */
spi_i = ike_sa_id->get_initiator_spi(ike_sa_id);
config = this->ike_sa->get_ike_cfg(this->ike_sa);
if (force_encap(config) && type == NAT_DETECTION_SOURCE_IP)
{
- u_int32_t addr;
+ uint32_t addr;
/* chunk_hash() is randomly keyed so this produces a random IPv4 address
* that changes with every restart but otherwise stays the same */
this->collision->get_type(this->collision) == TASK_IKE_REAUTH)))
{
job_t *job;
- u_int32_t retry = RETRY_INTERVAL - (random() % RETRY_JITTER);
+ uint32_t retry = RETRY_INTERVAL - (random() % RETRY_JITTER);
job = (job_t*)rekey_ike_sa_job_create(
this->ike_sa->get_id(this->ike_sa), FALSE);
DBG1(DBG_IKE, "IKE_SA rekeying failed, "
bio_reader_t *reader;
id_type_t id_type;
chunk_t gateway;
- u_int8_t type;
+ uint8_t type;
reader = bio_reader_create(data);
if (!reader->read_uint8(reader, &type) ||
* @param tsi initiator traffic selector, if packet-triggered
* @param tsr responder traffic selector, if packet-triggered
*/
- void (*queue_child)(task_manager_t *this, child_cfg_t *cfg, u_int32_t reqid,
+ void (*queue_child)(task_manager_t *this, child_cfg_t *cfg, uint32_t reqid,
traffic_selector_t *tsi, traffic_selector_t *tsr);
/**
* @param spi CHILD_SA SPI to rekey
*/
void (*queue_child_rekey)(task_manager_t *this, protocol_id_t protocol,
- u_int32_t spi);
+ uint32_t spi);
/**
* Queue CHILD_SA delete tasks.
* @param expired TRUE if SA already expired
*/
void (*queue_child_delete)(task_manager_t *this, protocol_id_t protocol,
- u_int32_t spi, bool expired);
+ uint32_t spi, bool expired);
/**
* Queue liveness checking tasks.
* - INVALID_STATE if retransmission not required
* - SUCCESS if retransmission sent
*/
- status_t (*retransmit) (task_manager_t *this, u_int32_t message_id);
+ status_t (*retransmit) (task_manager_t *this, uint32_t message_id);
/**
* Migrate all queued tasks from other to this.
* @param initiate message ID / DPD seq to initiate exchanges (send)
* @param respond message ID / DPD seq to respond to exchanges (expect)
*/
- void (*reset) (task_manager_t *this, u_int32_t initiate, u_int32_t respond);
+ void (*reset) (task_manager_t *this, uint32_t initiate, uint32_t respond);
/**
* Check if we are currently waiting for a reply.
/** pending IKE_SA connecting upon acquire */
ike_sa_t *ike_sa;
/** reqid of pending trap policy */
- u_int32_t reqid;
+ uint32_t reqid;
/** destination address (wildcard case) */
host_t *dst;
} acquire_t;
/**
* match an acquire entry by reqid
*/
-static bool acquire_by_reqid(acquire_t *this, u_int32_t *reqid)
+static bool acquire_by_reqid(acquire_t *this, uint32_t *reqid)
{
return this->reqid == *reqid;
}
return this->dst && this->dst->ip_equals(this->dst, dst);
}
-METHOD(trap_manager_t, install, u_int32_t,
+METHOD(trap_manager_t, install, uint32_t,
private_trap_manager_t *this, peer_cfg_t *peer, child_cfg_t *child,
- u_int32_t reqid)
+ uint32_t reqid)
{
entry_t *entry, *found = NULL;
ike_cfg_t *ike_cfg;
}
METHOD(trap_manager_t, uninstall, bool,
- private_trap_manager_t *this, u_int32_t reqid)
+ private_trap_manager_t *this, uint32_t reqid)
{
enumerator_t *enumerator;
entry_t *entry, *found = NULL;
(void*)this->lock->unlock);
}
-METHOD(trap_manager_t, find_reqid, u_int32_t,
+METHOD(trap_manager_t, find_reqid, uint32_t,
private_trap_manager_t *this, child_cfg_t *child)
{
enumerator_t *enumerator;
entry_t *entry;
- u_int32_t reqid = 0;
+ uint32_t reqid = 0;
this->lock->read_lock(this->lock);
enumerator = this->traps->create_enumerator(this->traps);
}
METHOD(trap_manager_t, acquire, void,
- private_trap_manager_t *this, u_int32_t reqid,
+ private_trap_manager_t *this, uint32_t reqid,
traffic_selector_t *src, traffic_selector_t *dst)
{
enumerator_t *enumerator;
if (wildcard)
{ /* for wildcard acquires we check that we don't have a pending acquire
* with the same peer */
- u_int8_t mask;
+ uint8_t mask;
dst->to_subnet(dst, &host, &mask);
if (this->acquires->find_first(this->acquires, (void*)acquire_by_dst,
if (ike_sa)
{
ike_cfg_t *ike_cfg;
- u_int16_t port;
- u_int8_t mask;
+ uint16_t port;
+ uint8_t mask;
ike_sa->set_peer_cfg(ike_sa, peer);
ike_cfg = ike_sa->get_ike_cfg(ike_sa);
* @param reqid optional reqid to use
* @return reqid of installed CHILD_SA, 0 if failed
*/
- u_int32_t (*install)(trap_manager_t *this, peer_cfg_t *peer,
- child_cfg_t *child, u_int32_t reqid);
+ uint32_t (*install)(trap_manager_t *this, peer_cfg_t *peer,
+ child_cfg_t *child, uint32_t reqid);
/**
* Uninstall a trap policy.
* @param id reqid of CHILD_SA to uninstall, returned by install()
* @return TRUE if uninstalled successfully
*/
- bool (*uninstall)(trap_manager_t *this, u_int32_t reqid);
+ bool (*uninstall)(trap_manager_t *this, uint32_t reqid);
/**
* Create an enumerator over all installed traps.
* @param child CHILD_SA config to get the reqid for
* @return reqid of trap, 0 if not found
*/
- u_int32_t (*find_reqid)(trap_manager_t *this, child_cfg_t *child);
+ uint32_t (*find_reqid)(trap_manager_t *this, child_cfg_t *child);
/**
* Acquire an SA triggered by an installed trap.
* @param src source of the triggering packet
* @param dst destination of the triggering packet
*/
- void (*acquire)(trap_manager_t *this, u_int32_t reqid,
+ void (*acquire)(trap_manager_t *this, uint32_t reqid,
traffic_selector_t *src, traffic_selector_t *dst);
/**
}
METHOD(iv_gen_t, get_iv, bool,
- iv_gen_t *this, u_int64_t seq, size_t size, u_int8_t *buffer)
+ iv_gen_t *this, uint64_t seq, size_t size, uint8_t *buffer)
{
if (size != 8)
{
}
METHOD(iv_gen_t, allocate_iv, bool,
- iv_gen_t *this, u_int64_t seq, size_t size, chunk_t *chunk)
+ iv_gen_t *this, uint64_t seq, size_t size, chunk_t *chunk)
{
if (size != 8)
{
*/
START_TEST(test_chacha20poly1305)
{
- u_int64_t spii, spir;
+ uint64_t spii, spir;
ike_sa_id_t *id;
message_t *m;
- u_int32_t window = htonl(10);
+ uint32_t window = htonl(10);
chunk_t chunk, exp;
keymat_t keymat = {
.get_version = _get_version,
}
METHOD(pa_tnc_attr_t, process, status_t,
- private_generic_attr_bool_t *this, u_int32_t *offset)
+ private_generic_attr_bool_t *this, uint32_t *offset)
{
enum_name_t *pa_attr_names;
bio_reader_t *reader;
- u_int32_t status;
+ uint32_t status;
*offset = 0;
}
METHOD(pa_tnc_attr_t, process, status_t,
- private_generic_attr_chunk_t *this, u_int32_t *offset)
+ private_generic_attr_chunk_t *this, uint32_t *offset)
{
enum_name_t *pa_attr_names;
*offset = 0;
}
METHOD(pa_tnc_attr_t, process, status_t,
- private_generic_attr_string_t *this, u_int32_t *offset)
+ private_generic_attr_string_t *this, uint32_t *offset)
{
enum_name_t *pa_attr_names;
u_char *pos;
/**
* See header
*/
-pa_tnc_attr_t* ietf_attr_create_from_data(u_int32_t type, size_t length,
+pa_tnc_attr_t* ietf_attr_create_from_data(uint32_t type, size_t length,
chunk_t value)
{
switch (type)
* @param length attribute length
* @param value attribute value or segment
*/
-pa_tnc_attr_t* ietf_attr_create_from_data(u_int32_t type, size_t length,
+pa_tnc_attr_t* ietf_attr_create_from_data(uint32_t type, size_t length,
chunk_t value);
#endif /** IETF_ATTR_H_ @}*/
/**
* Assessment Result
*/
- u_int32_t result;
+ uint32_t result;
/**
* Reference count
}
METHOD(pa_tnc_attr_t, process, status_t,
- private_ietf_attr_assess_result_t *this, u_int32_t *offset)
+ private_ietf_attr_assess_result_t *this, uint32_t *offset)
{
bio_reader_t *reader;
}
}
-METHOD(ietf_attr_assess_result_t, get_result, u_int32_t,
+METHOD(ietf_attr_assess_result_t, get_result, uint32_t,
private_ietf_attr_assess_result_t *this)
{
return this->result;
/**
* Described in header.
*/
-pa_tnc_attr_t *ietf_attr_assess_result_create(u_int32_t result)
+pa_tnc_attr_t *ietf_attr_assess_result_create(uint32_t result)
{
private_ietf_attr_assess_result_t *this;
*
* @return Assessment Result
*/
- u_int32_t (*get_result)(ietf_attr_assess_result_t *this);
+ uint32_t (*get_result)(ietf_attr_assess_result_t *this);
};
* Creates an ietf_attr_assess_result_t object
*
*/
-pa_tnc_attr_t* ietf_attr_assess_result_create(u_int32_t result);
+pa_tnc_attr_t* ietf_attr_assess_result_create(uint32_t result);
/**
* Creates an ietf_attr_assess_result_t object from received data
}
METHOD(ietf_attr_attr_request_t, add, void,
- private_ietf_attr_attr_request_t *this, pen_t vendor_id, u_int32_t type)
+ private_ietf_attr_attr_request_t *this, pen_t vendor_id, uint32_t type)
{
enum_name_t *pa_attr_names;
pen_type_t *entry;
}
METHOD(pa_tnc_attr_t, process, status_t,
- private_ietf_attr_attr_request_t *this, u_int32_t *offset)
+ private_ietf_attr_attr_request_t *this, uint32_t *offset)
{
bio_reader_t *reader;
pen_t vendor_id;
- u_int32_t type;
- u_int8_t reserved;
+ uint32_t type;
+ uint8_t reserved;
int count;
*offset = 0;
/**
* Described in header.
*/
-pa_tnc_attr_t *ietf_attr_attr_request_create(pen_t vendor_id, u_int32_t type)
+pa_tnc_attr_t *ietf_attr_attr_request_create(pen_t vendor_id, uint32_t type)
{
private_ietf_attr_attr_request_t *this;
* @param vendor_id Attribute Vendor ID
* @param type Attribute Type
*/
- void (*add)(ietf_attr_attr_request_t *this, pen_t vendor_id, u_int32_t type);
+ void (*add)(ietf_attr_attr_request_t *this, pen_t vendor_id, uint32_t type);
/**
* Creates an enumerator over all attribute types contained
* Creates an ietf_attr_attr_request_t object
*
*/
-pa_tnc_attr_t* ietf_attr_attr_request_create(pen_t vendor_id, u_int32_t type);
+pa_tnc_attr_t* ietf_attr_attr_request_create(pen_t vendor_id, uint32_t type);
/**
* @param length Total length of attribute value
}
METHOD(pa_tnc_attr_t, process, status_t,
- private_ietf_attr_fwd_enabled_t *this, u_int32_t *offset)
+ private_ietf_attr_fwd_enabled_t *this, uint32_t *offset)
{
bio_reader_t *reader;
- u_int32_t fwd_status;
+ uint32_t fwd_status;
*offset = 0;
}
METHOD(pa_tnc_attr_t, process, status_t,
- private_ietf_attr_installed_packages_t *this, u_int32_t *offset)
+ private_ietf_attr_installed_packages_t *this, uint32_t *offset)
{
bio_reader_t *reader;
package_entry_t *entry;
status_t status = NEED_MORE;
chunk_t name, version;
- u_int16_t reserved;
+ uint16_t reserved;
u_char *pos;
if (this->offset == 0)
/**
* Major Version Number
*/
- u_int32_t major_version;
+ uint32_t major_version;
/**
* Minor Version Number
*/
- u_int32_t minor_version;
+ uint32_t minor_version;
/**
* IBuild Number
*/
- u_int32_t build;
+ uint32_t build;
/**
* Service Pack Major Number
*/
- u_int16_t service_pack_major;
+ uint16_t service_pack_major;
/**
* Service Pack Minor Number
*/
- u_int16_t service_pack_minor;
+ uint16_t service_pack_minor;
/**
* Reference count
}
METHOD(pa_tnc_attr_t, process, status_t,
- private_ietf_attr_numeric_version_t *this, u_int32_t *offset)
+ private_ietf_attr_numeric_version_t *this, uint32_t *offset)
{
bio_reader_t *reader;
}
METHOD(ietf_attr_numeric_version_t, get_version, void,
- private_ietf_attr_numeric_version_t *this, u_int32_t *major, u_int32_t *minor)
+ private_ietf_attr_numeric_version_t *this, uint32_t *major, uint32_t *minor)
{
if (major)
{
}
}
-METHOD(ietf_attr_numeric_version_t, get_build, u_int32_t,
+METHOD(ietf_attr_numeric_version_t, get_build, uint32_t,
private_ietf_attr_numeric_version_t *this)
{
return this->build;
}
METHOD(ietf_attr_numeric_version_t, get_service_pack, void,
- private_ietf_attr_numeric_version_t *this, u_int16_t *major, u_int16_t *minor)
+ private_ietf_attr_numeric_version_t *this, uint16_t *major, uint16_t *minor)
{
if (major)
{
/**
* Described in header.
*/
-pa_tnc_attr_t *ietf_attr_numeric_version_create(u_int32_t major, u_int32_t minor,
- u_int32_t build,
- u_int16_t service_pack_major,
- u_int16_t service_pack_minor)
+pa_tnc_attr_t *ietf_attr_numeric_version_create(uint32_t major, uint32_t minor,
+ uint32_t build,
+ uint16_t service_pack_major,
+ uint16_t service_pack_minor)
{
private_ietf_attr_numeric_version_t *this;
* @param minor Minor Version Number
*/
void (*get_version)(ietf_attr_numeric_version_t *this,
- u_int32_t *major, u_int32_t *minor);
+ uint32_t *major, uint32_t *minor);
/**
* Gets the Build Number
* @param major Major Version Number
* @param minor Minor Version Number
*/
- u_int32_t (*get_build)(ietf_attr_numeric_version_t *this);
+ uint32_t (*get_build)(ietf_attr_numeric_version_t *this);
/**
* Gets the Major and Minor Numbers of the Service Pack
* @param minor Servcie Pack Minor Number
*/
void (*get_service_pack)(ietf_attr_numeric_version_t *this,
- u_int16_t *major, u_int16_t *minor);
+ uint16_t *major, uint16_t *minor);
};
/**
* Creates an ietf_attr_numeric_version_t object
*
*/
-pa_tnc_attr_t* ietf_attr_numeric_version_create(u_int32_t major, u_int32_t minor,
- u_int32_t build,
- u_int16_t service_pack_major,
- u_int16_t service_pack_minor);
+pa_tnc_attr_t* ietf_attr_numeric_version_create(uint32_t major, uint32_t minor,
+ uint32_t build,
+ uint16_t service_pack_major,
+ uint16_t service_pack_minor);
/**
* Creates an ietf_attr_numeric_version_t object from received data
/**
* Status
*/
- u_int8_t status;
+ uint8_t status;
/**
* Result
*/
- u_int8_t result;
+ uint8_t result;
/**
* Last Use
}
METHOD(pa_tnc_attr_t, process, status_t,
- private_ietf_attr_op_status_t *this, u_int32_t *offset)
+ private_ietf_attr_op_status_t *this, uint32_t *offset)
{
bio_reader_t *reader;
chunk_t last_use;
- u_int16_t reserved;
+ uint16_t reserved;
struct tm t;
*offset = 0;
}
}
-METHOD(ietf_attr_op_status_t, get_status, u_int8_t,
+METHOD(ietf_attr_op_status_t, get_status, uint8_t,
private_ietf_attr_op_status_t *this)
{
return this->status;
}
-METHOD(ietf_attr_op_status_t, get_result, u_int8_t,
+METHOD(ietf_attr_op_status_t, get_result, uint8_t,
private_ietf_attr_op_status_t *this)
{
return this->result;
/**
* Described in header.
*/
-pa_tnc_attr_t *ietf_attr_op_status_create(u_int8_t status, u_int8_t result,
+pa_tnc_attr_t *ietf_attr_op_status_create(uint8_t status, uint8_t result,
time_t last_use)
{
private_ietf_attr_op_status_t *this;
*
* @return Operational Status
*/
- u_int8_t (*get_status)(ietf_attr_op_status_t *this);
+ uint8_t (*get_status)(ietf_attr_op_status_t *this);
/**
* Gets the Operational Result
*
* @return Operational Result
*/
- u_int8_t (*get_result)(ietf_attr_op_status_t *this);
+ uint8_t (*get_result)(ietf_attr_op_status_t *this);
/**
* Gets the time of last use
* @param result Operational Result
* @param last_use Time of last use
*/
-pa_tnc_attr_t* ietf_attr_op_status_create(u_int8_t status, u_int8_t result,
+pa_tnc_attr_t* ietf_attr_op_status_create(uint8_t status, uint8_t result,
time_t last_use);
/**
*/
struct port_entry_t {
bool blocked;
- u_int8_t protocol;
- u_int16_t port;
+ uint8_t protocol;
+ uint16_t port;
};
/**
}
METHOD(pa_tnc_attr_t, process, status_t,
- private_ietf_attr_port_filter_t *this, u_int32_t *offset)
+ private_ietf_attr_port_filter_t *this, uint32_t *offset)
{
bio_reader_t *reader;
port_entry_t *entry;
- u_int8_t blocked;
+ uint8_t blocked;
*offset = 0;
}
METHOD(ietf_attr_port_filter_t, add_port, void,
- private_ietf_attr_port_filter_t *this, bool blocked, u_int8_t protocol,
- u_int16_t port)
+ private_ietf_attr_port_filter_t *this, bool blocked, uint8_t protocol,
+ uint16_t port)
{
port_entry_t *entry;
* Enumerate port filter entries
*/
static bool port_filter(void *null, port_entry_t **entry,
- bool *blocked, void *i2, u_int8_t *protocol, void *i3,
- u_int16_t *port)
+ bool *blocked, void *i2, uint8_t *protocol, void *i3,
+ uint16_t *port)
{
*blocked = (*entry)->blocked;
*protocol = (*entry)->protocol;
* @param port TCP/UDP port number
*/
void (*add_port)(ietf_attr_port_filter_t *this, bool blocked,
- u_int8_t protocol, u_int16_t port);
+ uint8_t protocol, uint16_t port);
/**
* Enumerates over all ports
- * Format: bool *blocked, u_int8_t *protocol, u_int16_t *port
+ * Format: bool *blocked, uint8_t *protocol, uint16_t *port
*
* @return enumerator
*/
/**
* Product ID
*/
- u_int16_t product_id;
+ uint16_t product_id;
/**
* Product Name
}
METHOD(pa_tnc_attr_t, process, status_t,
- private_ietf_attr_product_info_t *this, u_int32_t *offset)
+ private_ietf_attr_product_info_t *this, uint32_t *offset)
{
bio_reader_t *reader;
chunk_t product_name;
}
METHOD(ietf_attr_product_info_t, get_info, chunk_t,
- private_ietf_attr_product_info_t *this, pen_t *vendor_id, u_int16_t *id)
+ private_ietf_attr_product_info_t *this, pen_t *vendor_id, uint16_t *id)
{
if (vendor_id)
{
/**
* Described in header.
*/
-pa_tnc_attr_t *ietf_attr_product_info_create(pen_t vendor_id, u_int16_t id,
+pa_tnc_attr_t *ietf_attr_product_info_create(pen_t vendor_id, uint16_t id,
chunk_t name)
{
private_ietf_attr_product_info_t *this;
* @return Product Name
*/
chunk_t (*get_info)(ietf_attr_product_info_t *this,
- pen_t *vendor_id, u_int16_t *id);
+ pen_t *vendor_id, uint16_t *id);
};
* Creates an ietf_attr_product_info_t object
*
*/
-pa_tnc_attr_t* ietf_attr_product_info_create(pen_t vendor_id, u_int16_t id,
+pa_tnc_attr_t* ietf_attr_product_info_create(pen_t vendor_id, uint16_t id,
chunk_t name);
/**
}
METHOD(pa_tnc_attr_t, process, status_t,
- private_ietf_attr_remediation_instr_t *this, u_int32_t *offset)
+ private_ietf_attr_remediation_instr_t *this, uint32_t *offset)
{
bio_reader_t *reader;
- u_int8_t reserved;
+ uint8_t reserved;
status_t status = SUCCESS;
u_char *pos;
}
METHOD(pa_tnc_attr_t, process, status_t,
- private_ietf_attr_string_version_t *this, u_int32_t *offset)
+ private_ietf_attr_string_version_t *this, uint32_t *offset)
{
bio_reader_t *reader;
status_t status = FAILED;
/**
* number of message types registered by IMC
*/
- u_int32_t type_count;
+ uint32_t type_count;
/**
* ID of IMC as assigned by TNCC
/**
* Read an UInt32 attribute
*/
-static u_int32_t get_uint_attribute(private_imc_agent_t *this, TNC_ConnectionID id,
+static uint32_t get_uint_attribute(private_imc_agent_t *this, TNC_ConnectionID id,
TNC_AttributeID attribute_id)
{
TNC_UInt32 len;
TNC_ConnectionID conn_id;
char *tnccs_p = NULL, *tnccs_v = NULL, *t_p = NULL, *t_v = NULL;
bool has_long = FALSE, has_excl = FALSE, has_soh = FALSE;
- u_int32_t max_msg_len;
+ uint32_t max_msg_len;
conn_id = state->get_connection_id(state);
if (find_connection(this, conn_id))
* Described in header.
*/
imc_agent_t *imc_agent_create(const char *name,
- pen_type_t *supported_types, u_int32_t type_count,
+ pen_type_t *supported_types, uint32_t type_count,
TNC_IMCID id, TNC_Version *actual_version)
{
private_imc_agent_t *this;
*
*/
imc_agent_t *imc_agent_create(const char *name,
- pen_type_t *supported_types, u_int32_t type_count,
+ pen_type_t *supported_types, uint32_t type_count,
TNC_IMCID id, TNC_Version *actual_version);
#endif /** IMC_AGENT_H_ @}*/
}
METHOD(imc_os_info_t, get_numeric_version, void,
- private_imc_os_info_t *this, u_int32_t *major, u_int32_t *minor)
+ private_imc_os_info_t *this, uint32_t *major, uint32_t *minor)
{
u_char *pos;
* @param major OS major version number
* @param minor OS minor version number
*/
- void (*get_numeric_version)(imc_os_info_t *this, u_int32_t *major,
- u_int32_t *minor);
+ void (*get_numeric_version)(imc_os_info_t *this, uint32_t *major,
+ uint32_t *minor);
/**
* Get the OS version or release
*
* @param max_msg_len maximum size of a PA-TNC message
*/
- void (*set_max_msg_len)(imc_state_t *this, u_int32_t max_msg_len);
+ void (*set_max_msg_len)(imc_state_t *this, uint32_t max_msg_len);
/**
* Get the maximum size of a PA-TNC message for this TNCCS connection
*
* @return maximum size of a PA-TNC message
*/
- u_int32_t (*get_max_msg_len)(imc_state_t *this);
+ uint32_t (*get_max_msg_len)(imc_state_t *this);
/**
* Get attribute segmentation contracts associated with TNCCS Connection
*/
imv_session_t* (*add_session)(imv_database_t *this,
TNC_ConnectionID conn_id,
- u_int32_t ar_id_type, chunk_t ar_id_value);
+ uint32_t ar_id_type, chunk_t ar_id_value);
/**
* Remove and delete a session
/**
* See header
*/
-pa_tnc_attr_t* ita_attr_create_from_data(u_int32_t type, size_t length,
+pa_tnc_attr_t* ita_attr_create_from_data(uint32_t type, size_t length,
chunk_t value)
{
switch (type)
* @param length attribute length
* @param value attribute value or segment
*/
-pa_tnc_attr_t* ita_attr_create_from_data(u_int32_t type, size_t length,
+pa_tnc_attr_t* ita_attr_create_from_data(uint32_t type, size_t length,
chunk_t value);
#endif /** ITA_ATTR_H_ @}*/
}
METHOD(pa_tnc_attr_t, process, status_t,
- private_ita_attr_angel_t *this, u_int32_t *offset)
+ private_ita_attr_angel_t *this, uint32_t *offset)
{
return SUCCESS;
}
}
METHOD(pa_tnc_attr_t, process, status_t,
- private_ita_attr_command_t *this, u_int32_t *offset)
+ private_ita_attr_command_t *this, uint32_t *offset)
{
*offset = 0;
}
METHOD(pa_tnc_attr_t, process, status_t,
- private_ita_attr_dummy_t *this, u_int32_t *offset)
+ private_ita_attr_dummy_t *this, uint32_t *offset)
{
*offset = 0;
}
METHOD(pa_tnc_attr_t, process, status_t,
- private_ita_attr_get_settings_t *this, u_int32_t *offset)
+ private_ita_attr_get_settings_t *this, uint32_t *offset)
{
bio_reader_t *reader;
- u_int32_t count;
+ uint32_t count;
chunk_t name;
status_t status = FAILED;
}
METHOD(pa_tnc_attr_t, process, status_t,
- private_ita_attr_settings_t *this, u_int32_t *offset)
+ private_ita_attr_settings_t *this, uint32_t *offset)
{
bio_reader_t *reader;
- u_int32_t count;
+ uint32_t count;
chunk_t name, value;
entry_t *entry;
status_t status = FAILED;
#include <library.h>
#include <bio/bio_reader.h>
-typedef pa_tnc_attr_t* (*pa_tnc_attr_create_t)(u_int32_t type, size_t length,
+typedef pa_tnc_attr_t* (*pa_tnc_attr_create_t)(uint32_t type, size_t length,
chunk_t value);
/**
{
tcg_pts_attr_req_file_meas_t *attr_cast;
char *pathname;
- u_int16_t request_id;
+ uint16_t request_id;
bool is_directory;
- u_int32_t delimiter;
+ uint32_t delimiter;
pts_file_meas_t *measurements;
pen_type_t error_code;
tcg_pts_attr_req_file_meta_t *attr_cast;
char *pathname;
bool is_directory;
- u_int8_t delimiter;
+ uint8_t delimiter;
pts_file_meta_t *metadata;
pen_type_t error_code;
pts_comp_evidence_t *evid;
pts_component_t *comp;
pen_type_t error_code;
- u_int32_t depth;
- u_int8_t flags;
+ uint32_t depth;
+ uint8_t flags;
status_t status;
enumerator_t *e;
/**
* Maximum PA-TNC message size for this TNCCS connection
*/
- u_int32_t max_msg_len;
+ uint32_t max_msg_len;
/**
* PA-TNC attribute segmentation contracts associated with TNCCS connection
}
METHOD(imc_state_t, set_max_msg_len, void,
- private_imc_attestation_state_t *this, u_int32_t max_msg_len)
+ private_imc_attestation_state_t *this, uint32_t max_msg_len)
{
this->max_msg_len = max_msg_len;
}
-METHOD(imc_state_t, get_max_msg_len, u_int32_t,
+METHOD(imc_state_t, get_max_msg_len, uint32_t,
private_imc_attestation_state_t *this)
{
return this->max_msg_len;
METHOD(imc_attestation_state_t, create_component, pts_component_t*,
private_imc_attestation_state_t *this, pts_comp_func_name_t *name,
- u_int32_t depth)
+ uint32_t depth)
{
enumerator_t *enumerator;
pts_component_t *component;
* @return created functional component instance or NULL
*/
pts_component_t* (*create_component)(imc_attestation_state_t *this,
- pts_comp_func_name_t *name, u_int32_t depth);
+ pts_comp_func_name_t *name, uint32_t depth);
/**
* Add an entry to the Component Evidence cache list
/**
* Maximum PA-TNC message size for this TNCCS connection
*/
- u_int32_t max_msg_len;
+ uint32_t max_msg_len;
/**
* PA-TNC attribute segmentation contracts associated with TNCCS connection
}
METHOD(imc_state_t, set_max_msg_len, void,
- private_imc_hcd_state_t *this, u_int32_t max_msg_len)
+ private_imc_hcd_state_t *this, uint32_t max_msg_len)
{
this->max_msg_len = max_msg_len;
}
-METHOD(imc_state_t, get_max_msg_len, u_int32_t,
+METHOD(imc_state_t, get_max_msg_len, uint32_t,
private_imc_hcd_state_t *this)
{
return this->max_msg_len;
static void add_numeric_version(imc_msg_t *msg)
{
pa_tnc_attr_t *attr;
- u_int32_t major, minor;
+ uint32_t major, minor;
os->get_numeric_version(os, &major, &minor);
DBG1(DBG_IMC, "operating system numeric version is %d.%d",
/**
* Maximum PA-TNC message size for this TNCCS connection
*/
- u_int32_t max_msg_len;
+ uint32_t max_msg_len;
/**
* PA-TNC attribute segmentation contracts associated with TNCCS connection
}
METHOD(imc_state_t, set_max_msg_len, void,
- private_imc_os_state_t *this, u_int32_t max_msg_len)
+ private_imc_os_state_t *this, uint32_t max_msg_len)
{
this->max_msg_len = max_msg_len;
}
-METHOD(imc_state_t, get_max_msg_len, u_int32_t,
+METHOD(imc_state_t, get_max_msg_len, uint32_t,
private_imc_os_state_t *this)
{
return this->max_msg_len;
while (fgets(buf, sizeof(buf), file))
{
u_char *pos;
- u_int8_t new_protocol, protocol;
- u_int16_t new_port, port;
+ uint8_t new_protocol, protocol;
+ uint16_t new_port, port;
int i;
enumerator_t *enumerator;
bool allowed, found = FALSE;
/**
* Maximum PA-TNC message size for this TNCCS connection
*/
- u_int32_t max_msg_len;
+ uint32_t max_msg_len;
/**
* PA-TNC attribute segmentation contracts associated with TNCCS connection
}
METHOD(imc_state_t, set_max_msg_len, void,
- private_imc_scanner_state_t *this, u_int32_t max_msg_len)
+ private_imc_scanner_state_t *this, uint32_t max_msg_len)
{
this->max_msg_len = max_msg_len;
}
-METHOD(imc_state_t, get_max_msg_len, u_int32_t,
+METHOD(imc_state_t, get_max_msg_len, uint32_t,
private_imc_scanner_state_t *this)
{
return this->max_msg_len;
/**
* Maximum PA-TNC message size for this TNCCS connection
*/
- u_int32_t max_msg_len;
+ uint32_t max_msg_len;
/**
* PA-TNC attribute segmentation contracts associated with TNCCS connection
/**
* Event ID Epoch
*/
- u_int32_t eid_epoch;
+ uint32_t eid_epoch;
};
METHOD(imc_state_t, get_connection_id, TNC_ConnectionID,
}
METHOD(imc_state_t, set_max_msg_len, void,
- private_imc_swid_state_t *this, u_int32_t max_msg_len)
+ private_imc_swid_state_t *this, uint32_t max_msg_len)
{
this->max_msg_len = max_msg_len;
}
-METHOD(imc_state_t, get_max_msg_len, u_int32_t,
+METHOD(imc_state_t, get_max_msg_len, uint32_t,
private_imc_swid_state_t *this)
{
return this->max_msg_len;
free(this);
}
-METHOD(imc_swid_state_t, get_eid_epoch, u_int32_t,
+METHOD(imc_swid_state_t, get_eid_epoch, uint32_t,
private_imc_swid_state_t *this)
{
return this->eid_epoch;
imc_state_t *imc_swid_state_create(TNC_ConnectionID connection_id)
{
private_imc_swid_state_t *this;
- u_int32_t eid_epoch;
+ uint32_t eid_epoch;
nonce_gen_t *ng;
ng = lib->crypto->create_nonce_gen(lib->crypto);
- if (!ng || !ng->get_nonce(ng, 4, (u_int8_t*)&eid_epoch))
+ if (!ng || !ng->get_nonce(ng, 4, (uint8_t*)&eid_epoch))
{
DBG1(DBG_TNC, "failed to generate random EID epoch value");
DESTROY_IF(ng);
*
* @return Event ID Epoch
*/
- u_int32_t (*get_eid_epoch)(imc_swid_state_t *this);
+ uint32_t (*get_eid_epoch)(imc_swid_state_t *this);
};
/**
* Maximum PA-TNC message size for this TNCCS connection
*/
- u_int32_t max_msg_len;
+ uint32_t max_msg_len;
/**
* PA-TNC attribute segmentation contracts associated with TNCCS connection
}
METHOD(imc_state_t, set_max_msg_len, void,
- private_imc_test_state_t *this, u_int32_t max_msg_len)
+ private_imc_test_state_t *this, uint32_t max_msg_len)
{
this->max_msg_len = max_msg_len;
}
-METHOD(imc_state_t, get_max_msg_len, u_int32_t,
+METHOD(imc_state_t, get_max_msg_len, uint32_t,
private_imc_test_state_t *this)
{
return this->max_msg_len;
time_t timestamp;
int id, last_id = 0, ar_id = 0, last_ar_id = 0, device_count = 0, trusted;
int session_id, rec;
- u_int32_t ar_id_type;
+ uint32_t ar_id_type;
u_int tstamp;
e = this->db->query(this->db,
typedef struct port_range_t port_range_t;
struct port_range_t {
- u_int16_t start, stop;
+ uint16_t start, stop;
};
/**
* Parse a TCP or UDP port list from an argument string
*/
-static linked_list_t* get_port_list(u_int8_t protocol_family,
+static linked_list_t* get_port_list(uint8_t protocol_family,
bool closed_port_policy, char *arg_str)
{
chunk_t port_list, port_item, port_start;
{
TNC_IMV_Evaluation_Result eval;
TNC_IMV_Action_Recommendation rec;
- u_int8_t protocol_family, protocol;
- u_int16_t port;
+ uint8_t protocol_family, protocol;
+ uint16_t port;
bool closed_port_policy, blocked, first;
char result_str[BUF_LEN], *pos, *protocol_str;
size_t len;
* @param depth Sub-component depth
* @param pts_db PTS measurement database
*/
-pts_component_t* pts_ita_comp_ima_create(u_int32_t depth,
+pts_component_t* pts_ita_comp_ima_create(uint32_t depth,
pts_database_t *pts_db);
#endif /** PTS_ITA_COMP_IMA_H_ @}*/
/**
* Sub-component depth
*/
- u_int32_t depth;
+ uint32_t depth;
/**
* PTS measurement database
return this->name;
}
-METHOD(pts_component_t, get_evidence_flags, u_int8_t,
+METHOD(pts_component_t, get_evidence_flags, uint8_t,
pts_ita_comp_tboot_t *this)
{
return PTS_REQ_FUNC_COMP_EVID_PCR;
}
-METHOD(pts_component_t, get_depth, u_int32_t,
+METHOD(pts_component_t, get_depth, uint32_t,
pts_ita_comp_tboot_t *this)
{
return this->depth;
}
METHOD(pts_component_t, measure, status_t,
- pts_ita_comp_tboot_t *this, u_int8_t qualifier, pts_t *pts,
+ pts_ita_comp_tboot_t *this, uint8_t qualifier, pts_t *pts,
pts_comp_evidence_t **evidence)
{
pts_comp_evidence_t *evid;
char *meas_hex, *pcr_before_hex, *pcr_after_hex;
chunk_t measurement, pcr_before, pcr_after;
- u_int32_t extended_pcr;
+ uint32_t extended_pcr;
switch (this->seq_no++)
{
}
METHOD(pts_component_t, verify, status_t,
- pts_ita_comp_tboot_t *this, u_int8_t qualifier,pts_t *pts,
+ pts_ita_comp_tboot_t *this, uint8_t qualifier,pts_t *pts,
pts_comp_evidence_t *evidence)
{
bool has_pcr_info;
- u_int32_t extended_pcr, vid, name;
+ uint32_t extended_pcr, vid, name;
enum_name_t *names;
pts_meas_algorithms_t algo;
pts_pcr_transform_t transform;
}
METHOD(pts_component_t, finalize, bool,
- pts_ita_comp_tboot_t *this, u_int8_t qualifier, bio_writer_t *result)
+ pts_ita_comp_tboot_t *this, uint8_t qualifier, bio_writer_t *result)
{
char result_buf[BUF_LEN];
pts_ita_comp_tboot_t *this)
{
int count;
- u_int32_t vid, name;
+ uint32_t vid, name;
enum_name_t *names;
if (ref_put(&this->ref))
/**
* See header
*/
-pts_component_t *pts_ita_comp_tboot_create(u_int32_t depth,
+pts_component_t *pts_ita_comp_tboot_create(uint32_t depth,
pts_database_t *pts_db)
{
pts_ita_comp_tboot_t *this;
* @param depth Sub-component depth
* @param pts_db PTS measurement database
*/
-pts_component_t* pts_ita_comp_tboot_create(u_int32_t depth,
+pts_component_t* pts_ita_comp_tboot_create(uint32_t depth,
pts_database_t *pts_db);
#endif /** PTS_ITA_COMP_TBOOT_H_ @}*/
/**
* Sub-component depth
*/
- u_int32_t depth;
+ uint32_t depth;
/**
* PTS measurement database
return this->name;
}
-METHOD(pts_component_t, get_evidence_flags, u_int8_t,
+METHOD(pts_component_t, get_evidence_flags, uint8_t,
pts_ita_comp_tgrub_t *this)
{
return PTS_REQ_FUNC_COMP_EVID_PCR;
}
-METHOD(pts_component_t, get_depth, u_int32_t,
+METHOD(pts_component_t, get_depth, uint32_t,
pts_ita_comp_tgrub_t *this)
{
return this->depth;
}
METHOD(pts_component_t, measure, status_t,
- pts_ita_comp_tgrub_t *this, u_int8_t qualifier, pts_t *pts,
+ pts_ita_comp_tgrub_t *this, uint8_t qualifier, pts_t *pts,
pts_comp_evidence_t **evidence)
{
size_t pcr_len;
pts_pcr_transform_t pcr_transform;
pts_meas_algorithms_t hash_algo;
pts_comp_evidence_t *evid;
- u_int32_t extended_pcr;
+ uint32_t extended_pcr;
time_t measurement_time;
chunk_t measurement, pcr_before, pcr_after;
}
METHOD(pts_component_t, verify, status_t,
- pts_ita_comp_tgrub_t *this, u_int8_t qualifier, pts_t *pts,
+ pts_ita_comp_tgrub_t *this, uint8_t qualifier, pts_t *pts,
pts_comp_evidence_t *evidence)
{
bool has_pcr_info;
- u_int32_t extended_pcr;
+ uint32_t extended_pcr;
pts_meas_algorithms_t algo;
pts_pcr_transform_t transform;
pts_pcr_t *pcrs;
}
METHOD(pts_component_t, finalize, bool,
- pts_ita_comp_tgrub_t *this, u_int8_t qualifier, bio_writer_t *result)
+ pts_ita_comp_tgrub_t *this, uint8_t qualifier, bio_writer_t *result)
{
return FALSE;
}
/**
* See header
*/
-pts_component_t *pts_ita_comp_tgrub_create(u_int32_t depth,
+pts_component_t *pts_ita_comp_tgrub_create(uint32_t depth,
pts_database_t *pts_db)
{
pts_ita_comp_tgrub_t *this;
* @param depth Sub-component depth
* @param pts_db PTS measurement database
*/
-pts_component_t* pts_ita_comp_tgrub_create(u_int32_t depth,
+pts_component_t* pts_ita_comp_tgrub_create(uint32_t depth,
pts_database_t *pts_db);
#endif /** PTS_ITA_COMP_TGRUB_H_ @}*/
/**
* Sub-Component Depth
*/
- u_int32_t depth;
+ uint32_t depth;
/**
* Measurement Time
/**
* PCR the measurement was extended into
*/
- u_int32_t extended_pcr;
+ uint32_t extended_pcr;
/**
* PCR value before extension
};
METHOD(pts_comp_evidence_t, get_comp_func_name, pts_comp_func_name_t*,
- private_pts_comp_evidence_t *this, u_int32_t *depth)
+ private_pts_comp_evidence_t *this, uint32_t *depth)
{
if (depth)
{
return this->name;
}
-METHOD(pts_comp_evidence_t, get_extended_pcr, u_int32_t,
+METHOD(pts_comp_evidence_t, get_extended_pcr, uint32_t,
private_pts_comp_evidence_t *this)
{
return this->extended_pcr;
}
METHOD(pts_comp_evidence_t, get_measurement, chunk_t,
- private_pts_comp_evidence_t *this, u_int32_t *extended_pcr,
+ private_pts_comp_evidence_t *this, uint32_t *extended_pcr,
pts_meas_algorithms_t *algo, pts_pcr_transform_t *transform,
time_t *measurement_time)
{
* See header
*/
pts_comp_evidence_t *pts_comp_evidence_create(pts_comp_func_name_t *name,
- u_int32_t depth,
- u_int32_t extended_pcr,
+ uint32_t depth,
+ uint32_t extended_pcr,
pts_meas_algorithms_t algo,
pts_pcr_transform_t transform,
time_t measurement_time,
* @result Component Functional Name
*/
pts_comp_func_name_t* (*get_comp_func_name)(pts_comp_evidence_t *this,
- u_int32_t *depth);
+ uint32_t *depth);
/**
* Gets the PCR the measurement was extended into
*
* @result PCR the measurement was extended into
*/
- u_int32_t (*get_extended_pcr)(pts_comp_evidence_t *this);
+ uint32_t (*get_extended_pcr)(pts_comp_evidence_t *this);
/**
* Gets the measurement and the algorithms used
* @result Measurement hash value
*/
chunk_t (*get_measurement)(pts_comp_evidence_t *this,
- u_int32_t *extended_pcr,
+ uint32_t *extended_pcr,
pts_meas_algorithms_t *algo,
pts_pcr_transform_t *transform,
time_t *measurement_time);
* @param measurement Measurement hash value
*/
pts_comp_evidence_t* pts_comp_evidence_create(pts_comp_func_name_t *name,
- u_int32_t depth,
- u_int32_t extended_pcr,
+ uint32_t depth,
+ uint32_t extended_pcr,
pts_meas_algorithms_t algo,
pts_pcr_transform_t transform,
time_t measurement_time,
/**
* PTS Component Functional Name Vendor ID
*/
- u_int32_t vid;
+ uint32_t vid;
/**
* PTS Component Functional Name
*/
- u_int32_t name;
+ uint32_t name;
/**
* PTS Component Functional Name Qualifier
*/
- u_int8_t qualifier;
+ uint8_t qualifier;
};
-METHOD(pts_comp_func_name_t, get_vendor_id, u_int32_t,
+METHOD(pts_comp_func_name_t, get_vendor_id, uint32_t,
private_pts_comp_func_name_t *this)
{
return this->vid;
}
-METHOD(pts_comp_func_name_t, get_name, u_int32_t,
+METHOD(pts_comp_func_name_t, get_name, uint32_t,
private_pts_comp_func_name_t *this)
{
return this->name;
}
-METHOD(pts_comp_func_name_t, get_qualifier, u_int8_t,
+METHOD(pts_comp_func_name_t, get_qualifier, uint8_t,
private_pts_comp_func_name_t *this)
{
return this->qualifier;
}
METHOD(pts_comp_func_name_t, set_qualifier, void,
- private_pts_comp_func_name_t *this, u_int8_t qualifier)
+ private_pts_comp_func_name_t *this, uint8_t qualifier)
{
this->qualifier = qualifier;
}
/**
* See header
*/
-pts_comp_func_name_t* pts_comp_func_name_create(u_int32_t vid, u_int32_t name,
- u_int8_t qualifier)
+pts_comp_func_name_t* pts_comp_func_name_create(uint32_t vid, uint32_t name,
+ uint8_t qualifier)
{
private_pts_comp_func_name_t *this;
*
* @return PTS Component Functional Name Vendor ID
*/
- u_int32_t (*get_vendor_id)(pts_comp_func_name_t *this);
+ uint32_t (*get_vendor_id)(pts_comp_func_name_t *this);
/**
* Get the PTS Component Functional Name
*
* @return PTS Component Functional Name
*/
- u_int32_t (*get_name)(pts_comp_func_name_t *this);
+ uint32_t (*get_name)(pts_comp_func_name_t *this);
/**
* Get the PTS Component Functional Name Qualifier
*
* @return PTS Component Functional Name Qualifier
*/
- u_int8_t (*get_qualifier)(pts_comp_func_name_t *this);
+ uint8_t (*get_qualifier)(pts_comp_func_name_t *this);
/**
* Set the PTS Component Functional Name Qualifier
*
* @param qualifier PTS Component Functional Name Qualifier to be set
*/
- void (*set_qualifier)(pts_comp_func_name_t *this, u_int8_t qualifier);
+ void (*set_qualifier)(pts_comp_func_name_t *this, uint8_t qualifier);
/**
* Check to PTS Component Functional Names for equality
* @param name PTS Component Functional Name
* @param qualifier PTS Component Functional Name Qualifier
*/
-pts_comp_func_name_t* pts_comp_func_name_create(u_int32_t vid, u_int32_t name,
- u_int8_t qualifier);
+pts_comp_func_name_t* pts_comp_func_name_create(uint32_t vid, uint32_t name,
+ uint8_t qualifier);
#endif /** PTS_FUNC_COMP_NAME_H_ @}*/
*
* @return PTS Component Functional Name
*/
- u_int8_t (*get_evidence_flags)(pts_component_t *this);
+ uint8_t (*get_evidence_flags)(pts_component_t *this);
/**
* Get the PTS Sub-component Depth
*
* @return PTS Sub-component Depth
*/
- u_int32_t (*get_depth)(pts_component_t *this);
+ uint32_t (*get_depth)(pts_component_t *this);
/**
* Do evidence measurements on the PTS Functional Component
* @param measurements additional file measurements (NULL if not present)
* @return status return code
*/
- status_t (*measure)(pts_component_t *this, u_int8_t qualifier, pts_t *pts,
+ status_t (*measure)(pts_component_t *this, uint8_t qualifier, pts_t *pts,
pts_comp_evidence_t** evidence);
/**
* @param evidence component evidence measurement to be verified
* @return status return code
*/
- status_t (*verify)(pts_component_t *this, u_int8_t qualifier, pts_t *pts,
+ status_t (*verify)(pts_component_t *this, uint8_t qualifier, pts_t *pts,
pts_comp_evidence_t *evidence);
/**
* @param result writer appending concise measurement result
* @return TRUE if finalization successful
*/
- bool (*finalize)(pts_component_t *this, u_int8_t qualifier,
+ bool (*finalize)(pts_component_t *this, uint8_t qualifier,
bio_writer_t *result);
/**
/**
* Vendor-Specific Component Functional Name
*/
- u_int32_t name;
+ uint32_t name;
/**
* Functional Component creation method
}
METHOD(pts_component_manager_t, add_component, void,
- private_pts_component_manager_t *this, pen_t vendor_id, u_int32_t name,
+ private_pts_component_manager_t *this, pen_t vendor_id, uint32_t name,
pts_component_create_t create)
{
enumerator_t *enumerator;
enumerator->destroy(enumerator);
}
-METHOD(pts_component_manager_t, get_qualifier, u_int8_t,
+METHOD(pts_component_manager_t, get_qualifier, uint8_t,
private_pts_component_manager_t *this, pts_comp_func_name_t *name,
char *flags)
{
enumerator_t *enumerator;
vendor_entry_t *entry;
- u_int8_t qualifier, size, flag, type = 0;
+ uint8_t qualifier, size, flag, type = 0;
int i;
enumerator = this->list->create_enumerator(this->list);
METHOD(pts_component_manager_t, create, pts_component_t*,
private_pts_component_manager_t *this,
- pts_comp_func_name_t *name, u_int32_t depth, pts_database_t *pts_db)
+ pts_comp_func_name_t *name, uint32_t depth, pts_database_t *pts_db)
{
enumerator_t *enumerator, *e2;
vendor_entry_t *entry;
#include <library.h>
#include <pen/pen.h>
-typedef pts_component_t* (*pts_component_create_t)(u_int32_t depth,
+typedef pts_component_t* (*pts_component_create_t)(uint32_t depth,
pts_database_t *pts_db);
/**
* @param create Functional Component creation method
*/
void (*add_component)(pts_component_manager_t *this, pen_t vendor_id,
- u_int32_t name, pts_component_create_t create);
+ uint32_t name, pts_component_create_t create);
/**
* Remove vendor-specific components and associated namespace
* @param flags Qualifier Flags as a string in a char buffer
* @return Qualifier Type
*/
- u_int8_t (*get_qualifier)(pts_component_manager_t *this,
+ uint8_t (*get_qualifier)(pts_component_manager_t *this,
pts_comp_func_name_t *name, char *flags);
/**
* @return Component object if supported, NULL else
*/
pts_component_t* (*create)(pts_component_manager_t *this,
- pts_comp_func_name_t *name, u_int32_t depth,
+ pts_comp_func_name_t *name, uint32_t depth,
pts_database_t *pts_db);
/**
#ifdef TSS_TROUSERS
METHOD(pts_t, read_pcr, bool,
- private_pts_t *this, u_int32_t pcr_num, chunk_t *pcr_value)
+ private_pts_t *this, uint32_t pcr_num, chunk_t *pcr_value)
{
TSS_HCONTEXT hContext;
TSS_HTPM hTPM;
}
METHOD(pts_t, extend_pcr, bool,
- private_pts_t *this, u_int32_t pcr_num, chunk_t input, chunk_t *output)
+ private_pts_t *this, uint32_t pcr_num, chunk_t input, chunk_t *output)
{
TSS_HCONTEXT hContext;
TSS_HTPM hTPM;
TSS_RESULT result;
- u_int32_t pcr_length;
+ uint32_t pcr_length;
chunk_t pcr_value = chunk_empty;
result = Tspi_Context_Create(&hContext);
TSS_RESULT result;
chunk_t quote_info;
BYTE* versionInfo;
- u_int32_t versionInfoSize, pcr;
+ uint32_t versionInfoSize, pcr;
enumerator_t *enumerator;
bool success = FALSE;
#else /* TSS_TROUSERS */
METHOD(pts_t, read_pcr, bool,
- private_pts_t *this, u_int32_t pcr_num, chunk_t *pcr_value)
+ private_pts_t *this, uint32_t pcr_num, chunk_t *pcr_value)
{
return FALSE;
}
METHOD(pts_t, extend_pcr, bool,
- private_pts_t *this, u_int32_t pcr_num, chunk_t input, chunk_t *output)
+ private_pts_t *this, uint32_t pcr_num, chunk_t input, chunk_t *output)
{
return FALSE;
}
TSS_HCONTEXT hContext;
TSS_HTPM hTPM;
TSS_RESULT result;
- u_int32_t version_info_len;
+ uint32_t version_info_len;
result = Tspi_Context_Create(&hContext);
if (result != TSS_SUCCESS)
* @param pcr_value Chunk to save pcr read output
* @return NULL in case of TSS error, PCR value otherwise
*/
- bool (*read_pcr)(pts_t *this, u_int32_t pcr_num, chunk_t *pcr_value);
+ bool (*read_pcr)(pts_t *this, uint32_t pcr_num, chunk_t *pcr_value);
/**
* Extends given PCR with given value
* @param output Chunk to save PCR value after extension
* @return FALSE in case of TSS error, TRUE otherwise
*/
- bool (*extend_pcr)(pts_t *this, u_int32_t pcr_num, chunk_t input,
+ bool (*extend_pcr)(pts_t *this, uint32_t pcr_num, chunk_t input,
chunk_t *output);
/**
/**
* ID of PTS File Measurement Request
*/
- u_int16_t request_id;
+ uint16_t request_id;
/**
* List of File Measurements
}
}
-METHOD(pts_file_meas_t, get_request_id, u_int16_t,
+METHOD(pts_file_meas_t, get_request_id, uint16_t,
private_pts_file_meas_t *this)
{
return this->request_id;
/**
* See header
*/
-pts_file_meas_t *pts_file_meas_create(u_int16_t request_id)
+pts_file_meas_t *pts_file_meas_create(uint16_t request_id)
{
private_pts_file_meas_t *this;
/**
* See header
*/
-pts_file_meas_t *pts_file_meas_create_from_path(u_int16_t request_id,
+pts_file_meas_t *pts_file_meas_create_from_path(uint16_t request_id,
char *pathname, bool is_dir, bool use_rel_name,
pts_meas_algorithms_t alg)
{
*
* @return ID of PTS File Measurement Request
*/
- u_int16_t (*get_request_id)(pts_file_meas_t *this);
+ uint16_t (*get_request_id)(pts_file_meas_t *this);
/**
* Get the number of measured files
*
* @param request_id ID of PTS File Measurement Request
*/
-pts_file_meas_t* pts_file_meas_create(u_int16_t request_id);
+pts_file_meas_t* pts_file_meas_create(uint16_t request_id);
/**
* Creates a pts_file_meas_t object measuring a file/directory
* @param use_rel_name TRUE if relative filenames are to be used
* @param alg PTS hash measurement algorithm to be used
*/
-pts_file_meas_t* pts_file_meas_create_from_path(u_int16_t request_id,
+pts_file_meas_t* pts_file_meas_create_from_path(uint16_t request_id,
char* pathname, bool is_dir, bool use_rel_name,
pts_meas_algorithms_t alg);
*/
struct pts_file_metadata_t {
pts_file_type_t type;
- u_int64_t filesize;
- u_int64_t created;
- u_int64_t modified;
- u_int64_t accessed;
- u_int64_t owner;
- u_int64_t group;
+ uint64_t filesize;
+ uint64_t created;
+ uint64_t modified;
+ uint64_t accessed;
+ uint64_t owner;
+ uint64_t group;
char *filename;
};
/**
* Number of extended PCR registers
*/
- u_int32_t pcr_count;
+ uint32_t pcr_count;
/**
* Highest extended PCR register
*/
- u_int32_t pcr_max;
+ uint32_t pcr_max;
/**
* Bitmap of extended PCR registers
*/
- u_int8_t pcr_select[PTS_PCR_MAX_NUM / 8];
+ uint8_t pcr_select[PTS_PCR_MAX_NUM / 8];
/**
* Hasher used to extend shadow PCRs
};
-METHOD(pts_pcr_t, get_count, u_int32_t,
+METHOD(pts_pcr_t, get_count, uint32_t,
private_pts_pcr_t *this)
{
return this->pcr_count;
}
METHOD(pts_pcr_t, select_pcr, bool,
- private_pts_pcr_t *this, u_int32_t pcr)
+ private_pts_pcr_t *this, uint32_t pcr)
{
- u_int32_t i, f;
+ uint32_t i, f;
if (pcr >= PTS_PCR_MAX_NUM)
{
/** implements enumerator_t */
enumerator_t public;
/** current PCR */
- u_int32_t pcr;
+ uint32_t pcr;
/** back reference to parent */
private_pts_pcr_t *pcrs;
} pcr_enumerator_t;
*/
static bool pcr_enumerator_enumerate(pcr_enumerator_t *this, ...)
{
- u_int32_t *pcr, i, f;
+ uint32_t *pcr, i, f;
va_list args;
va_start(args, this);
- pcr = va_arg(args, u_int32_t*);
+ pcr = va_arg(args, uint32_t*);
va_end(args);
while (this->pcr <= this->pcrs->pcr_max)
}
METHOD(pts_pcr_t, get, chunk_t,
- private_pts_pcr_t *this, u_int32_t pcr)
+ private_pts_pcr_t *this, uint32_t pcr)
{
return (pcr < PTS_PCR_MAX_NUM) ? this->pcrs[pcr] : chunk_empty;
}
METHOD(pts_pcr_t, set, bool,
- private_pts_pcr_t *this, u_int32_t pcr, chunk_t value)
+ private_pts_pcr_t *this, uint32_t pcr, chunk_t value)
{
if (value.len != PTS_PCR_LEN)
{
}
METHOD(pts_pcr_t, extend, chunk_t,
- private_pts_pcr_t *this, u_int32_t pcr, chunk_t measurement)
+ private_pts_pcr_t *this, uint32_t pcr, chunk_t measurement)
{
if (measurement.len != PTS_PCR_LEN)
{
{
chunk_t composite;
enumerator_t *enumerator;
- u_int16_t selection_size;
- u_int32_t pcr_field_size, pcr;
+ uint16_t selection_size;
+ uint32_t pcr_field_size, pcr;
u_char *pos;
selection_size = get_selection_size(this);
METHOD(pts_pcr_t, destroy, void,
private_pts_pcr_t *this)
{
- u_int32_t i;
+ uint32_t i;
for (i = 0; i < PTS_PCR_MAX_NUM; i++)
{
{
private_pts_pcr_t *this;
hasher_t *hasher;
- u_int32_t i;
+ uint32_t i;
hasher = lib->crypto->create_hasher(lib->crypto, HASH_SHA1);
if (!hasher)
*
* @return number of selected PCRs
*/
- u_int32_t (*get_count)(pts_pcr_t *this);
+ uint32_t (*get_count)(pts_pcr_t *this);
/**
* Mark a PCR as selected
* @param pcr index of PCR
* @return TRUE if PCR index exists
*/
- bool (*select_pcr)(pts_pcr_t *this, u_int32_t pcr);
+ bool (*select_pcr)(pts_pcr_t *this, uint32_t pcr);
/**
* Get the size of the selection field in bytes
* @param pcr index of PCR
* @return content of PCR
*/
- chunk_t (*get)(pts_pcr_t *this, u_int32_t pcr);
+ chunk_t (*get)(pts_pcr_t *this, uint32_t pcr);
/**
* Set the content of a PCR
* @param value new value of PCR
* @return TRUE if value could be set
*/
- bool (*set)(pts_pcr_t *this, u_int32_t pcr, chunk_t value);
+ bool (*set)(pts_pcr_t *this, uint32_t pcr, chunk_t value);
/**
* Extend the content of a PCR
* @param measurement measurment value to be extended into PCR
* @return new content of PCR
*/
- chunk_t (*extend)(pts_pcr_t *this, u_int32_t pcr, chunk_t measurement);
+ chunk_t (*extend)(pts_pcr_t *this, uint32_t pcr, chunk_t measurement);
/**
* Create a PCR Composite object over all selected PCRs
/**
* See header
*/
-pa_tnc_attr_t* pwg_attr_create_from_data(u_int32_t type, size_t length, chunk_t value)
+pa_tnc_attr_t* pwg_attr_create_from_data(uint32_t type, size_t length, chunk_t value)
{
switch (type)
{
* @param length attribute length
* @param value attribute value or segment
*/
-pa_tnc_attr_t* pwg_attr_create_from_data(u_int32_t type, size_t length,
+pa_tnc_attr_t* pwg_attr_create_from_data(uint32_t type, size_t length,
chunk_t value);
#endif /** PWG_ATTR_H_ @}*/
}
METHOD(pa_tnc_attr_t, process, status_t,
- private_pwg_attr_vendor_smi_code_t *this, u_int32_t *offset)
+ private_pwg_attr_vendor_smi_code_t *this, uint32_t *offset)
{
bio_reader_t *reader;
uint32_t vendor_smi_code;
/**
* Described in header.
*/
-pa_tnc_attr_t* swid_error_create(swid_error_code_t code, u_int32_t request_id,
- u_int32_t max_attr_size, char *description)
+pa_tnc_attr_t* swid_error_create(swid_error_code_t code, uint32_t request_id,
+ uint32_t max_attr_size, char *description)
{
bio_writer_t *writer;
chunk_t msg_info;
* @param max_attr_size Maximum IF-M attribute size (if applicable)
* @param description Optional description string or NULL
*/
-pa_tnc_attr_t* swid_error_create(swid_error_code_t code, u_int32_t request,
- u_int32_t max_attr_size, char *description);
+pa_tnc_attr_t* swid_error_create(swid_error_code_t code, uint32_t request,
+ uint32_t max_attr_size, char *description);
#endif /** SWID_ERROR_H_ @}*/
private_tcg_pts_attr_aik_t *this)
{
bio_writer_t *writer;
- u_int8_t flags = PTS_AIK_FLAGS_NONE;
+ uint8_t flags = PTS_AIK_FLAGS_NONE;
cred_encoding_type_t encoding_type = CERT_ASN1_DER;
chunk_t aik_blob;
}
METHOD(pa_tnc_attr_t, process, status_t,
- private_tcg_pts_attr_aik_t *this, u_int32_t *offset)
+ private_tcg_pts_attr_aik_t *this, uint32_t *offset)
{
bio_reader_t *reader;
- u_int8_t flags;
+ uint8_t flags;
certificate_type_t type;
chunk_t aik_blob;
}
METHOD(pa_tnc_attr_t, process, status_t,
- private_tcg_pts_attr_dh_nonce_finish_t *this, u_int32_t *offset)
+ private_tcg_pts_attr_dh_nonce_finish_t *this, uint32_t *offset)
{
bio_reader_t *reader;
- u_int8_t reserved, nonce_len;
- u_int16_t hash_algo;
+ uint8_t reserved, nonce_len;
+ uint16_t hash_algo;
*offset = 0;
*
* @return Length of nonce
*/
- u_int8_t (*get_nonce_len)(tcg_pts_attr_dh_nonce_finish_t *this);
+ uint8_t (*get_nonce_len)(tcg_pts_attr_dh_nonce_finish_t *this);
/**
* Get selected hash algorithm
/**
* Minimum acceptable length of nonce
*/
- u_int8_t min_nonce_len;
+ uint8_t min_nonce_len;
/**
* Diffie Hellman group set
}
METHOD(pa_tnc_attr_t, process, status_t,
- private_tcg_pts_attr_dh_nonce_params_req_t *this, u_int32_t *offset)
+ private_tcg_pts_attr_dh_nonce_params_req_t *this, uint32_t *offset)
{
bio_reader_t *reader;
- u_int8_t reserved;
- u_int16_t dh_groups;
+ uint8_t reserved;
+ uint16_t dh_groups;
*offset = 0;
}
}
-METHOD(tcg_pts_attr_dh_nonce_params_req_t, get_min_nonce_len, u_int8_t,
+METHOD(tcg_pts_attr_dh_nonce_params_req_t, get_min_nonce_len, uint8_t,
private_tcg_pts_attr_dh_nonce_params_req_t *this)
{
return this->min_nonce_len;
/**
* Described in header.
*/
-pa_tnc_attr_t *tcg_pts_attr_dh_nonce_params_req_create(u_int8_t min_nonce_len,
+pa_tnc_attr_t *tcg_pts_attr_dh_nonce_params_req_create(uint8_t min_nonce_len,
pts_dh_group_t dh_groups)
{
private_tcg_pts_attr_dh_nonce_params_req_t *this;
*
* @return Minimum acceptable length of nonce
*/
- u_int8_t (*get_min_nonce_len)(tcg_pts_attr_dh_nonce_params_req_t *this);
+ uint8_t (*get_min_nonce_len)(tcg_pts_attr_dh_nonce_params_req_t *this);
/**
* Get supported Diffie Hellman Groups
* @param min_nonce_len Minimum acceptable length of nonce
* @param dh_groups Initiator's supported DH groups
*/
-pa_tnc_attr_t* tcg_pts_attr_dh_nonce_params_req_create(u_int8_t min_nonce_len,
+pa_tnc_attr_t* tcg_pts_attr_dh_nonce_params_req_create(uint8_t min_nonce_len,
pts_dh_group_t dh_groups);
/**
}
METHOD(pa_tnc_attr_t, process, status_t,
- private_tcg_pts_attr_dh_nonce_params_resp_t *this, u_int32_t *offset)
+ private_tcg_pts_attr_dh_nonce_params_resp_t *this, uint32_t *offset)
{
bio_reader_t *reader;
- u_int32_t reserved;
- u_int8_t nonce_len;
- u_int16_t dh_group, hash_algo_set;
+ uint32_t reserved;
+ uint8_t nonce_len;
+ uint16_t dh_group, hash_algo_set;
*offset = 0;
{
bio_writer_t *writer;
enumerator_t *enumerator;
- u_int64_t count;
- u_int16_t request_id;
+ uint64_t count;
+ uint16_t request_id;
char *filename;
chunk_t measurement;
bool first = TRUE;
}
METHOD(pa_tnc_attr_t, process, status_t,
- private_tcg_pts_attr_file_meas_t *this, u_int32_t *offset)
+ private_tcg_pts_attr_file_meas_t *this, uint32_t *offset)
{
bio_reader_t *reader;
chunk_t measurement, filename;
}
METHOD(pa_tnc_attr_t, process, status_t,
- private_tcg_pts_attr_gen_attest_evid_t *this, u_int32_t *offset)
+ private_tcg_pts_attr_gen_attest_evid_t *this, uint32_t *offset)
{
bio_reader_t *reader;
- u_int32_t reserved;
+ uint32_t reserved;
*offset = 0;
}
METHOD(pa_tnc_attr_t, process, status_t,
- private_tcg_pts_attr_get_aik_t *this, u_int32_t *offset)
+ private_tcg_pts_attr_get_aik_t *this, uint32_t *offset)
{
bio_reader_t *reader;
- u_int32_t reserved;
+ uint32_t reserved;
*offset = 0;
}
METHOD(pa_tnc_attr_t, process, status_t,
- private_tcg_pts_attr_get_tpm_version_info_t *this, u_int32_t *offset)
+ private_tcg_pts_attr_get_tpm_version_info_t *this, uint32_t *offset)
{
bio_reader_t *reader;
- u_int32_t reserved;
+ uint32_t reserved;
*offset = 0;
}
METHOD(pa_tnc_attr_t, process, status_t,
- private_tcg_pts_attr_meas_algo_t *this, u_int32_t *offset)
+ private_tcg_pts_attr_meas_algo_t *this, uint32_t *offset)
{
bio_reader_t *reader;
- u_int16_t reserved, algorithms;
+ uint16_t reserved, algorithms;
*offset = 0;
}
METHOD(pa_tnc_attr_t, process, status_t,
- private_tcg_pts_attr_proto_caps_t *this, u_int32_t *offset)
+ private_tcg_pts_attr_proto_caps_t *this, uint32_t *offset)
{
bio_reader_t *reader;
- u_int16_t reserved, flags;
+ uint16_t reserved, flags;
*offset = 0;
/**
* Request ID
*/
- u_int16_t request_id;
+ uint16_t request_id;
/**
* UTF8 Encoding of Delimiter Character
*/
- u_int32_t delimiter;
+ uint32_t delimiter;
/**
* Fully Qualified File Pathname
METHOD(pa_tnc_attr_t, build, void,
private_tcg_pts_attr_req_file_meas_t *this)
{
- u_int8_t flags = PTS_REQ_FILE_MEAS_NO_FLAGS;
+ uint8_t flags = PTS_REQ_FILE_MEAS_NO_FLAGS;
chunk_t pathname;
bio_writer_t *writer;
}
METHOD(pa_tnc_attr_t, process, status_t,
- private_tcg_pts_attr_req_file_meas_t *this, u_int32_t *offset)
+ private_tcg_pts_attr_req_file_meas_t *this, uint32_t *offset)
{
bio_reader_t *reader;
- u_int8_t flags;
- u_int8_t reserved;
+ uint8_t flags;
+ uint8_t reserved;
chunk_t pathname;
*offset = 0;
return this->directory_flag;
}
-METHOD(tcg_pts_attr_req_file_meas_t, get_request_id, u_int16_t,
+METHOD(tcg_pts_attr_req_file_meas_t, get_request_id, uint16_t,
private_tcg_pts_attr_req_file_meas_t *this)
{
return this->request_id;
}
-METHOD(tcg_pts_attr_req_file_meas_t, get_delimiter, u_int32_t,
+METHOD(tcg_pts_attr_req_file_meas_t, get_delimiter, uint32_t,
private_tcg_pts_attr_req_file_meas_t *this)
{
return this->delimiter;
* Described in header.
*/
pa_tnc_attr_t *tcg_pts_attr_req_file_meas_create(bool directory_flag,
- u_int16_t request_id,
- u_int32_t delimiter,
+ uint16_t request_id,
+ uint32_t delimiter,
char *pathname)
{
private_tcg_pts_attr_req_file_meas_t *this;
*
* @return Request ID
*/
- u_int16_t (*get_request_id)(tcg_pts_attr_req_file_meas_t *this);
+ uint16_t (*get_request_id)(tcg_pts_attr_req_file_meas_t *this);
/**
* Get Delimiter
*
* @return UTF-8 encoding of a Delimiter Character
*/
- u_int32_t (*get_delimiter)(tcg_pts_attr_req_file_meas_t *this);
+ uint32_t (*get_delimiter)(tcg_pts_attr_req_file_meas_t *this);
/**
* Get Fully Qualified File Pathname
* @param pathname File Pathname
*/
pa_tnc_attr_t* tcg_pts_attr_req_file_meas_create(bool directory_flag,
- u_int16_t request_id,
- u_int32_t delimiter,
+ uint16_t request_id,
+ uint32_t delimiter,
char *pathname);
/**
/**
* UTF8 Encoding of Delimiter Character
*/
- u_int8_t delimiter;
+ uint8_t delimiter;
/**
* Fully Qualified File Pathname
METHOD(pa_tnc_attr_t, build, void,
private_tcg_pts_attr_req_file_meta_t *this)
{
- u_int8_t flags = PTS_REQ_FILE_META_NO_FLAGS;
+ uint8_t flags = PTS_REQ_FILE_META_NO_FLAGS;
chunk_t pathname;
bio_writer_t *writer;
}
METHOD(pa_tnc_attr_t, process, status_t,
- private_tcg_pts_attr_req_file_meta_t *this, u_int32_t *offset)
+ private_tcg_pts_attr_req_file_meta_t *this, uint32_t *offset)
{
bio_reader_t *reader;
- u_int8_t flags;
- u_int16_t reserved;
+ uint8_t flags;
+ uint16_t reserved;
chunk_t pathname;
*offset = 0;
return this->directory_flag;
}
-METHOD(tcg_pts_attr_req_file_meta_t, get_delimiter, u_int8_t,
+METHOD(tcg_pts_attr_req_file_meta_t, get_delimiter, uint8_t,
private_tcg_pts_attr_req_file_meta_t *this)
{
return this->delimiter;
* Described in header.
*/
pa_tnc_attr_t *tcg_pts_attr_req_file_meta_create(bool directory_flag,
- u_int8_t delimiter,
+ uint8_t delimiter,
char *pathname)
{
private_tcg_pts_attr_req_file_meta_t *this;
*
* @return UTF-8 encoding of a Delimiter Character
*/
- u_int8_t (*get_delimiter)(tcg_pts_attr_req_file_meta_t *this);
+ uint8_t (*get_delimiter)(tcg_pts_attr_req_file_meta_t *this);
/**
* Get Fully Qualified File Pathname
* @param pathname File Pathname
*/
pa_tnc_attr_t* tcg_pts_attr_req_file_meta_create(bool directory_flag,
- u_int8_t delimiter,
+ uint8_t delimiter,
char *pathname);
/**
* Functional component entry
*/
struct entry_t {
- u_int8_t flags;
- u_int32_t depth;
+ uint8_t flags;
+ uint32_t depth;
pts_comp_func_name_t *name;
};
/**
* Enumerate functional component entries
*/
-static bool entry_filter(void *null, entry_t **entry, u_int8_t *flags,
- void *i2, u_int32_t *depth, void *i3,
+static bool entry_filter(void *null, entry_t **entry, uint8_t *flags,
+ void *i2, uint32_t *depth, void *i3,
pts_comp_func_name_t **name)
{
*flags = (*entry)->flags;
}
METHOD(pa_tnc_attr_t, process, status_t,
- private_tcg_pts_attr_req_func_comp_evid_t *this, u_int32_t *offset)
+ private_tcg_pts_attr_req_func_comp_evid_t *this, uint32_t *offset)
{
bio_reader_t *reader;
- u_int32_t depth, vendor_id, name;
- u_int8_t flags, fam_and_qualifier, qualifier;
+ uint32_t depth, vendor_id, name;
+ uint8_t flags, fam_and_qualifier, qualifier;
status_t status = FAILED;
entry_t *entry = NULL;
}
METHOD(tcg_pts_attr_req_func_comp_evid_t, add_component, void,
- private_tcg_pts_attr_req_func_comp_evid_t *this, u_int8_t flags,
- u_int32_t depth, pts_comp_func_name_t *name)
+ private_tcg_pts_attr_req_func_comp_evid_t *this, uint8_t flags,
+ uint32_t depth, pts_comp_func_name_t *name)
{
entry_t *entry;
* @param name Functional Component Name
*/
void (*add_component)(tcg_pts_attr_req_func_comp_evid_t *this,
- u_int8_t flags, u_int32_t depth,
+ uint8_t flags, uint32_t depth,
pts_comp_func_name_t *name);
/**
bio_writer_t *writer;
bool has_pcr_info;
char utc_time_buf[25], *policy_uri;
- u_int8_t flags;
- u_int16_t len;
- u_int32_t depth, extended_pcr;
+ uint8_t flags;
+ uint16_t len;
+ uint32_t depth, extended_pcr;
pts_comp_func_name_t *name;
pts_meas_algorithms_t hash_algorithm;
pts_pcr_transform_t transform;
}
METHOD(pa_tnc_attr_t, process, status_t,
- private_tcg_pts_attr_simple_comp_evid_t *this, u_int32_t *offset)
+ private_tcg_pts_attr_simple_comp_evid_t *this, uint32_t *offset)
{
bio_reader_t *reader;
pts_comp_func_name_t *name;
- u_int8_t flags, fam_and_qualifier, qualifier, reserved;
- u_int8_t measurement_type, transform, validation;
- u_int16_t hash_algorithm, len;
- u_int32_t depth, vendor_id, comp_name, extended_pcr;
+ uint8_t flags, fam_and_qualifier, qualifier, reserved;
+ uint8_t measurement_type, transform, validation;
+ uint16_t hash_algorithm, len;
+ uint32_t depth, vendor_id, comp_name, extended_pcr;
chunk_t measurement, utc_time, policy_uri, pcr_before, pcr_after;
time_t measurement_time;
bool has_pcr_info = FALSE, has_validation = FALSE;
/**
* Set of flags for Simple Evidence Final
*/
- u_int8_t flags;
+ uint8_t flags;
/**
* Optional Composite Hash Algorithm
private_tcg_pts_attr_simple_evid_final_t *this)
{
bio_writer_t *writer;
- u_int8_t flags;
+ uint8_t flags;
if (this->value.ptr)
{
}
METHOD(pa_tnc_attr_t, process, status_t,
- private_tcg_pts_attr_simple_evid_final_t *this, u_int32_t *offset)
+ private_tcg_pts_attr_simple_evid_final_t *this, uint32_t *offset)
{
bio_reader_t *reader;
- u_int8_t flags, reserved;
- u_int16_t algorithm;
- u_int32_t pcr_comp_len, tpm_quote_sig_len, evid_sig_len;
+ uint8_t flags, reserved;
+ uint16_t algorithm;
+ uint32_t pcr_comp_len, tpm_quote_sig_len, evid_sig_len;
status_t status = FAILED;
*offset = 0;
return status;
}
-METHOD(tcg_pts_attr_simple_evid_final_t, get_quote_info, u_int8_t,
+METHOD(tcg_pts_attr_simple_evid_final_t, get_quote_info, uint8_t,
private_tcg_pts_attr_simple_evid_final_t *this,
pts_meas_algorithms_t *comp_hash_algo, chunk_t *pcr_comp, chunk_t *tpm_quote_sig)
{
/**
* Described in header.
*/
-pa_tnc_attr_t *tcg_pts_attr_simple_evid_final_create(u_int8_t flags,
+pa_tnc_attr_t *tcg_pts_attr_simple_evid_final_create(uint8_t flags,
pts_meas_algorithms_t comp_hash_algorithm,
chunk_t pcr_comp, chunk_t tpm_quote_sig)
{
* @param tpm_quote sig Optional TPM Quote Signature
* @return PTS_SIMPLE_EVID_FINAL flags
*/
- u_int8_t (*get_quote_info)(tcg_pts_attr_simple_evid_final_t *this,
+ uint8_t (*get_quote_info)(tcg_pts_attr_simple_evid_final_t *this,
pts_meas_algorithms_t *comp_hash_algo,
chunk_t *pcr_comp, chunk_t *tpm_quote_sig);
* @param tpm_quote_sign Optional TPM Quote Signature
*/
pa_tnc_attr_t* tcg_pts_attr_simple_evid_final_create(
- u_int8_t flags,
+ uint8_t flags,
pts_meas_algorithms_t comp_hash_algorithm,
chunk_t pcr_comp,
chunk_t tpm_quote_sign);
}
METHOD(pa_tnc_attr_t, process, status_t,
- private_tcg_pts_attr_tpm_version_info_t *this, u_int32_t *offset)
+ private_tcg_pts_attr_tpm_version_info_t *this, uint32_t *offset)
{
bio_reader_t *reader;
bio_writer_t *writer;
enumerator_t *enumerator;
pts_file_metadata_t *entry;
- u_int64_t number_of_files;
+ uint64_t number_of_files;
if (this->value.ptr)
{
}
METHOD(pa_tnc_attr_t, process, status_t,
- private_tcg_pts_attr_file_meta_t *this, u_int32_t *offset)
+ private_tcg_pts_attr_file_meta_t *this, uint32_t *offset)
{
bio_reader_t *reader;
pts_file_metadata_t *entry;
- u_int8_t type, reserved;
- u_int16_t len;
- u_int64_t number_of_files, filesize, created, modified, accessed;
- u_int64_t owner, group;
+ uint8_t type, reserved;
+ uint16_t len;
+ uint64_t number_of_files, filesize, created, modified, accessed;
+ uint64_t owner, group;
chunk_t filename;
status_t status = FAILED;
}
METHOD(pa_tnc_attr_t, process, status_t,
- private_tcg_seg_attr_max_size_t *this, u_int32_t *offset)
+ private_tcg_seg_attr_max_size_t *this, uint32_t *offset)
{
bio_reader_t *reader;
}
METHOD(pa_tnc_attr_t, process, status_t,
- private_tcg_seg_attr_next_seg_t *this, u_int32_t *offset)
+ private_tcg_seg_attr_next_seg_t *this, uint32_t *offset)
{
bio_reader_t *reader;
uint8_t flags;
}
METHOD(pa_tnc_attr_t, process, status_t,
- private_tcg_seg_attr_seg_env_t *this, u_int32_t *offset)
+ private_tcg_seg_attr_seg_env_t *this, uint32_t *offset)
{
bio_reader_t *reader;
/**
* SWID request flags
*/
- u_int8_t flags;
+ uint8_t flags;
/**
* Request ID
*/
- u_int32_t request_id;
+ uint32_t request_id;
/**
* Earliest EID
*/
- u_int32_t earliest_eid;
+ uint32_t earliest_eid;
/**
* List of Target Tag Identifiers
}
METHOD(pa_tnc_attr_t, process, status_t,
- private_tcg_swid_attr_req_t *this, u_int32_t *offset)
+ private_tcg_swid_attr_req_t *this, uint32_t *offset)
{
bio_reader_t *reader;
- u_int32_t tag_id_count;
+ uint32_t tag_id_count;
chunk_t tag_creator, unique_sw_id;
swid_tag_id_t *tag_id;
}
}
-METHOD(tcg_swid_attr_req_t, get_flags, u_int8_t,
+METHOD(tcg_swid_attr_req_t, get_flags, uint8_t,
private_tcg_swid_attr_req_t *this)
{
return this->flags;
}
-METHOD(tcg_swid_attr_req_t, get_request_id, u_int32_t,
+METHOD(tcg_swid_attr_req_t, get_request_id, uint32_t,
private_tcg_swid_attr_req_t *this)
{
return this->request_id;
}
-METHOD(tcg_swid_attr_req_t, get_earliest_eid, u_int32_t,
+METHOD(tcg_swid_attr_req_t, get_earliest_eid, uint32_t,
private_tcg_swid_attr_req_t *this)
{
return this->earliest_eid;
/**
* Described in header.
*/
-pa_tnc_attr_t *tcg_swid_attr_req_create(u_int8_t flags, u_int32_t request_id,
- u_int32_t eid)
+pa_tnc_attr_t *tcg_swid_attr_req_create(uint8_t flags, uint32_t request_id,
+ uint32_t eid)
{
private_tcg_swid_attr_req_t *this;
*
* @return Flags
*/
- u_int8_t (*get_flags)(tcg_swid_attr_req_t *this);
+ uint8_t (*get_flags)(tcg_swid_attr_req_t *this);
/**
* Get Request ID
*
* @return Request ID
*/
- u_int32_t (*get_request_id)(tcg_swid_attr_req_t *this);
+ uint32_t (*get_request_id)(tcg_swid_attr_req_t *this);
/**
* Get Earliest EID
*
* @return Event ID
*/
- u_int32_t (*get_earliest_eid)(tcg_swid_attr_req_t *this);
+ uint32_t (*get_earliest_eid)(tcg_swid_attr_req_t *this);
/**
* Add Tag ID
* @param request_id Request ID
* @param eid Earliest Event ID
*/
-pa_tnc_attr_t* tcg_swid_attr_req_create(u_int8_t flags, u_int32_t request_id,
- u_int32_t eid);
+pa_tnc_attr_t* tcg_swid_attr_req_create(uint8_t flags, uint32_t request_id,
+ uint32_t eid);
/**
* Creates an tcg_swid_attr_req_t object from received data
/**
* See header
*/
-pa_tnc_attr_t* tcg_attr_create_from_data(u_int32_t type, size_t length, chunk_t value)
+pa_tnc_attr_t* tcg_attr_create_from_data(uint32_t type, size_t length, chunk_t value)
{
switch (type)
{
* @param length attribute length
* @param value attribute value or segment
*/
-pa_tnc_attr_t* tcg_attr_create_from_data(u_int32_t type, size_t length,
+pa_tnc_attr_t* tcg_attr_create_from_data(uint32_t type, size_t length,
chunk_t value);
#endif /** TCG_ATTR_H_ @}*/
* The highest sequence number that was successfully verified
* and authenticated, or assigned in an outbound context
*/
- u_int32_t last_seqno;
+ uint32_t last_seqno;
/**
* The bit in the window of the highest authenticated sequence number
/**
* Returns TRUE if the supplied seqno is not already marked in the window
*/
-static bool check_window(private_esp_context_t *this, u_int32_t seqno)
+static bool check_window(private_esp_context_t *this, uint32_t seqno)
{
u_int offset;
}
METHOD(esp_context_t, verify_seqno, bool,
- private_esp_context_t *this, u_int32_t seqno)
+ private_esp_context_t *this, uint32_t seqno)
{
if (!this->inbound)
{
}
METHOD(esp_context_t, set_authenticated_seqno, void,
- private_esp_context_t *this, u_int32_t seqno)
+ private_esp_context_t *this, uint32_t seqno)
{
u_int i, shift;
}
}
-METHOD(esp_context_t, get_seqno, u_int32_t,
+METHOD(esp_context_t, get_seqno, uint32_t,
private_esp_context_t *this)
{
return this->last_seqno;
}
METHOD(esp_context_t, next_seqno, bool,
- private_esp_context_t *this, u_int32_t *seqno)
+ private_esp_context_t *this, uint32_t *seqno)
{
if (this->inbound || this->last_seqno == UINT32_MAX)
{ /* inbound or segno would cycle */
*
* @return current sequence number, in host byte order
*/
- u_int32_t (*get_seqno)(esp_context_t *this);
+ uint32_t (*get_seqno)(esp_context_t *this);
/**
* Allocate the next outbound ESP sequence number.
* @param seqno the sequence number, in host byte order
* @return FALSE if the sequence number cycled or inbound context
*/
- bool (*next_seqno)(esp_context_t *this, u_int32_t *seqno);
+ bool (*next_seqno)(esp_context_t *this, uint32_t *seqno);
/**
* Verify an ESP sequence number. Checks whether a packet with this
* @param seqno the sequence number to verify, in host byte order
* @return TRUE when sequence number is valid
*/
- bool (*verify_seqno)(esp_context_t *this, u_int32_t seqno);
+ bool (*verify_seqno)(esp_context_t *this, uint32_t seqno);
/**
* Adds a sequence number that was successfully verified and
* @param seqno verified and authenticated seq number in host byte order
*/
void (*set_authenticated_seqno)(esp_context_t *this,
- u_int32_t seqno);
+ uint32_t seqno);
/**
* Destroy an esp_context_t
/**
* Next Header info (e.g. IPPROTO_IPIP)
*/
- u_int8_t next_header;
+ uint8_t next_header;
};
return this->packet->set_data(this->packet, data);
}
-METHOD(packet_t, get_dscp, u_int8_t,
+METHOD(packet_t, get_dscp, uint8_t,
private_esp_packet_t *this)
{
return this->packet->get_dscp(this->packet);
}
METHOD(packet_t, set_dscp, void,
- private_esp_packet_t *this, u_int8_t value)
+ private_esp_packet_t *this, uint8_t value)
{
this->packet->set_dscp(this->packet, value);
}
}
METHOD(esp_packet_t, parse_header, bool,
- private_esp_packet_t *this, u_int32_t *spi)
+ private_esp_packet_t *this, uint32_t *spi)
{
bio_reader_t *reader;
- u_int32_t seq;
+ uint32_t seq;
reader = bio_reader_create(this->packet->get_data(this->packet));
if (!reader->read_uint32(reader, spi) ||
for (i = 0; i < padding.len; ++i)
{
- if (padding.ptr[i] != (u_int8_t)(i + 1))
+ if (padding.ptr[i] != (uint8_t)(i + 1))
{
return FALSE;
}
*/
static bool remove_padding(private_esp_packet_t *this, chunk_t plaintext)
{
- u_int8_t next_header, pad_length;
+ uint8_t next_header, pad_length;
chunk_t padding, payload;
bio_reader_t *reader;
private_esp_packet_t *this, esp_context_t *esp_context)
{
bio_reader_t *reader;
- u_int32_t spi, seq;
+ uint32_t spi, seq;
chunk_t data, iv, icv, aad, ciphertext, plaintext;
aead_t *aead;
for (i = 0; i < padding.len; ++i)
{
- padding.ptr[i] = (u_int8_t)(i + 1);
+ padding.ptr[i] = (uint8_t)(i + 1);
}
}
METHOD(esp_packet_t, encrypt, status_t,
- private_esp_packet_t *this, esp_context_t *esp_context, u_int32_t spi)
+ private_esp_packet_t *this, esp_context_t *esp_context, uint32_t spi)
{
chunk_t iv, icv, aad, padding, payload, ciphertext;
bio_writer_t *writer;
- u_int32_t next_seqno;
+ uint32_t next_seqno;
size_t blocksize, plainlen;
aead_t *aead;
iv_gen_t *iv_gen;
plainlen += padding.len;
/* len = spi, seq, IV, plaintext, ICV */
- writer = bio_writer_create(2 * sizeof(u_int32_t) + iv.len + plainlen +
+ writer = bio_writer_create(2 * sizeof(uint32_t) + iv.len + plainlen +
icv.len);
writer->write_uint32(writer, ntohl(spi));
writer->write_uint32(writer, next_seqno);
DBG3(DBG_ESP, "ESP before encryption:\n payload = %B\n padding = %B\n "
"padding length = %hhu, next header = %hhu", &payload, &padding,
- (u_int8_t)padding.len, this->next_header);
+ (uint8_t)padding.len, this->next_header);
/* encrypt/authenticate the content inline */
if (!aead->encrypt(aead, ciphertext, aad, iv, NULL))
return SUCCESS;
}
-METHOD(esp_packet_t, get_next_header, u_int8_t,
+METHOD(esp_packet_t, get_next_header, uint8_t,
private_esp_packet_t *this)
{
return this->next_header;
* @return TRUE when successful, FALSE otherwise (e.g. when the
* length of the packet is invalid)
*/
- bool (*parse_header)(esp_packet_t *this, u_int32_t *spi);
+ bool (*parse_header)(esp_packet_t *this, uint32_t *spi);
/**
* Authenticate and decrypt the packet. Also verifies the sequence number
* - NOT_FOUND if no suitable IV generator provided
*/
status_t (*encrypt)(esp_packet_t *this, esp_context_t *esp_context,
- u_int32_t spi);
+ uint32_t spi);
/**
* Get the next header field of a packet.
*
* @return next header field
*/
- u_int8_t (*get_next_header)(esp_packet_t *this);
+ uint8_t (*get_next_header)(esp_packet_t *this);
/**
* Get the plaintext payload of this packet.
* and unfortunately Android does not define a variant with BSD names.
*/
struct tcphdr {
- u_int16_t source;
- u_int16_t dest;
- u_int32_t seq;
- u_int32_t ack_seq;
- u_int16_t flags;
- u_int16_t window;
- u_int16_t check;
- u_int16_t urg_ptr;
+ uint16_t source;
+ uint16_t dest;
+ uint32_t seq;
+ uint32_t ack_seq;
+ uint16_t flags;
+ uint16_t window;
+ uint16_t check;
+ uint16_t urg_ptr;
} __attribute__((packed));
/**
* the BSD member names, but this is simpler and more consistent with the above.
*/
struct udphdr {
- u_int16_t source;
- u_int16_t dest;
- u_int16_t len;
- u_int16_t check;
+ uint16_t source;
+ uint16_t dest;
+ uint16_t len;
+ uint16_t check;
} __attribute__((packed));
typedef struct private_ip_packet_t private_ip_packet_t;
/**
* IP version
*/
- u_int8_t version;
+ uint8_t version;
/**
* Protocol|Next Header field
*/
- u_int8_t next_header;
+ uint8_t next_header;
};
-METHOD(ip_packet_t, get_version, u_int8_t,
+METHOD(ip_packet_t, get_version, uint8_t,
private_ip_packet_t *this)
{
return this->version;
return this->payload;
}
-METHOD(ip_packet_t, get_next_header, u_int8_t,
+METHOD(ip_packet_t, get_next_header, uint8_t,
private_ip_packet_t *this)
{
return this->next_header;
/**
* Parse transport protocol header
*/
-static bool parse_transport_header(chunk_t packet, u_int8_t proto,
- u_int16_t *sport, u_int16_t *dport)
+static bool parse_transport_header(chunk_t packet, uint8_t proto,
+ uint16_t *sport, uint16_t *dport)
{
switch (proto)
{
ip_packet_t *ip_packet_create(chunk_t packet)
{
private_ip_packet_t *this;
- u_int8_t version, next_header;
- u_int16_t sport = 0, dport = 0;
+ uint8_t version, next_header;
+ uint16_t sport = 0, dport = 0;
host_t *src, *dst;
chunk_t payload;
/**
* Calculate the checksum for the pseudo IP header
*/
-static u_int16_t pseudo_header_checksum(host_t *src, host_t *dst,
- u_int8_t proto, chunk_t payload)
+static uint16_t pseudo_header_checksum(host_t *src, host_t *dst,
+ uint8_t proto, chunk_t payload)
{
switch (src->get_family(src))
{
case AF_INET:
{
struct __attribute__((packed)) {
- u_int32_t src;
- u_int32_t dst;
+ uint32_t src;
+ uint32_t dst;
u_char zero;
u_char proto;
- u_int16_t len;
+ uint16_t len;
} pseudo = {
.proto = proto,
.len = htons(payload.len),
struct __attribute__((packed)) {
u_char src[16];
u_char dst[16];
- u_int32_t len;
+ uint32_t len;
u_char zero[3];
u_char next_header;
} pseudo = {
/**
* Apply transport ports and calculate header checksums
*/
-static void fix_transport_header(host_t *src, host_t *dst, u_int8_t proto,
+static void fix_transport_header(host_t *src, host_t *dst, uint8_t proto,
chunk_t payload)
{
- u_int16_t sum = 0, sport, dport;
+ uint16_t sum = 0, sport, dport;
sport = src->get_port(src);
dport = dst->get_port(dst);
* Described in header.
*/
ip_packet_t *ip_packet_create_from_data(host_t *src, host_t *dst,
- u_int8_t next_header, chunk_t data)
+ uint8_t next_header, chunk_t data)
{
chunk_t packet;
int family;
*
* @return ip version
*/
- u_int8_t (*get_version)(ip_packet_t *this);
+ uint8_t (*get_version)(ip_packet_t *this);
/**
* Get the source address of this packet
*
* @return protocol|next header field
*/
- u_int8_t (*get_next_header)(ip_packet_t *this);
+ uint8_t (*get_next_header)(ip_packet_t *this);
/**
* Get the complete IP packet (including the header)
* @return ip_packet_t instance, or NULL if invalid
*/
ip_packet_t *ip_packet_create_from_data(host_t *src, host_t *dst,
- u_int8_t next_header, chunk_t data);
+ uint8_t next_header, chunk_t data);
/**
* Encode a UDP packet from the given data.
* @param dst destination address of expired SA
* @param hard TRUE if this is a hard expire, FALSE otherwise
*/
- void (*expire)(u_int8_t protocol, u_int32_t spi, host_t *dst, bool hard);
+ void (*expire)(uint8_t protocol, uint32_t spi, host_t *dst, bool hard);
};
#endif /** IPSEC_EVENT_LISTENER_H_ @}*/
/**
* Protocol of the SA
*/
- u_int8_t protocol;
+ uint8_t protocol;
/**
* SPI of the SA, if any
*/
- u_int32_t spi;
+ uint32_t spi;
/**
* SA destination address
}
METHOD(ipsec_event_relay_t, expire, void,
- private_ipsec_event_relay_t *this, u_int8_t protocol, u_int32_t spi,
+ private_ipsec_event_relay_t *this, uint8_t protocol, uint32_t spi,
host_t *dst, bool hard)
{
ipsec_event_t *event;
* @param dst destination address of expired SA
* @param hard TRUE for a hard expire, FALSE otherwise
*/
- void (*expire)(ipsec_event_relay_t *this, u_int8_t protocol, u_int32_t spi,
+ void (*expire)(ipsec_event_relay_t *this, uint8_t protocol, uint32_t spi,
host_t *dst, bool hard);
/**
/**
* If any of the two TS has a protocol selector we cache it here
*/
- u_int8_t protocol;
+ uint8_t protocol;
/**
* Traffic direction
METHOD(ipsec_policy_t, match, bool,
private_ipsec_policy_t *this, traffic_selector_t *src_ts,
- traffic_selector_t *dst_ts, policy_dir_t direction, u_int32_t reqid,
+ traffic_selector_t *dst_ts, policy_dir_t direction, uint32_t reqid,
mark_t mark, policy_priority_t priority)
{
return (this->direction == direction &&
METHOD(ipsec_policy_t, match_packet, bool,
private_ipsec_policy_t *this, ip_packet_t *packet)
{
- u_int8_t proto = packet->get_next_header(packet);
+ uint8_t proto = packet->get_next_header(packet);
host_t *src = packet->get_source(packet),
*dst = packet->get_destination(packet);
return this->dst_ts;
}
-METHOD(ipsec_policy_t, get_reqid, u_int32_t,
+METHOD(ipsec_policy_t, get_reqid, uint32_t,
private_ipsec_policy_t *this)
{
return this->sa.reqid;
*
* @return the reqid
*/
- u_int32_t (*get_reqid)(ipsec_policy_t *this);
+ uint32_t (*get_reqid)(ipsec_policy_t *this);
/**
* Get another reference to this policy
*/
bool (*match)(ipsec_policy_t *this, traffic_selector_t *src_ts,
traffic_selector_t *dst_ts, policy_dir_t direction,
- u_int32_t reqid, mark_t mark, policy_priority_t priority);
+ uint32_t reqid, mark_t mark, policy_priority_t priority);
/**
* Check if this policy matches the given IP packet
/**
* Priority used to sort policies
*/
- u_int32_t priority;
+ uint32_t priority;
/**
* The policy
* Calculate the pseudo-priority to sort policies. This is the same algorithm
* used by the NETLINK kernel interface (i.e. high priority -> low value).
*/
-static u_int32_t calculate_priority(policy_priority_t policy_priority,
+static uint32_t calculate_priority(policy_priority_t policy_priority,
traffic_selector_t *src,
traffic_selector_t *dst)
{
- u_int32_t priority = PRIO_BASE;
- u_int16_t port;
- u_int8_t mask, proto;
+ uint32_t priority = PRIO_BASE;
+ uint16_t port;
+ uint8_t mask, proto;
host_t *net;
switch (policy_priority)
{
enumerator_t *enumerator;
ipsec_policy_entry_t *current, *found = NULL;
- u_int32_t priority;
+ uint32_t priority;
if (type != POLICY_IPSEC || direction == POLICY_FWD)
{ /* we ignore these policies as we currently have no use for them */
METHOD(ipsec_policy_mgr_t, find_by_packet, ipsec_policy_t*,
private_ipsec_policy_mgr_t *this, ip_packet_t *packet, bool inbound,
- u_int32_t reqid)
+ uint32_t reqid)
{
enumerator_t *enumerator;
ipsec_policy_entry_t *current;
*/
ipsec_policy_t *(*find_by_packet)(ipsec_policy_mgr_t *this,
ip_packet_t *packet, bool inbound,
- u_int32_t reqid);
+ uint32_t reqid);
/**
* Destroy an ipsec_policy_mgr_t
esp_packet_t *packet;
ip_packet_t *ip_packet;
ipsec_sa_t *sa;
- u_int8_t next_header;
- u_int32_t spi, reqid;
+ uint8_t next_header;
+ uint32_t spi, reqid;
packet = (esp_packet_t*)this->inbound_queue->dequeue(this->inbound_queue);
/**
* SPI of this SA
*/
- u_int32_t spi;
+ uint32_t spi;
/**
* Source address
/**
* Protocol
*/
- u_int8_t protocol;
+ uint8_t protocol;
/**
* Reqid of this SA
*/
- u_int32_t reqid;
+ uint32_t reqid;
/**
* Lifetime configuration
/** last time of use */
time_t time;
/** number of packets processed */
- u_int64_t packets;
+ uint64_t packets;
/** number of bytes processed */
- u_int64_t bytes;
+ uint64_t bytes;
} use;
/**
this->dst = addr->clone(addr);
}
-METHOD(ipsec_sa_t, get_spi, u_int32_t,
+METHOD(ipsec_sa_t, get_spi, uint32_t,
private_ipsec_sa_t *this)
{
return this->spi;
}
-METHOD(ipsec_sa_t, get_reqid, u_int32_t,
+METHOD(ipsec_sa_t, get_reqid, uint32_t,
private_ipsec_sa_t *this)
{
return this->reqid;
}
-METHOD(ipsec_sa_t, get_protocol, u_int8_t,
+METHOD(ipsec_sa_t, get_protocol, uint8_t,
private_ipsec_sa_t *this)
{
return this->protocol;
}
METHOD(ipsec_sa_t, get_usestats, void,
- private_ipsec_sa_t *this, u_int64_t *bytes, u_int64_t *packets,
+ private_ipsec_sa_t *this, uint64_t *bytes, uint64_t *packets,
time_t *time)
{
if (bytes)
}
METHOD(ipsec_sa_t, update_usestats, void,
- private_ipsec_sa_t *this, u_int32_t bytes)
+ private_ipsec_sa_t *this, uint32_t bytes)
{
this->use.time = time_monotonic(NULL);
this->use.packets++;
}
METHOD(ipsec_sa_t, match_by_spi_dst, bool,
- private_ipsec_sa_t *this, u_int32_t spi, host_t *dst)
+ private_ipsec_sa_t *this, uint32_t spi, host_t *dst)
{
return this->spi == spi && this->dst->ip_equals(this->dst, dst) &&
!this->hard_expired;
}
METHOD(ipsec_sa_t, match_by_spi_src_dst, bool,
- private_ipsec_sa_t *this, u_int32_t spi, host_t *src, host_t *dst)
+ private_ipsec_sa_t *this, uint32_t spi, host_t *src, host_t *dst)
{
return this->spi == spi && this->src->ip_equals(this->src, src) &&
this->dst->ip_equals(this->dst, dst);
}
METHOD(ipsec_sa_t, match_by_reqid, bool,
- private_ipsec_sa_t *this, u_int32_t reqid, bool inbound)
+ private_ipsec_sa_t *this, uint32_t reqid, bool inbound)
{
return this->reqid == reqid && this->inbound == inbound &&
!this->hard_expired;
/**
* Described in header.
*/
-ipsec_sa_t *ipsec_sa_create(u_int32_t spi, host_t *src, host_t *dst,
- u_int8_t protocol, u_int32_t reqid, mark_t mark, u_int32_t tfc,
- lifetime_cfg_t *lifetime, u_int16_t enc_alg, chunk_t enc_key,
- u_int16_t int_alg, chunk_t int_key, ipsec_mode_t mode,
- u_int16_t ipcomp, u_int16_t cpi, bool encap, bool esn, bool inbound)
+ipsec_sa_t *ipsec_sa_create(uint32_t spi, host_t *src, host_t *dst,
+ uint8_t protocol, uint32_t reqid, mark_t mark, uint32_t tfc,
+ lifetime_cfg_t *lifetime, uint16_t enc_alg, chunk_t enc_key,
+ uint16_t int_alg, chunk_t int_key, ipsec_mode_t mode,
+ uint16_t ipcomp, uint16_t cpi, bool encap, bool esn, bool inbound)
{
private_ipsec_sa_t *this;
*
* @return SPI of this SA
*/
- u_int32_t (*get_spi)(ipsec_sa_t *this);
+ uint32_t (*get_spi)(ipsec_sa_t *this);
/**
* Get the reqid of this SA
*
* @return reqid of this SA
*/
- u_int32_t (*get_reqid)(ipsec_sa_t *this);
+ uint32_t (*get_reqid)(ipsec_sa_t *this);
/**
* Get the protocol (e.g. IPPROTO_ESP) of this SA
*
* @return protocol of this SA
*/
- u_int8_t (*get_protocol)(ipsec_sa_t *this);
+ uint8_t (*get_protocol)(ipsec_sa_t *this);
/**
* Returns whether this SA is inbound or outbound
* @param packets receives number of processed packets, or NULL
* @param time receives last use time of this SA, or NULL
*/
- void (*get_usestats)(ipsec_sa_t *this, u_int64_t *bytes, u_int64_t *packets,
+ void (*get_usestats)(ipsec_sa_t *this, uint64_t *bytes, uint64_t *packets,
time_t *time);
/**
*
* @param bytes length of packet processed
*/
- void (*update_usestats)(ipsec_sa_t *this, u_int32_t bytes);
+ void (*update_usestats)(ipsec_sa_t *this, uint32_t bytes);
/**
* Expire this SA, soft or hard.
* @param dst destination address
* @return TRUE if this SA matches all parameters, FALSE otherwise
*/
- bool (*match_by_spi_dst)(ipsec_sa_t *this, u_int32_t spi, host_t *dst);
+ bool (*match_by_spi_dst)(ipsec_sa_t *this, uint32_t spi, host_t *dst);
/**
* Check if this SA matches all given parameters
* @param dst destination address
* @return TRUE if this SA matches all parameters, FALSE otherwise
*/
- bool (*match_by_spi_src_dst)(ipsec_sa_t *this, u_int32_t spi, host_t *src,
+ bool (*match_by_spi_src_dst)(ipsec_sa_t *this, uint32_t spi, host_t *src,
host_t *dst);
/**
* @param inbound TRUE for inbound SA, FALSE for outbound
* @return TRUE if this SA matches all parameters, FALSE otherwise
*/
- bool (*match_by_reqid)(ipsec_sa_t *this, u_int32_t reqid, bool inbound);
+ bool (*match_by_reqid)(ipsec_sa_t *this, uint32_t reqid, bool inbound);
/**
* Destroy an ipsec_sa_t
* @param inbound TRUE if this is an inbound SA, FALSE otherwise
* @return the IPsec SA, or NULL if the creation failed
*/
-ipsec_sa_t *ipsec_sa_create(u_int32_t spi, host_t *src, host_t *dst,
- u_int8_t protocol, u_int32_t reqid, mark_t mark,
- u_int32_t tfc, lifetime_cfg_t *lifetime,
- u_int16_t enc_alg, chunk_t enc_key,
- u_int16_t int_alg, chunk_t int_key,
- ipsec_mode_t mode, u_int16_t ipcomp, u_int16_t cpi,
+ipsec_sa_t *ipsec_sa_create(uint32_t spi, host_t *src, host_t *dst,
+ uint8_t protocol, uint32_t reqid, mark_t mark,
+ uint32_t tfc, lifetime_cfg_t *lifetime,
+ uint16_t enc_alg, chunk_t enc_key,
+ uint16_t int_alg, chunk_t int_key,
+ ipsec_mode_t mode, uint16_t ipcomp, uint16_t cpi,
bool encap, bool esn, bool inbound);
#endif /** IPSEC_SA_H_ @}*/
/**
* 0 if this is a hard expire, otherwise the offset in s (soft->hard)
*/
- u_int32_t hard_offset;
+ uint32_t hard_offset;
} ipsec_sa_expired_t;
/*
* Used for the hash table of allocated SPIs
*/
-static bool spi_equals(u_int32_t *spi, u_int32_t *other_spi)
+static bool spi_equals(uint32_t *spi, uint32_t *other_spi)
{
return *spi == *other_spi;
}
-static u_int spi_hash(u_int32_t *spi)
+static u_int spi_hash(uint32_t *spi)
{
return chunk_hash(chunk_from_thing(*spi));
}
return item->sa == sa;
}
-static bool match_entry_by_spi_inbound(ipsec_sa_entry_t *item, u_int32_t *spi,
+static bool match_entry_by_spi_inbound(ipsec_sa_entry_t *item, uint32_t *spi,
bool *inbound)
{
return item->sa->get_spi(item->sa) == *spi &&
item->sa->is_inbound(item->sa) == *inbound;
}
-static bool match_entry_by_spi_src_dst(ipsec_sa_entry_t *item, u_int32_t *spi,
+static bool match_entry_by_spi_src_dst(ipsec_sa_entry_t *item, uint32_t *spi,
host_t *src, host_t *dst)
{
return item->sa->match_by_spi_src_dst(item->sa, *spi, src, dst);
}
static bool match_entry_by_reqid_inbound(ipsec_sa_entry_t *item,
- u_int32_t *reqid, bool *inbound)
+ uint32_t *reqid, bool *inbound)
{
return item->sa->match_by_reqid(item->sa, *reqid, *inbound);
}
-static bool match_entry_by_spi_dst(ipsec_sa_entry_t *item, u_int32_t *spi,
+static bool match_entry_by_spi_dst(ipsec_sa_entry_t *item, uint32_t *spi,
host_t *dst)
{
return item->sa->match_by_spi_dst(item->sa, *spi, dst);
if (this->sas->find_first(this->sas, (void*)match_entry_by_ptr,
NULL, expired->entry) == SUCCESS)
{
- u_int32_t hard_offset;
+ uint32_t hard_offset;
hard_offset = expired->hard_offset;
expired->entry->sa->expire(expired->entry->sa, hard_offset == 0);
lifetime_cfg_t *lifetime = entry->sa->get_lifetime(entry->sa);
ipsec_sa_expired_t *expired;
callback_job_t *job;
- u_int32_t timeout;
+ uint32_t timeout;
if (!lifetime->time.life)
{ /* no expiration at all */
static void flush_allocated_spis(private_ipsec_sa_mgr_t *this)
{
enumerator_t *enumerator;
- u_int32_t *current;
+ uint32_t *current;
DBG2(DBG_ESP, "flushing allocated SPIs");
enumerator = this->allocated_spis->create_enumerator(this->allocated_spis);
/**
* Pre-allocate an SPI for an inbound SA
*/
-static bool allocate_spi(private_ipsec_sa_mgr_t *this, u_int32_t spi)
+static bool allocate_spi(private_ipsec_sa_mgr_t *this, uint32_t spi)
{
- u_int32_t *spi_alloc;
+ uint32_t *spi_alloc;
if (this->allocated_spis->get(this->allocated_spis, &spi) ||
this->sas->find_first(this->sas, (void*)match_entry_by_spi_inbound,
{
return FALSE;
}
- spi_alloc = malloc_thing(u_int32_t);
+ spi_alloc = malloc_thing(uint32_t);
*spi_alloc = spi;
this->allocated_spis->put(this->allocated_spis, spi_alloc, spi_alloc);
return TRUE;
}
METHOD(ipsec_sa_mgr_t, get_spi, status_t,
- private_ipsec_sa_mgr_t *this, host_t *src, host_t *dst, u_int8_t protocol,
- u_int32_t *spi)
+ private_ipsec_sa_mgr_t *this, host_t *src, host_t *dst, uint8_t protocol,
+ uint32_t *spi)
{
- u_int32_t spi_new;
+ uint32_t spi_new;
this->mutex->lock(this->mutex);
if (!this->rng)
do
{
if (!this->rng->get_bytes(this->rng, sizeof(spi_new),
- (u_int8_t*)&spi_new))
+ (uint8_t*)&spi_new))
{
this->mutex->unlock(this->mutex);
DBG1(DBG_ESP, "failed to allocate SPI");
}
METHOD(ipsec_sa_mgr_t, add_sa, status_t,
- private_ipsec_sa_mgr_t *this, host_t *src, host_t *dst, u_int32_t spi,
- u_int8_t protocol, u_int32_t reqid, mark_t mark, u_int32_t tfc,
- lifetime_cfg_t *lifetime, u_int16_t enc_alg, chunk_t enc_key,
- u_int16_t int_alg, chunk_t int_key, ipsec_mode_t mode, u_int16_t ipcomp,
- u_int16_t cpi, bool initiator, bool encap, bool esn, bool inbound,
+ private_ipsec_sa_mgr_t *this, host_t *src, host_t *dst, uint32_t spi,
+ uint8_t protocol, uint32_t reqid, mark_t mark, uint32_t tfc,
+ lifetime_cfg_t *lifetime, uint16_t enc_alg, chunk_t enc_key,
+ uint16_t int_alg, chunk_t int_key, ipsec_mode_t mode, uint16_t ipcomp,
+ uint16_t cpi, bool initiator, bool encap, bool esn, bool inbound,
bool update)
{
ipsec_sa_entry_t *entry;
if (update)
{ /* remove any pre-allocated SPIs */
- u_int32_t *spi_alloc;
+ uint32_t *spi_alloc;
spi_alloc = this->allocated_spis->remove(this->allocated_spis, &spi);
free(spi_alloc);
}
METHOD(ipsec_sa_mgr_t, update_sa, status_t,
- private_ipsec_sa_mgr_t *this, u_int32_t spi, u_int8_t protocol,
- u_int16_t cpi, host_t *src, host_t *dst, host_t *new_src, host_t *new_dst,
+ private_ipsec_sa_mgr_t *this, uint32_t spi, uint8_t protocol,
+ uint16_t cpi, host_t *src, host_t *dst, host_t *new_src, host_t *new_dst,
bool encap, bool new_encap, mark_t mark)
{
ipsec_sa_entry_t *entry = NULL;
METHOD(ipsec_sa_mgr_t, query_sa, status_t,
private_ipsec_sa_mgr_t *this, host_t *src, host_t *dst,
- u_int32_t spi, u_int8_t protocol, mark_t mark,
- u_int64_t *bytes, u_int64_t *packets, time_t *time)
+ uint32_t spi, uint8_t protocol, mark_t mark,
+ uint64_t *bytes, uint64_t *packets, time_t *time)
{
ipsec_sa_entry_t *entry = NULL;
}
METHOD(ipsec_sa_mgr_t, del_sa, status_t,
- private_ipsec_sa_mgr_t *this, host_t *src, host_t *dst, u_int32_t spi,
- u_int8_t protocol, u_int16_t cpi, mark_t mark)
+ private_ipsec_sa_mgr_t *this, host_t *src, host_t *dst, uint32_t spi,
+ uint8_t protocol, uint16_t cpi, mark_t mark)
{
ipsec_sa_entry_t *current, *found = NULL;
enumerator_t *enumerator;
}
METHOD(ipsec_sa_mgr_t, checkout_by_reqid, ipsec_sa_t*,
- private_ipsec_sa_mgr_t *this, u_int32_t reqid, bool inbound)
+ private_ipsec_sa_mgr_t *this, uint32_t reqid, bool inbound)
{
ipsec_sa_entry_t *entry;
ipsec_sa_t *sa = NULL;
}
METHOD(ipsec_sa_mgr_t, checkout_by_spi, ipsec_sa_t*,
- private_ipsec_sa_mgr_t *this, u_int32_t spi, host_t *dst)
+ private_ipsec_sa_mgr_t *this, uint32_t spi, host_t *dst)
{
ipsec_sa_entry_t *entry;
ipsec_sa_t *sa = NULL;
* @return SUCCESS of operation successful
*/
status_t (*get_spi)(ipsec_sa_mgr_t *this, host_t *src, host_t *dst,
- u_int8_t protocol, u_int32_t *spi);
+ uint8_t protocol, uint32_t *spi);
/**
* Add a new SA
* @return SUCCESS if operation completed
*/
status_t (*add_sa)(ipsec_sa_mgr_t *this, host_t *src, host_t *dst,
- u_int32_t spi, u_int8_t protocol, u_int32_t reqid,
- mark_t mark, u_int32_t tfc, lifetime_cfg_t *lifetime,
- u_int16_t enc_alg, chunk_t enc_key, u_int16_t int_alg,
- chunk_t int_key, ipsec_mode_t mode, u_int16_t ipcomp,
- u_int16_t cpi, bool initiator, bool encap, bool esn,
+ uint32_t spi, uint8_t protocol, uint32_t reqid,
+ mark_t mark, uint32_t tfc, lifetime_cfg_t *lifetime,
+ uint16_t enc_alg, chunk_t enc_key, uint16_t int_alg,
+ chunk_t int_key, ipsec_mode_t mode, uint16_t ipcomp,
+ uint16_t cpi, bool initiator, bool encap, bool esn,
bool inbound, bool update);
/**
* @return SUCCESS if operation completed
*/
status_t (*update_sa)(ipsec_sa_mgr_t *this,
- u_int32_t spi, u_int8_t protocol, u_int16_t cpi,
+ uint32_t spi, uint8_t protocol, uint16_t cpi,
host_t *src, host_t *dst,
host_t *new_src, host_t *new_dst,
bool encap, bool new_encap, mark_t mark);
* @return SUCCESS if operation completed
*/
status_t (*query_sa)(ipsec_sa_mgr_t *this, host_t *src, host_t *dst,
- u_int32_t spi, u_int8_t protocol, mark_t mark,
- u_int64_t *bytes, u_int64_t *packets, time_t *time);
+ uint32_t spi, uint8_t protocol, mark_t mark,
+ uint64_t *bytes, uint64_t *packets, time_t *time);
/**
* Delete a previously added SA
* @return SUCCESS if operation completed
*/
status_t (*del_sa)(ipsec_sa_mgr_t *this, host_t *src, host_t *dst,
- u_int32_t spi, u_int8_t protocol, u_int16_t cpi,
+ uint32_t spi, uint8_t protocol, uint16_t cpi,
mark_t mark);
/**
* @param dst destination address (e.g. of an inbound packet)
* @return the matching IPsec SA, or NULL if none is found
*/
- ipsec_sa_t *(*checkout_by_spi)(ipsec_sa_mgr_t *this, u_int32_t spi,
+ ipsec_sa_t *(*checkout_by_spi)(ipsec_sa_mgr_t *this, uint32_t spi,
host_t *dst);
/**
* @param inbound TRUE for an inbound SA, FALSE for an outbound SA
* @return the matching IPsec SA, or NULL if none is found
*/
- ipsec_sa_t *(*checkout_by_reqid)(ipsec_sa_mgr_t *this, u_int32_t reqid,
+ ipsec_sa_t *(*checkout_by_reqid)(ipsec_sa_mgr_t *this, uint32_t reqid,
bool inbound);
/**
}
METHOD(iv_gen_t, get_iv, bool,
- iv_gen_t *this, u_int64_t seq, size_t size, u_int8_t *buffer)
+ iv_gen_t *this, uint64_t seq, size_t size, uint8_t *buffer)
{
if (size != 8)
{
}
METHOD(iv_gen_t, allocate_iv, bool,
- iv_gen_t *this, u_int64_t seq, size_t size, chunk_t *chunk)
+ iv_gen_t *this, uint64_t seq, size_t size, chunk_t *chunk)
{
if (size != 8)
{
esp_packet_t *esp;
esp_context_t *ctx;
chunk_t data, exp;
- u_int32_t seq = 0;
+ uint32_t seq = 0;
icmp = ip_packet_create(chunk_clone(chunk_from_chars(
0x45,0x00,0x00,0x54,0xa6,0xf2,0x00,0x00,
/**
* Read a PT-TLS message, return header data
*/
-bio_reader_t* pt_tls_read(tls_socket_t *tls, u_int32_t *vendor,
- u_int32_t *type, u_int32_t *identifier)
+bio_reader_t* pt_tls_read(tls_socket_t *tls, uint32_t *vendor,
+ uint32_t *type, uint32_t *identifier)
{
bio_reader_t *reader;
- u_int32_t len;
- u_int8_t reserved;
+ uint32_t len;
+ uint8_t reserved;
reader = read_tls(tls, PT_TLS_HEADER_LEN);
if (!reader)
* Prepend a PT-TLS header to a writer, send data, destroy writer
*/
bool pt_tls_write(tls_socket_t *tls, pt_tls_message_type_t type,
- u_int32_t identifier, chunk_t data)
+ uint32_t identifier, chunk_t data)
{
bio_writer_t *writer;
chunk_t out;
* @param identifier receives Message Identifer
* @return reader over message value, NULL on error
*/
-bio_reader_t* pt_tls_read(tls_socket_t *tls, u_int32_t *vendor,
- u_int32_t *type, u_int32_t *identifier);
+bio_reader_t* pt_tls_read(tls_socket_t *tls, uint32_t *vendor,
+ uint32_t *type, uint32_t *identifier);
/**
* Prepend a PT-TLS header to a writer, send data, destroy writer.
* @return TRUE if data written successfully
*/
bool pt_tls_write(tls_socket_t *tls, pt_tls_message_type_t type,
- u_int32_t identifier, chunk_t data);
+ uint32_t identifier, chunk_t data);
/**
* Dummy libpttls initialization function needed for integrity test
/**
* Current PT-TLS message identifier
*/
- u_int32_t identifier;
+ uint32_t identifier;
};
/**
{
bio_writer_t *writer;
bio_reader_t *reader;
- u_int32_t type, vendor, identifier, reserved;
- u_int8_t version;
+ uint32_t type, vendor, identifier, reserved;
+ uint8_t version;
bool res;
DBG1(DBG_TNC, "sending offer for PT-TLS version %d", PT_TLS_VERSION);
*/
static status_t do_sasl(private_pt_tls_client_t *this, sasl_mechanism_t *sasl)
{
- u_int32_t type, vendor, identifier;
- u_int8_t result;
+ uint32_t type, vendor, identifier;
+ uint8_t result;
bio_reader_t *reader;
bio_writer_t *writer;
chunk_t data;
{
bio_reader_t *reader;
sasl_mechanism_t *sasl = NULL;
- u_int32_t type, vendor, identifier;
- u_int8_t len;
+ uint32_t type, vendor, identifier;
+ uint8_t len;
chunk_t chunk;
char buf[21];
status_t status = NEED_MORE;
size_t buflen = PT_TLS_MAX_MESSAGE_LEN;
char buf[buflen];
bio_reader_t *reader;
- u_int32_t vendor, type, identifier;
+ uint32_t vendor, type, identifier;
chunk_t data;
switch (tnccs->build(tnccs, buf, &buflen, &msglen))
/**
* Message Identifier
*/
- u_int32_t identifier;
+ uint32_t identifier;
/**
* TNCCS protocol handler, implemented as tls_t
{
bio_reader_t *reader;
bio_writer_t *writer;
- u_int32_t vendor, type, identifier;
- u_int8_t reserved, vmin, vmax, vpref;
+ uint32_t vendor, type, identifier;
+ uint8_t reserved, vmin, vmax, vpref;
bool res;
reader = pt_tls_read(this->tls, &vendor, &type, &identifier);
static status_t read_sasl(private_pt_tls_server_t *this,
sasl_mechanism_t *sasl)
{
- u_int32_t vendor, type, identifier;
+ uint32_t vendor, type, identifier;
bio_reader_t *reader;
status_t status;
chunk_t data;
static status_t read_sasl_mech_selection(private_pt_tls_server_t *this,
sasl_mechanism_t **out)
{
- u_int32_t vendor, type, identifier;
+ uint32_t vendor, type, identifier;
sasl_mechanism_t *sasl;
bio_reader_t *reader;
chunk_t chunk;
- u_int8_t len;
+ uint8_t len;
char buf[21];
reader = pt_tls_read(this->tls, &vendor, &type, &identifier);
size_t buflen = PT_TLS_MAX_MESSAGE_LEN;
char buf[buflen];
bio_reader_t *reader;
- u_int32_t vendor, type, identifier;
+ uint32_t vendor, type, identifier;
chunk_t data;
status_t status;
* See header
*/
radius_config_t *radius_config_create(char *name, char *address,
- u_int16_t auth_port, u_int16_t acct_port,
+ uint16_t auth_port, uint16_t acct_port,
char *nas_identifier, char *secret,
int sockets, int preference,
u_int tries, double timeout, double base)
* @param base base to calculate retransmission timeout
*/
radius_config_t *radius_config_create(char *name, char *address,
- u_int16_t auth_port, u_int16_t acct_port,
+ uint16_t auth_port, uint16_t acct_port,
char *nas_identifier, char *secret,
int sockets, int preference,
u_int tries, double timeout, double base);
*/
struct rmsg_t {
/** message code, radius_message_code_t */
- u_int8_t code;
+ uint8_t code;
/** message identifier */
- u_int8_t identifier;
+ uint8_t identifier;
/** length of Code, Identifier, Length, Authenticator and Attributes */
- u_int16_t length;
+ uint16_t length;
/** message authenticator, MD5 hash */
- u_int8_t authenticator[HASH_SIZE_MD5];
+ uint8_t authenticator[HASH_SIZE_MD5];
/** variable list of packed attributes */
- u_int8_t attributes[];
+ uint8_t attributes[];
} __attribute__((packed));
/**
*/
struct rattr_t {
/** attribute type, radius_attribute_type_t */
- u_int8_t type;
+ uint8_t type;
/** length of the attriubte, including the Type, Length and Value fields */
- u_int8_t length;
+ uint8_t length;
/** variable length attribute value */
- u_int8_t value[];
+ uint8_t value[];
} __attribute__((packed));
/**
/** inner attribute enumerator */
enumerator_t *inner;
/** current vendor ID */
- u_int32_t vendor;
+ uint32_t vendor;
/** reader for current vendor ID */
bio_reader_t *reader;
} vendor_enumerator_t;
{
chunk_t inner_data;
int inner_type;
- u_int8_t type8, len;
+ uint8_t type8, len;
while (TRUE)
{
}
METHOD(radius_message_t, sign, bool,
- private_radius_message_t *this, u_int8_t *req_auth, chunk_t secret,
+ private_radius_message_t *this, uint8_t *req_auth, chunk_t secret,
hasher_t *hasher, signer_t *signer, rng_t *rng, bool msg_auth)
{
if (rng)
}
METHOD(radius_message_t, verify, bool,
- private_radius_message_t *this, u_int8_t *req_auth, chunk_t secret,
+ private_radius_message_t *this, uint8_t *req_auth, chunk_t secret,
hasher_t *hasher, signer_t *signer)
{
char buf[HASH_SIZE_MD5], res_auth[HASH_SIZE_MD5];
return this->msg->code;
}
-METHOD(radius_message_t, get_identifier, u_int8_t,
+METHOD(radius_message_t, get_identifier, uint8_t,
private_radius_message_t *this)
{
return this->msg->identifier;
}
METHOD(radius_message_t, set_identifier, void,
- private_radius_message_t *this, u_int8_t identifier)
+ private_radius_message_t *this, uint8_t identifier)
{
this->msg->identifier = identifier;
}
-METHOD(radius_message_t, get_authenticator, u_int8_t*,
+METHOD(radius_message_t, get_authenticator, uint8_t*,
private_radius_message_t *this)
{
return this->msg->authenticator;
*
* @return message identifier
*/
- u_int8_t (*get_identifier)(radius_message_t *this);
+ uint8_t (*get_identifier)(radius_message_t *this);
/**
* Set the message identifier.
*
* @param identifier message identifier
*/
- void (*set_identifier)(radius_message_t *this, u_int8_t identifier);
+ void (*set_identifier)(radius_message_t *this, uint8_t identifier);
/**
* Get the 16 byte authenticator.
*
* @return pointer to the Authenticator field
*/
- u_int8_t* (*get_authenticator)(radius_message_t *this);
+ uint8_t* (*get_authenticator)(radius_message_t *this);
/**
* Get the RADIUS message in its encoded form.
* @param msg_auth calculate and add Message-Authenticator
* @return TRUE if signed successfully
*/
- bool (*sign)(radius_message_t *this, u_int8_t *req_auth, chunk_t secret,
+ bool (*sign)(radius_message_t *this, uint8_t *req_auth, chunk_t secret,
hasher_t *hasher, signer_t *signer, rng_t *rng, bool msg_auth);
/**
* @param signer HMAC-MD5 signer with secret set
* @param hasher MD5 hasher
*/
- bool (*verify)(radius_message_t *this, u_int8_t *req_auth, chunk_t secret,
+ bool (*verify)(radius_message_t *this, uint8_t *req_auth, chunk_t secret,
hasher_t *hasher, signer_t *signer);
/**
typedef struct mppe_key_t mppe_key_t;
struct mppe_key_t {
- u_int32_t id;
- u_int8_t type;
- u_int8_t length;
- u_int16_t salt;
- u_int8_t key[];
+ uint32_t id;
+ uint8_t type;
+ uint8_t length;
+ uint16_t salt;
+ uint8_t key[];
} __attribute__((packed));
#endif /** RADIUS_MPPE_H_ @}*/
/**
* Server port for authentication
*/
- u_int16_t auth_port;
+ uint16_t auth_port;
/**
* socket file descriptor for authentication
/**
* Server port for accounting
*/
- u_int16_t acct_port;
+ uint16_t acct_port;
/**
* socket file descriptor for accounting
/**
* current RADIUS identifier
*/
- u_int8_t identifier;
+ uint8_t identifier;
/**
* hasher to use for response verification
* Check or establish RADIUS connection
*/
static bool check_connection(private_radius_socket_t *this,
- int *fd, u_int16_t port)
+ int *fd, uint16_t port)
{
if (*fd == -1)
{
/**
* Receive the response to the message with the given ID
*/
-static status_t receive_response(int fd, int timeout, u_int8_t id,
+static status_t receive_response(int fd, int timeout, uint8_t id,
radius_message_t **response)
{
radius_message_t *msg;
radius_message_t *response;
chunk_t data;
int *fd, retransmit = 0, timeout;
- u_int16_t port;
+ uint16_t port;
rng_t *rng = NULL;
if (request->get_code(request) == RMC_ACCOUNTING_REQUEST)
/**
* Decrypt a MS-MPPE-Send/Recv-Key
*/
-static chunk_t decrypt_mppe_key(private_radius_socket_t *this, u_int16_t salt,
+static chunk_t decrypt_mppe_key(private_radius_socket_t *this, uint16_t salt,
chunk_t C, radius_message_t *request)
{
chunk_t decrypted;
/**
* See header
*/
-radius_socket_t *radius_socket_create(char *address, u_int16_t auth_port,
- u_int16_t acct_port, chunk_t secret,
+radius_socket_t *radius_socket_create(char *address, uint16_t auth_port,
+ uint16_t acct_port, chunk_t secret,
u_int tries, double timeout, double base)
{
private_radius_socket_t *this;
* @param timeout retransmission timeout
* @param base base to calculate retransmission timeout
*/
-radius_socket_t *radius_socket_create(char *address, u_int16_t auth_port,
- u_int16_t acct_port, chunk_t secret,
+radius_socket_t *radius_socket_create(char *address, uint16_t auth_port,
+ uint16_t acct_port, chunk_t secret,
u_int tries, double timeout, double base);
#endif /** RADIUS_SOCKET_H_ @}*/
*/
void (*set_reauth)(simaka_card_t *this, identification_t *id,
identification_t *next, char mk[HASH_SIZE_SHA1],
- u_int16_t counter);
+ uint16_t counter);
/**
* Retrieve parameters for fast reauthentication stored via set_reauth().
* @return fast reauthentication identity, NULL if not found
*/
identification_t* (*get_reauth)(simaka_card_t *this, identification_t *id,
- char mk[HASH_SIZE_SHA1], u_int16_t *counter);
+ char mk[HASH_SIZE_SHA1], uint16_t *counter);
};
#endif /** SIMAKA_CARD_H_ @}*/
METHOD(simaka_manager_t, card_set_reauth, void,
private_simaka_manager_t *this, identification_t *id, identification_t *next,
- char mk[HASH_SIZE_SHA1], u_int16_t counter)
+ char mk[HASH_SIZE_SHA1], uint16_t counter)
{
enumerator_t *enumerator;
simaka_card_t *card;
METHOD(simaka_manager_t, card_get_reauth, identification_t*,
private_simaka_manager_t *this, identification_t *id, char mk[HASH_SIZE_SHA1],
- u_int16_t *counter)
+ uint16_t *counter)
{
enumerator_t *enumerator;
simaka_card_t *card;
METHOD(simaka_manager_t, provider_is_reauth, identification_t*,
private_simaka_manager_t *this, identification_t *id, char mk[HASH_SIZE_SHA1],
- u_int16_t *counter)
+ uint16_t *counter)
{
enumerator_t *enumerator;
simaka_provider_t *provider;
*/
void (*card_set_reauth)(simaka_manager_t *this, identification_t *id,
identification_t *next, char mk[HASH_SIZE_SHA1],
- u_int16_t counter);
+ uint16_t counter);
/**
* Retrieve fast reauthentication parameters from one of the registered cards.
*/
identification_t* (*card_get_reauth)(simaka_manager_t *this,
identification_t *id, char mk[HASH_SIZE_SHA1],
- u_int16_t *counter);
+ uint16_t *counter);
/**
* Register a triplet provider (server) at the manager.
*/
identification_t* (*provider_is_reauth)(simaka_manager_t *this,
identification_t *id, char mk[HASH_SIZE_SHA1],
- u_int16_t *counter);
+ uint16_t *counter);
/**
* Generate a fast reauth id using one of the registered providers.
*/
struct hdr_t {
/** EAP code (REQUEST/RESPONSE) */
- u_int8_t code;
+ uint8_t code;
/** unique message identifier */
- u_int8_t identifier;
+ uint8_t identifier;
/** length of whole message */
- u_int16_t length;
+ uint16_t length;
/** EAP type => EAP_SIM/EAP_AKA */
- u_int8_t type;
+ uint8_t type;
/** SIM subtype */
- u_int8_t subtype;
+ uint8_t subtype;
/** reserved bytes */
- u_int16_t reserved;
+ uint16_t reserved;
} __attribute__((__packed__));
/**
*/
struct attr_hdr_t {
/** attribute type */
- u_int8_t type;
+ uint8_t type;
/** attibute length */
- u_int8_t length;
+ uint8_t length;
} __attribute__((__packed__));
/**
return this->hdr->code == EAP_REQUEST;
}
-METHOD(simaka_message_t, get_identifier, u_int8_t,
+METHOD(simaka_message_t, get_identifier, uint8_t,
private_simaka_message_t *this)
{
return this->hdr->identifier;
case AT_IDENTITY:
case AT_VERSION_LIST:
{
- u_int16_t len;
+ uint16_t len;
if (hdr->length < 1 || in.len < 4)
{
chunk_t out, encr, data, *target, mac = chunk_empty;
simaka_attribute_t type;
attr_hdr_t *hdr;
- u_int16_t len;
+ uint16_t len;
signer_t *signer;
call_hook(this, FALSE, TRUE);
case AT_VERSION_LIST:
case AT_RES:
{
- u_int16_t len, padding;
+ uint16_t len, padding;
len = htons(data.len);
if (type == AT_RES)
/**
* See header.
*/
-simaka_message_t *simaka_message_create(bool request, u_int8_t identifier,
+simaka_message_t *simaka_message_create(bool request, uint8_t identifier,
eap_type_t type, simaka_subtype_t subtype,
simaka_crypto_t *crypto)
{
*
* @return EAP message identifier
*/
- u_int8_t (*get_identifier)(simaka_message_t *this);
+ uint8_t (*get_identifier)(simaka_message_t *this);
/**
* Get the EAP type of the message.
* @param crypto EAP-SIM/AKA crypto helper
* @return empty message of requested kind, NULL on error
*/
-simaka_message_t *simaka_message_create(bool request, u_int8_t identifier,
+simaka_message_t *simaka_message_create(bool request, uint8_t identifier,
eap_type_t type, simaka_subtype_t subtype,
simaka_crypto_t *crypto);
* @return permanent identity, NULL if id not a reauth identity
*/
identification_t* (*is_reauth)(simaka_provider_t *this, identification_t *id,
- char mk[HASH_SIZE_SHA1], u_int16_t *counter);
+ char mk[HASH_SIZE_SHA1], uint16_t *counter);
/**
* Generate a fast reauthentication identity, associated to a master key.
/*
* Described in header
*/
-u_int64_t asn1_parse_integer_uint64(chunk_t blob)
+uint64_t asn1_parse_integer_uint64(chunk_t blob)
{
- u_int64_t val = 0;
+ uint64_t val = 0;
int i;
for (i = 0; i < blob.len; i++)
{ /* if it is longer than 8 bytes, we just use the 8 LSBs */
val <<= 8;
- val |= (u_int64_t)blob.ptr[i];
+ val |= (uint64_t)blob.ptr[i];
}
return val;
}
const char* name);
/**
- * Converts an ASN.1 INTEGER object to an u_int64_t. If the INTEGER is longer
+ * Converts an ASN.1 INTEGER object to an uint64_t. If the INTEGER is longer
* than 8 bytes only the 8 LSBs are returned.
*
* @param blob body of an ASN.1 coded integer object
* @return converted integer
*/
-u_int64_t asn1_parse_integer_uint64(chunk_t blob);
+uint64_t asn1_parse_integer_uint64(chunk_t blob);
/**
* Print the value of an ASN.1 simple object
chunk_t cleanup;
};
-METHOD(bio_reader_t, remaining, u_int32_t,
+METHOD(bio_reader_t, remaining, uint32_t,
private_bio_reader_t *this)
{
return this->buf.len;
/**
* Returns a pointer to the data to read, optionally from the end
*/
-static inline u_char *get_ptr_end(private_bio_reader_t *this, u_int32_t len,
+static inline u_char *get_ptr_end(private_bio_reader_t *this, uint32_t len,
bool from_end)
{
return from_end ? this->buf.ptr + (this->buf.len - len) : this->buf.ptr;
}
/**
- * Read an u_int8_t from the buffer, optionally from the end of the buffer
+ * Read an uint8_t from the buffer, optionally from the end of the buffer
*/
-static bool read_uint8_internal(private_bio_reader_t *this, u_int8_t *res,
+static bool read_uint8_internal(private_bio_reader_t *this, uint8_t *res,
bool from_end)
{
if (this->buf.len < 1)
}
/**
- * Read an u_int16_t from the buffer, optionally from the end
+ * Read an uint16_t from the buffer, optionally from the end
*/
-static bool read_uint16_internal(private_bio_reader_t *this, u_int16_t *res,
+static bool read_uint16_internal(private_bio_reader_t *this, uint16_t *res,
bool from_end)
{
if (this->buf.len < 2)
}
/**
- * Read an u_int32_t (only 24-bit) from the buffer, optionally from the end
+ * Read an uint32_t (only 24-bit) from the buffer, optionally from the end
*/
-static bool read_uint24_internal(private_bio_reader_t *this, u_int32_t *res,
+static bool read_uint24_internal(private_bio_reader_t *this, uint32_t *res,
bool from_end)
{
if (this->buf.len < 3)
}
/**
- * Read an u_int32_t from the buffer, optionally from the end
+ * Read an uint32_t from the buffer, optionally from the end
*/
-static bool read_uint32_internal(private_bio_reader_t *this, u_int32_t *res,
+static bool read_uint32_internal(private_bio_reader_t *this, uint32_t *res,
bool from_end)
{
if (this->buf.len < 4)
}
/**
- * Read an u_int64_t from the buffer, optionally from the end
+ * Read an uint64_t from the buffer, optionally from the end
*/
-static bool read_uint64_internal(private_bio_reader_t *this, u_int64_t *res,
+static bool read_uint64_internal(private_bio_reader_t *this, uint64_t *res,
bool from_end)
{
if (this->buf.len < 8)
/**
* Read a chunk of data from the buffer, optionally from the end
*/
-static bool read_data_internal(private_bio_reader_t *this, u_int32_t len,
+static bool read_data_internal(private_bio_reader_t *this, uint32_t len,
chunk_t *res, bool from_end)
{
if (this->buf.len < len)
}
METHOD(bio_reader_t, read_uint8, bool,
- private_bio_reader_t *this, u_int8_t *res)
+ private_bio_reader_t *this, uint8_t *res)
{
return read_uint8_internal(this, res, FALSE);
}
METHOD(bio_reader_t, read_uint16, bool,
- private_bio_reader_t *this, u_int16_t *res)
+ private_bio_reader_t *this, uint16_t *res)
{
return read_uint16_internal(this, res, FALSE);
}
METHOD(bio_reader_t, read_uint24, bool,
- private_bio_reader_t *this, u_int32_t *res)
+ private_bio_reader_t *this, uint32_t *res)
{
return read_uint24_internal(this, res, FALSE);
}
METHOD(bio_reader_t, read_uint32, bool,
- private_bio_reader_t *this, u_int32_t *res)
+ private_bio_reader_t *this, uint32_t *res)
{
return read_uint32_internal(this, res, FALSE);
}
METHOD(bio_reader_t, read_uint64, bool,
- private_bio_reader_t *this, u_int64_t *res)
+ private_bio_reader_t *this, uint64_t *res)
{
return read_uint64_internal(this, res, FALSE);
}
METHOD(bio_reader_t, read_data, bool,
- private_bio_reader_t *this, u_int32_t len, chunk_t *res)
+ private_bio_reader_t *this, uint32_t len, chunk_t *res)
{
return read_data_internal(this, len, res, FALSE);
}
METHOD(bio_reader_t, read_uint8_end, bool,
- private_bio_reader_t *this, u_int8_t *res)
+ private_bio_reader_t *this, uint8_t *res)
{
return read_uint8_internal(this, res, TRUE);
}
METHOD(bio_reader_t, read_uint16_end, bool,
- private_bio_reader_t *this, u_int16_t *res)
+ private_bio_reader_t *this, uint16_t *res)
{
return read_uint16_internal(this, res, TRUE);
}
METHOD(bio_reader_t, read_uint24_end, bool,
- private_bio_reader_t *this, u_int32_t *res)
+ private_bio_reader_t *this, uint32_t *res)
{
return read_uint24_internal(this, res, TRUE);
}
METHOD(bio_reader_t, read_uint32_end, bool,
- private_bio_reader_t *this, u_int32_t *res)
+ private_bio_reader_t *this, uint32_t *res)
{
return read_uint32_internal(this, res, TRUE);
}
METHOD(bio_reader_t, read_uint64_end, bool,
- private_bio_reader_t *this, u_int64_t *res)
+ private_bio_reader_t *this, uint64_t *res)
{
return read_uint64_internal(this, res, TRUE);
}
METHOD(bio_reader_t, read_data_end, bool,
- private_bio_reader_t *this, u_int32_t len, chunk_t *res)
+ private_bio_reader_t *this, uint32_t len, chunk_t *res)
{
return read_data_internal(this, len, res, TRUE);
}
METHOD(bio_reader_t, read_data8, bool,
private_bio_reader_t *this, chunk_t *res)
{
- u_int8_t len;
+ uint8_t len;
if (!read_uint8(this, &len))
{
METHOD(bio_reader_t, read_data16, bool,
private_bio_reader_t *this, chunk_t *res)
{
- u_int16_t len;
+ uint16_t len;
if (!read_uint16(this, &len))
{
METHOD(bio_reader_t, read_data24, bool,
private_bio_reader_t *this, chunk_t *res)
{
- u_int32_t len;
+ uint32_t len;
if (!read_uint24(this, &len))
{
METHOD(bio_reader_t, read_data32, bool,
private_bio_reader_t *this, chunk_t *res)
{
- u_int32_t len;
+ uint32_t len;
if (!read_uint32(this, &len))
{
*
* @return number of remaining bytes in buffer
*/
- u_int32_t (*remaining)(bio_reader_t *this);
+ uint32_t (*remaining)(bio_reader_t *this);
/**
* Peek the remaining data, not consuming any bytes.
* @param res pointer to result
* @return TRUE if integer read successfully
*/
- bool (*read_uint8)(bio_reader_t *this, u_int8_t *res);
+ bool (*read_uint8)(bio_reader_t *this, uint8_t *res);
/**
* Read a 16-bit integer from the buffer, advance.
* @param res pointer to result
* @return TRUE if integer read successfully
*/
- bool (*read_uint16)(bio_reader_t *this, u_int16_t *res);
+ bool (*read_uint16)(bio_reader_t *this, uint16_t *res);
/**
* Read a 24-bit integer from the buffer, advance.
* @param res pointer to result
* @return TRUE if integer read successfully
*/
- bool (*read_uint24)(bio_reader_t *this, u_int32_t *res);
+ bool (*read_uint24)(bio_reader_t *this, uint32_t *res);
/**
* Read a 32-bit integer from the buffer, advance.
* @param res pointer to result
* @return TRUE if integer read successfully
*/
- bool (*read_uint32)(bio_reader_t *this, u_int32_t *res);
+ bool (*read_uint32)(bio_reader_t *this, uint32_t *res);
/**
* Read a 64-bit integer from the buffer, advance.
* @param res pointer to result
* @return TRUE if integer read successfully
*/
- bool (*read_uint64)(bio_reader_t *this, u_int64_t *res);
+ bool (*read_uint64)(bio_reader_t *this, uint64_t *res);
/**
* Read a chunk of len bytes, advance.
* @param res pointer to result, not cloned
* @return TRUE if data read successfully
*/
- bool (*read_data)(bio_reader_t *this, u_int32_t len, chunk_t *res);
+ bool (*read_data)(bio_reader_t *this, uint32_t len, chunk_t *res);
/**
* Read a 8-bit integer from the end of the buffer, reduce remaining.
* @param res pointer to result
* @return TRUE if integer read successfully
*/
- bool (*read_uint8_end)(bio_reader_t *this, u_int8_t *res);
+ bool (*read_uint8_end)(bio_reader_t *this, uint8_t *res);
/**
* Read a 16-bit integer from the end of the buffer, reduce remaining.
* @param res pointer to result
* @return TRUE if integer read successfully
*/
- bool (*read_uint16_end)(bio_reader_t *this, u_int16_t *res);
+ bool (*read_uint16_end)(bio_reader_t *this, uint16_t *res);
/**
* Read a 24-bit integer from the end of the buffer, reduce remaining.
* @param res pointer to result
* @return TRUE if integer read successfully
*/
- bool (*read_uint24_end)(bio_reader_t *this, u_int32_t *res);
+ bool (*read_uint24_end)(bio_reader_t *this, uint32_t *res);
/**
* Read a 32-bit integer from the end of the buffer, reduce remaining.
* @param res pointer to result
* @return TRUE if integer read successfully
*/
- bool (*read_uint32_end)(bio_reader_t *this, u_int32_t *res);
+ bool (*read_uint32_end)(bio_reader_t *this, uint32_t *res);
/**
* Read a 64-bit integer from the end of the buffer, reduce remaining.
* @param res pointer to result
* @return TRUE if integer read successfully
*/
- bool (*read_uint64_end)(bio_reader_t *this, u_int64_t *res);
+ bool (*read_uint64_end)(bio_reader_t *this, uint64_t *res);
/**
* Read a chunk of len bytes from the end of the buffer, reduce remaining.
* @param res ponter to result, not cloned
* @return TRUE if data read successfully
*/
- bool (*read_data_end)(bio_reader_t *this, u_int32_t len, chunk_t *res);
+ bool (*read_data_end)(bio_reader_t *this, uint32_t len, chunk_t *res);
/**
* Read a chunk of bytes with a 8-bit length header, advance.
}
METHOD(bio_writer_t, write_uint8, void,
- private_bio_writer_t *this, u_int8_t value)
+ private_bio_writer_t *this, uint8_t value)
{
increase(this, 1);
this->buf.ptr[this->used] = value;
}
METHOD(bio_writer_t, write_uint16, void,
- private_bio_writer_t *this, u_int16_t value)
+ private_bio_writer_t *this, uint16_t value)
{
increase(this, 2);
htoun16(this->buf.ptr + this->used, value);
}
METHOD(bio_writer_t, write_uint24, void,
- private_bio_writer_t *this, u_int32_t value)
+ private_bio_writer_t *this, uint32_t value)
{
increase(this, 3);
value = htonl(value);
}
METHOD(bio_writer_t, write_uint32, void,
- private_bio_writer_t *this, u_int32_t value)
+ private_bio_writer_t *this, uint32_t value)
{
increase(this, 4);
htoun32(this->buf.ptr + this->used, value);
}
METHOD(bio_writer_t, write_uint64, void,
- private_bio_writer_t *this, u_int64_t value)
+ private_bio_writer_t *this, uint64_t value)
{
increase(this, 8);
htoun64(this->buf.ptr + this->used, value);
METHOD(bio_writer_t, wrap24, void,
private_bio_writer_t *this)
{
- u_int32_t len;
+ uint32_t len;
increase(this, 3);
memmove(this->buf.ptr + 3, this->buf.ptr, this->used);
/**
* See header
*/
-bio_writer_t *bio_writer_create(u_int32_t bufsize)
+bio_writer_t *bio_writer_create(uint32_t bufsize)
{
private_bio_writer_t *this;
*
* @param value value to append
*/
- void (*write_uint8)(bio_writer_t *this, u_int8_t value);
+ void (*write_uint8)(bio_writer_t *this, uint8_t value);
/**
* Append a 16-bit integer to the buffer.
*
* @param value value to append
*/
- void (*write_uint16)(bio_writer_t *this, u_int16_t value);
+ void (*write_uint16)(bio_writer_t *this, uint16_t value);
/**
* Append a 24-bit integer to the buffer.
*
* @param value value to append
*/
- void (*write_uint24)(bio_writer_t *this, u_int32_t value);
+ void (*write_uint24)(bio_writer_t *this, uint32_t value);
/**
* Append a 32-bit integer to the buffer.
*
* @param value value to append
*/
- void (*write_uint32)(bio_writer_t *this, u_int32_t value);
+ void (*write_uint32)(bio_writer_t *this, uint32_t value);
/**
* Append a 64-bit integer to the buffer.
*
* @param value value to append
*/
- void (*write_uint64)(bio_writer_t *this, u_int64_t value);
+ void (*write_uint64)(bio_writer_t *this, uint64_t value);
/**
* Append a chunk of data without a length header.
*
* @param bufsize initially allocated buffer size
*/
-bio_writer_t *bio_writer_create(u_int32_t bufsize);
+bio_writer_t *bio_writer_create(uint32_t bufsize);
#endif /** BIO_WRITER_H_ @}*/
*/
struct array_t {
/** number of elements currently in array (not counting head/tail) */
- u_int32_t count;
+ uint32_t count;
/** size of each element, 0 for a pointer based array */
- u_int16_t esize;
+ uint16_t esize;
/** allocated but unused elements at array front */
- u_int8_t head;
+ uint8_t head;
/** allocated but unused elements at array end */
- u_int8_t tail;
+ uint8_t tail;
/** array elements */
void *data;
};
/**
* Get the actual size of a number of elements
*/
-static size_t get_size(array_t *array, u_int32_t num)
+static size_t get_size(array_t *array, uint32_t num)
{
if (array->esize)
{
/**
* Increase allocated but unused tail room to at least "room"
*/
-static void make_tail_room(array_t *array, u_int8_t room)
+static void make_tail_room(array_t *array, uint8_t room)
{
if (array->tail < room)
{
/**
* Increase allocated but unused head room to at least "room"
*/
-static void make_head_room(array_t *array, u_int8_t room)
+static void make_head_room(array_t *array, uint8_t room)
{
if (array->head < room)
{
- u_int8_t increase = room - array->head;
+ uint8_t increase = room - array->head;
array->data = realloc(array->data,
get_size(array, array->count + array->tail + room));
array->head++;
}
-array_t *array_create(u_int esize, u_int8_t reserve)
+array_t *array_create(u_int esize, uint8_t reserve)
{
array_t *array;
{
if (array)
{
- u_int32_t tail;
+ uint32_t tail;
tail = array->tail;
if (array->head)
* @param reserve number of items to allocate space for
* @return array instance
*/
-array_t *array_create(u_int esize, u_int8_t reserve);
+array_t *array_create(u_int esize, uint8_t reserve);
/**
* Get the number of elements currently in the array.
AUTH_RULE_EAP_IDENTITY,
/** EAP type to propose for peer authentication, eap_type_t */
AUTH_RULE_EAP_TYPE,
- /** EAP vendor for vendor specific type, u_int32_t */
+ /** EAP vendor for vendor specific type, uint32_t */
AUTH_RULE_EAP_VENDOR,
/** XAUTH backend name to use, char* */
AUTH_RULE_XAUTH_BACKEND,
*/
static void add_chunks(chunk_t a, chunk_t b)
{
- u_int16_t sum;
- u_int8_t rem = 0;
+ uint16_t sum;
+ uint8_t rem = 0;
ssize_t i, j;
for (i = a.len - 1, j = b.len -1; i >= 0 && j >= 0; i--, j--)
* Do the actual key derivation with the given hasher, password and id.
*/
static bool derive_key(hash_algorithm_t hash, chunk_t unicode, chunk_t salt,
- u_int64_t iterations, char id, chunk_t result)
+ uint64_t iterations, char id, chunk_t result)
{
chunk_t out = result, D, S, P = chunk_empty, I, Ai, B, Ij;
hasher_t *hasher;
size_t Slen, v, u;
- u_int64_t i;
+ uint64_t i;
bool success = FALSE;
hasher = lib->crypto->create_hasher(lib->crypto, hash);
* Described in header
*/
bool pkcs12_derive_key(hash_algorithm_t hash, chunk_t password, chunk_t salt,
- u_int64_t iterations, pkcs12_key_type_t type, chunk_t key)
+ uint64_t iterations, pkcs12_key_type_t type, chunk_t key)
{
chunk_t unicode = chunk_empty;
bool success;
* @return TRUE on success
*/
bool pkcs12_derive_key(hash_algorithm_t hash, chunk_t password, chunk_t salt,
- u_int64_t iterations, pkcs12_key_type_t type, chunk_t key);
+ uint64_t iterations, pkcs12_key_type_t type, chunk_t key);
#endif /** PKCS12_H_ @}*/
* @return TRUE if hash created successfully
*/
bool (*get_hash)(hasher_t *this, chunk_t data,
- u_int8_t *hash) __attribute__((warn_unused_result));
+ uint8_t *hash) __attribute__((warn_unused_result));
/**
* Hash data and allocate space for the hash.
* @param buffer pointer where the generated IV will be written
* @return TRUE if IV allocation was successful, FALSE otherwise
*/
- bool (*get_iv)(iv_gen_t *this, u_int64_t seq, size_t size,
- u_int8_t *buffer) __attribute__((warn_unused_result));
+ bool (*get_iv)(iv_gen_t *this, uint64_t seq, size_t size,
+ uint8_t *buffer) __attribute__((warn_unused_result));
/**
* Generates an IV and allocates space for it.
* @param chunk chunk which will hold the generated IV
* @return TRUE if IV allocation was successful, FALSE otherwise
*/
- bool (*allocate_iv)(iv_gen_t *this, u_int64_t seq, size_t size,
+ bool (*allocate_iv)(iv_gen_t *this, uint64_t seq, size_t size,
chunk_t *chunk) __attribute__((warn_unused_result));
/**
};
METHOD(iv_gen_t, get_iv, bool,
- private_iv_gen_t *this, u_int64_t seq, size_t size, u_int8_t *buffer)
+ private_iv_gen_t *this, uint64_t seq, size_t size, uint8_t *buffer)
{
return size == 0;
}
METHOD(iv_gen_t, allocate_iv, bool,
- private_iv_gen_t *this, u_int64_t seq, size_t size, chunk_t *chunk)
+ private_iv_gen_t *this, uint64_t seq, size_t size, chunk_t *chunk)
{
*chunk = chunk_empty;
return size == 0;
};
METHOD(iv_gen_t, get_iv, bool,
- private_iv_gen_t *this, u_int64_t seq, size_t size, u_int8_t *buffer)
+ private_iv_gen_t *this, uint64_t seq, size_t size, uint8_t *buffer)
{
if (!this->rng)
{
}
METHOD(iv_gen_t, allocate_iv, bool,
- private_iv_gen_t *this, u_int64_t seq, size_t size, chunk_t *chunk)
+ private_iv_gen_t *this, uint64_t seq, size_t size, chunk_t *chunk)
{
if (!this->rng)
{
/**
* Magic value for the initial IV state
*/
-#define SEQ_IV_INIT_STATE (~(u_int64_t)0)
+#define SEQ_IV_INIT_STATE (~(uint64_t)0)
#define SEQ_IV_HIGH_MASK (1ULL << 63)
typedef struct private_iv_gen_t private_iv_gen_t;
/**
* Previously passed sequence number in lower space to enforce uniqueness
*/
- u_int64_t prevl;
+ uint64_t prevl;
/**
* Previously passed sequence number in upper space to enforce uniqueness
*/
- u_int64_t prevh;
+ uint64_t prevh;
/**
* Salt to mask counter
*/
- u_int8_t *salt;
+ uint8_t *salt;
};
METHOD(iv_gen_t, get_iv, bool,
- private_iv_gen_t *this, u_int64_t seq, size_t size, u_int8_t *buffer)
+ private_iv_gen_t *this, uint64_t seq, size_t size, uint8_t *buffer)
{
- u_int8_t iv[sizeof(u_int64_t)];
+ uint8_t iv[sizeof(uint64_t)];
size_t len = size;
if (!this->salt)
{
return FALSE;
}
- if (size < sizeof(u_int64_t))
+ if (size < sizeof(uint64_t))
{
return FALSE;
}
{
this->prevl = seq;
}
- if (len > sizeof(u_int64_t))
+ if (len > sizeof(uint64_t))
{
- len = sizeof(u_int64_t);
+ len = sizeof(uint64_t);
memset(buffer, 0, size - len);
}
htoun64(iv, seq);
- memxor(iv, this->salt, sizeof(u_int64_t));
- memcpy(buffer + size - len, iv + sizeof(u_int64_t) - len, len);
+ memxor(iv, this->salt, sizeof(uint64_t));
+ memcpy(buffer + size - len, iv + sizeof(uint64_t) - len, len);
return TRUE;
}
METHOD(iv_gen_t, allocate_iv, bool,
- private_iv_gen_t *this, u_int64_t seq, size_t size, chunk_t *chunk)
+ private_iv_gen_t *this, uint64_t seq, size_t size, chunk_t *chunk)
{
*chunk = chunk_alloc(size);
if (!get_iv(this, seq, chunk->len, chunk->ptr))
rng = lib->crypto->create_rng(lib->crypto, RNG_STRONG);
if (rng)
{
- this->salt = malloc(sizeof(u_int64_t));
- if (!rng->get_bytes(rng, sizeof(u_int64_t), this->salt))
+ this->salt = malloc(sizeof(uint64_t));
+ if (!rng->get_bytes(rng, sizeof(uint64_t), this->salt))
{
free(this->salt);
this->salt = NULL;
* @return TRUE if mac generated successfully
*/
bool (*get_mac)(mac_t *this, chunk_t data,
- u_int8_t *out) __attribute__((warn_unused_result));
+ uint8_t *out) __attribute__((warn_unused_result));
/**
* Get the size of the resulting MAC.
/**
* Counter
*/
- u_int32_t counter;
+ uint32_t counter;
/**
* Set if counter has reached 2^32
* @return TRUE if nonce allocation was successful, FALSE otherwise
*/
bool (*get_nonce)(nonce_gen_t *this, size_t size,
- u_int8_t *buffer) __attribute__((warn_unused_result));
+ uint8_t *buffer) __attribute__((warn_unused_result));
/**
* Generates a nonce and allocates space for it.
/**
* Iterations for key derivation
*/
- u_int64_t iterations;
+ uint64_t iterations;
/**
* Encryption algorithm
*/
static bool verify_padding(crypter_t *crypter, chunk_t *blob)
{
- u_int8_t padding, count;
+ uint8_t padding, count;
padding = count = blob->ptr[blob->len - 1];
* Function F of PBKDF2
*/
static bool pbkdf2_f(chunk_t block, prf_t *prf, chunk_t seed,
- u_int64_t iterations)
+ uint64_t iterations)
{
chunk_t u;
- u_int64_t i;
+ uint64_t i;
u = chunk_alloca(prf->get_block_size(prf));
if (!prf->get_bytes(prf, seed, u.ptr))
prf_t *prf;
chunk_t keymat, block, seed;
size_t blocks;
- u_int32_t i = 0;
+ uint32_t i = 0;
prf = this->data.pbes2.prf;
{
hasher_t *hasher;
chunk_t hash;
- u_int64_t i;
+ uint64_t i;
hasher = this->data.pbes1.hasher;
/**
* Octet which will be appended to the seed, 0 if not used
*/
- u_int8_t counter;
+ uint8_t counter;
/**
* Already given out bytes in current buffer.
};
METHOD(prf_plus_t, get_bytes, bool,
- private_prf_plus_t *this, size_t length, u_int8_t *buffer)
+ private_prf_plus_t *this, size_t length, uint8_t *buffer)
{
size_t round, written = 0;
* @return TRUE if bytes generated successfully
*/
bool (*get_bytes)(prf_plus_t *this, size_t length,
- u_int8_t *buffer) __attribute__((warn_unused_result));
+ uint8_t *buffer) __attribute__((warn_unused_result));
/**
* Allocate pseudo random bytes.
};
METHOD(prf_t, get_bytes, bool,
- private_prf_t *this, chunk_t seed, u_int8_t *buffer)
+ private_prf_t *this, chunk_t seed, uint8_t *buffer)
{
return this->mac->get_mac(this->mac, seed, buffer);
}
* @return TRUE if bytes generated successfully
*/
bool (*get_bytes)(prf_t *this, chunk_t seed,
- u_int8_t *buffer) __attribute__((warn_unused_result));
+ uint8_t *buffer) __attribute__((warn_unused_result));
/**
* Generates pseudo random bytes and allocate space for them.
METHOD(proposal_keywords_t, register_token, void,
private_proposal_keywords_t *this, const char *name, transform_type_t type,
- u_int16_t algorithm, u_int16_t keysize)
+ uint16_t algorithm, uint16_t keysize)
{
proposal_token_t *token;
/**
* The IKE id of the algorithm.
*/
- u_int16_t algorithm;
+ uint16_t algorithm;
/**
* The key size associated with the specific algorithm.
*/
- u_int16_t keysize;
+ uint16_t keysize;
};
/**
* @param keysize the key size associated with the specific algorithm
*/
void (*register_token)(proposal_keywords_t *this, const char *name,
- transform_type_t type, u_int16_t algorithm,
- u_int16_t keysize);
+ transform_type_t type, uint16_t algorithm,
+ uint16_t keysize);
/**
* Register an algorithm name parser.
/*
* Described in header.
*/
-bool rng_get_bytes_not_zero(rng_t *rng, size_t len, u_int8_t *buffer, bool all)
+bool rng_get_bytes_not_zero(rng_t *rng, size_t len, uint8_t *buffer, bool all)
{
- u_int8_t *pos = buffer, *check = buffer + (all ? len : min(1, len));
+ uint8_t *pos = buffer, *check = buffer + (all ? len : min(1, len));
if (!rng->get_bytes(rng, len, pos))
{
* @return TRUE if bytes successfully written
*/
bool (*get_bytes)(rng_t *this, size_t len,
- u_int8_t *buffer) __attribute__((warn_unused_result));
+ uint8_t *buffer) __attribute__((warn_unused_result));
/**
* Generates random bytes and allocate space for them.
* @param all TRUE if all bytes have to be non-zero, FALSE for first
* @return TRUE if bytes successfully written
*/
-bool rng_get_bytes_not_zero(rng_t *rng, size_t len, u_int8_t *buffer,
+bool rng_get_bytes_not_zero(rng_t *rng, size_t len, uint8_t *buffer,
bool all) __attribute__((warn_unused_result));
/**
};
METHOD(signer_t, get_signature, bool,
- private_signer_t *this, chunk_t data, u_int8_t *buffer)
+ private_signer_t *this, chunk_t data, uint8_t *buffer)
{
if (buffer)
{
- u_int8_t mac[this->mac->get_mac_size(this->mac)];
+ uint8_t mac[this->mac->get_mac_size(this->mac)];
if (!this->mac->get_mac(this->mac, data, mac))
{
{
if (chunk)
{
- u_int8_t mac[this->mac->get_mac_size(this->mac)];
+ uint8_t mac[this->mac->get_mac_size(this->mac)];
if (!this->mac->get_mac(this->mac, data, mac))
{
METHOD(signer_t, verify_signature, bool,
private_signer_t *this, chunk_t data, chunk_t signature)
{
- u_int8_t mac[this->mac->get_mac_size(this->mac)];
+ uint8_t mac[this->mac->get_mac_size(this->mac)];
if (signature.len != this->truncation)
{
* @return TRUE if signature created successfully
*/
bool (*get_signature)(signer_t *this, chunk_t data,
- u_int8_t *buffer) __attribute__((warn_unused_result));
+ uint8_t *buffer) __attribute__((warn_unused_result));
/**
* Generate a signature and allocate space for it.
/**
* Vendor Id
*/
- u_int32_t vendor;
+ uint32_t vendor;
};
/**
* EAP packet format
*/
typedef struct __attribute__((packed)) {
- u_int8_t code;
- u_int8_t identifier;
- u_int16_t length;
- u_int8_t type;
- u_int8_t data;
+ uint8_t code;
+ uint8_t identifier;
+ uint16_t length;
+ uint8_t type;
+ uint8_t data;
} eap_packet_t;
/**
/** mode of SA (tunnel, transport) */
ipsec_mode_t mode;
/** unique ID */
- u_int32_t reqid;
+ uint32_t reqid;
/** number of policies of the same kind (in/out/fwd) attached to SA */
- u_int32_t policy_count;
+ uint32_t policy_count;
/** details about ESP/AH */
struct {
/** TRUE if this protocol is used */
bool use;
/** SPI for ESP/AH */
- u_int32_t spi;
+ uint32_t spi;
} esp, ah;
/** details about IPComp */
struct {
/** the IPComp transform used */
- u_int16_t transform;
+ uint16_t transform;
/** CPI for IPComp */
- u_int16_t cpi;
+ uint16_t cpi;
} ipcomp;
};
struct lifetime_cfg_t {
struct {
/** Limit before the SA gets invalid. */
- u_int64_t life;
+ uint64_t life;
/** Limit before the SA gets rekeyed. */
- u_int64_t rekey;
+ uint64_t rekey;
/** The range of a random value subtracted from rekey. */
- u_int64_t jitter;
+ uint64_t jitter;
} time, bytes, packets;
};
*/
struct mark_t {
/** Mark value */
- u_int32_t value;
+ uint32_t value;
/** Mark mask */
- u_int32_t mask;
+ uint32_t mask;
};
/**
METHOD(host_t, is_anyaddr, bool,
private_host_t *this)
{
- static const u_int8_t zeroes[IPV6_LEN];
+ static const uint8_t zeroes[IPV6_LEN];
switch (this->address.sa_family)
{
else
{
void *address;
- u_int16_t port;
+ uint16_t port;
int len;
address = &this->address6.sin6_addr;
return this->address.sa_family;
}
-METHOD(host_t, get_port, u_int16_t,
+METHOD(host_t, get_port, uint16_t,
private_host_t *this)
{
switch (this->address.sa_family)
}
METHOD(host_t, set_port, void,
- private_host_t *this, u_int16_t port)
+ private_host_t *this, uint16_t port)
{
switch (this->address.sa_family)
{
/*
* Create a %any host with port
*/
-static host_t *host_create_any_port(int family, u_int16_t port)
+static host_t *host_create_any_port(int family, uint16_t port)
{
host_t *this;
* Described in header.
*/
host_t *host_create_from_string_and_family(char *string, int family,
- u_int16_t port)
+ uint16_t port)
{
union {
struct sockaddr_in v4;
/*
* Described in header.
*/
-host_t *host_create_from_string(char *string, u_int16_t port)
+host_t *host_create_from_string(char *string, uint16_t port)
{
return host_create_from_string_and_family(string, AF_UNSPEC, port);
}
/*
* Described in header.
*/
-host_t *host_create_from_dns(char *string, int af, u_int16_t port)
+host_t *host_create_from_dns(char *string, int af, uint16_t port)
{
host_t *this;
/*
* Described in header.
*/
-host_t *host_create_from_chunk(int family, chunk_t address, u_int16_t port)
+host_t *host_create_from_chunk(int family, chunk_t address, uint16_t port)
{
private_host_t *this;
if (bytes < len)
{
memset(target + bytes, 0x00, len - bytes);
- target[bytes] = (u_int8_t)(0xff << bits);
+ target[bytes] = (uint8_t)(0xff << bits);
}
return &this->public;
}
*
* @return port number
*/
- u_int16_t (*get_port) (host_t *this);
+ uint16_t (*get_port) (host_t *this);
/**
* Set the port of this host
*
* @param port port number
*/
- void (*set_port) (host_t *this, u_int16_t port);
+ void (*set_port) (host_t *this, uint16_t port);
/**
* Compare the ips of two hosts hosts.
* @param port port number
* @return host_t, NULL if string not an address.
*/
-host_t *host_create_from_string(char *string, u_int16_t port);
+host_t *host_create_from_string(char *string, uint16_t port);
/**
* Same as host_create_from_string(), but with the option to enforce a family.
* @return host_t, NULL if string not an address.
*/
host_t *host_create_from_string_and_family(char *string, int family,
- u_int16_t port);
+ uint16_t port);
/**
* Constructor to create a host_t from a DNS name.
* @param port port number
* @return host_t, NULL lookup failed
*/
-host_t *host_create_from_dns(char *string, int family, u_int16_t port);
+host_t *host_create_from_dns(char *string, int family, uint16_t port);
/**
* Constructor to create a host_t object from an address chunk.
* @param port port number
* @return host_t, NULL if family not supported/chunk invalid
*/
-host_t *host_create_from_chunk(int family, chunk_t address, u_int16_t port);
+host_t *host_create_from_chunk(int family, chunk_t address, uint16_t port);
/**
* Constructor to create a host_t object from a sockaddr struct
/**
* DSCP value on packet
*/
- u_int8_t dscp;
+ uint8_t dscp;
/**
* message data
this->adjusted_data = this->data = data;
}
-METHOD(packet_t, get_dscp, u_int8_t,
+METHOD(packet_t, get_dscp, uint8_t,
private_packet_t *this)
{
return this->dscp;
}
METHOD(packet_t, set_dscp, void,
- private_packet_t *this, u_int8_t value)
+ private_packet_t *this, uint8_t value)
{
this->dscp = value;
}
*
* @return DSCP value
*/
- u_int8_t (*get_dscp)(packet_t *this);
+ uint8_t (*get_dscp)(packet_t *this);
/**
* Set the DiffServ Code Point to use on this packet.
*
* @param value DSCP value
*/
- void (*set_dscp)(packet_t *this, u_int8_t value);
+ void (*set_dscp)(packet_t *this, uint8_t value);
/**
* Increase the offset where the actual packet data starts.
/**
* Netmask for address
*/
- u_int8_t netmask;
+ uint8_t netmask;
};
/**
#if __FreeBSD__ >= 10
static bool set_address_and_mask(struct in_aliasreq *ifra, host_t *addr,
- u_int8_t netmask)
+ uint8_t netmask)
{
host_t *mask;
* on FreeBSD 10 an newer.
*/
static bool set_address_impl(private_tun_device_t *this, host_t *addr,
- u_int8_t netmask)
+ uint8_t netmask)
{
struct in_aliasreq ifra;
* Set the address using the classic SIOCSIFADDR etc. commands on other systems.
*/
static bool set_address_impl(private_tun_device_t *this, host_t *addr,
- u_int8_t netmask)
+ uint8_t netmask)
{
struct ifreq ifr;
host_t *mask;
#endif /* __FreeBSD__ */
METHOD(tun_device_t, set_address, bool,
- private_tun_device_t *this, host_t *addr, u_int8_t netmask)
+ private_tun_device_t *this, host_t *addr, uint8_t netmask)
{
if (!set_address_impl(this, addr, netmask))
{
}
METHOD(tun_device_t, get_address, host_t*,
- private_tun_device_t *this, u_int8_t *netmask)
+ private_tun_device_t *this, uint8_t *netmask)
{
if (netmask && this->address)
{
#ifdef __APPLE__
/* UTUN's expect the packets to be prepended by a 32-bit protocol number
* instead of parsing the packet again, we assume IPv4 for now */
- u_int32_t proto = htonl(AF_INET);
+ uint32_t proto = htonl(AF_INET);
packet = chunk_cata("cc", chunk_from_thing(proto), packet);
#endif
s = write(this->tunfd, packet.ptr, packet.len);
data.len = len;
#ifdef __APPLE__
/* UTUN's prepend packets with a 32-bit protocol number */
- data = chunk_skip(data, sizeof(u_int32_t));
+ data = chunk_skip(data, sizeof(uint32_t));
#endif
*packet = chunk_clone(data);
return TRUE;
* @param netmask the netmask to use
* @return TRUE if operation successful
*/
- bool (*set_address)(tun_device_t *this, host_t *addr, u_int8_t netmask);
+ bool (*set_address)(tun_device_t *this, host_t *addr, uint8_t netmask);
/**
* Get the IP address previously assigned to using set_address().
* @param netmask pointer receiving the configured netmask, or NULL
* @return address previously set, NULL if none
*/
- host_t* (*get_address)(tun_device_t *this, u_int8_t *netmask);
+ host_t* (*get_address)(tun_device_t *this, uint8_t *netmask);
/**
* Bring the TUN device up
*/
struct pen_type_t {
pen_t vendor_id;
- u_int32_t type;
+ uint32_t type;
};
/**
* @param type type to create a pen_type_t
* @return created pen_type_t
*/
-static inline pen_type_t pen_type_create(pen_t vendor_id, u_int32_t type)
+static inline pen_type_t pen_type_create(pen_t vendor_id, uint32_t type)
{
pen_type_t pen_type = { vendor_id, type };
return pen_type;
* @return TRUE if vendor_id and type matches pen_type
*/
static inline bool pen_type_is(pen_type_t pen_type,
- pen_t vendor_id, u_int32_t type)
+ pen_t vendor_id, uint32_t type)
{
return pen_type.vendor_id == vendor_id && pen_type.type == type;
}
/**
* Number of words in the key input block.
*/
- u_int32_t aes_Nkey;
+ uint32_t aes_Nkey;
/**
* The number of cipher rounds.
*/
- u_int32_t aes_Nrnd;
+ uint32_t aes_Nrnd;
/**
* The encryption key schedule.
*/
- u_int32_t aes_e_key[AES_KS_LENGTH];
+ uint32_t aes_e_key[AES_KS_LENGTH];
/**
* The decryption key schedule.
*/
- u_int32_t aes_d_key[AES_KS_LENGTH];
+ uint32_t aes_d_key[AES_KS_LENGTH];
/**
* Key size of this AES cypher object.
*/
- u_int32_t key_size;
+ uint32_t key_size;
};
/**
*/
#define bval(x,n) ((unsigned char)((x) >> 8 * (n)))
#define bytes2word(b0, b1, b2, b3) \
- ((u_int32_t)(b3) << 24 | (u_int32_t)(b2) << 16 | (u_int32_t)(b1) << 8 | (b0))
+ ((uint32_t)(b3) << 24 | (uint32_t)(b2) << 16 | (uint32_t)(b1) << 8 | (b0))
/* little endian processor without data alignment restrictions: AES_LE_OK */
#ifdef AES_LE_OK
/* little endian processor without data alignment restrictions */
-#define word_in(x) *(u_int32_t*)(x)
-#define const_word_in(x) *(const u_int32_t*)(x)
-#define word_out(x,v) *(u_int32_t*)(x) = (v)
-#define const_word_out(x,v) *(const u_int32_t*)(x) = (v)
+#define word_in(x) *(uint32_t*)(x)
+#define const_word_in(x) *(const uint32_t*)(x)
+#define word_out(x,v) *(uint32_t*)(x) = (v)
+#define const_word_out(x,v) *(const uint32_t*)(x) = (v)
#else
/* slower but generic big endian or with data alignment restrictions */
/* some additional "const" touches to stop "gcc -Wcast-qual" complains --jjo */
-#define word_in(x) ((u_int32_t)(((unsigned char *)(x))[0])|((u_int32_t)(((unsigned char *)(x))[1])<<8)|((u_int32_t)(((unsigned char *)(x))[2])<<16)|((u_int32_t)(((unsigned char *)(x))[3])<<24))
-#define const_word_in(x) ((const u_int32_t)(((const unsigned char *)(x))[0])|((const u_int32_t)(((const unsigned char *)(x))[1])<<8)|((const u_int32_t)(((const unsigned char *)(x))[2])<<16)|((const u_int32_t)(((const unsigned char *)(x))[3])<<24))
+#define word_in(x) ((uint32_t)(((unsigned char *)(x))[0])|((uint32_t)(((unsigned char *)(x))[1])<<8)|((uint32_t)(((unsigned char *)(x))[2])<<16)|((uint32_t)(((unsigned char *)(x))[3])<<24))
+#define const_word_in(x) ((const uint32_t)(((const unsigned char *)(x))[0])|((const uint32_t)(((const unsigned char *)(x))[1])<<8)|((const uint32_t)(((const unsigned char *)(x))[2])<<16)|((const uint32_t)(((const unsigned char *)(x))[3])<<24))
#define word_out(x,v) ((unsigned char *)(x))[0]=(v),((unsigned char *)(x))[1]=((v)>>8),((unsigned char *)(x))[2]=((v)>>16),((unsigned char *)(x))[3]=((v)>>24)
#define const_word_out(x,v) ((const unsigned char *)(x))[0]=(v),((const unsigned char *)(x))[1]=((v)>>8),((const unsigned char *)(x))[2]=((v)>>16),((const unsigned char *)(x))[3]=((v)>>24)
#endif
// this table can be a table of bytes if the key schedule
// code is adjusted accordingly
-static const u_int32_t rcon_tab[29] =
+static const uint32_t rcon_tab[29] =
{
w0(01), w0(02), w0(04), w0(08),
w0(10), w0(20), w0(40), w0(80),
#undef r
#define r r0
-static const u_int32_t ft_tab[4][256] =
+static const uint32_t ft_tab[4][256] =
{ { f_table },
#undef r
#define r r1
#undef r
#define r r0
-static const u_int32_t it_tab[4][256] =
+static const uint32_t it_tab[4][256] =
{ { i_table },
#undef r
#define r r1
#undef r
#define r(p,q,r,s) w0(q)
-static const u_int32_t fl_tab[4][256] =
+static const uint32_t fl_tab[4][256] =
{ { f_table },
#undef r
#define r(p,q,r,s) w1(q)
#undef w
#define w w0
-static const u_int32_t il_tab[4][256] =
+static const uint32_t il_tab[4][256] =
{ { li_table },
#undef w
#define w w1
#undef r
#define r r0
-static const u_int32_t im_tab[4][256] =
+static const uint32_t im_tab[4][256] =
{ { m_table },
#undef r
#define r r1
static void encrypt_block(const private_aes_crypter_t *this,
const unsigned char in_blk[], unsigned char out_blk[])
{
- u_int32_t locals(b0, b1);
- const u_int32_t *kp = this->aes_e_key;
+ uint32_t locals(b0, b1);
+ const uint32_t *kp = this->aes_e_key;
state_in(b0, in_blk, kp); kp += nc;
static void decrypt_block(const private_aes_crypter_t *this,
const unsigned char in_blk[], unsigned char out_blk[])
{
- u_int32_t locals(b0, b1);
- const u_int32_t *kp = this->aes_d_key;
+ uint32_t locals(b0, b1);
+ const uint32_t *kp = this->aes_d_key;
state_in(b0, in_blk, kp); kp += nc;
private_aes_crypter_t *this, chunk_t data, chunk_t iv, chunk_t *decrypted)
{
int pos;
- const u_int32_t *iv_i;
- u_int8_t *in, *out;
+ const uint32_t *iv_i;
+ uint8_t *in, *out;
if (decrypted)
{
decrypt_block(this, in, out);
if (pos==0)
{
- iv_i=(const u_int32_t*) (iv.ptr);
+ iv_i=(const uint32_t*) (iv.ptr);
}
else
{
- iv_i=(const u_int32_t*) (in-16);
+ iv_i=(const uint32_t*) (in-16);
}
- *((u_int32_t *)(&out[ 0])) ^= iv_i[0];
- *((u_int32_t *)(&out[ 4])) ^= iv_i[1];
- *((u_int32_t *)(&out[ 8])) ^= iv_i[2];
- *((u_int32_t *)(&out[12])) ^= iv_i[3];
+ *((uint32_t *)(&out[ 0])) ^= iv_i[0];
+ *((uint32_t *)(&out[ 4])) ^= iv_i[1];
+ *((uint32_t *)(&out[ 8])) ^= iv_i[2];
+ *((uint32_t *)(&out[12])) ^= iv_i[3];
in-=16;
out-=16;
pos-=16;
private_aes_crypter_t *this, chunk_t data, chunk_t iv, chunk_t *encrypted)
{
int pos;
- const u_int32_t *iv_i;
- u_int8_t *in, *out;
+ const uint32_t *iv_i;
+ uint8_t *in, *out;
in = data.ptr;
out = data.ptr;
{
if (pos==0)
{
- iv_i=(const u_int32_t*) iv.ptr;
+ iv_i=(const uint32_t*) iv.ptr;
}
else
{
- iv_i=(const u_int32_t*) (out-16);
+ iv_i=(const uint32_t*) (out-16);
}
- *((u_int32_t *)(&out[ 0])) = iv_i[0]^*((const u_int32_t *)(&in[ 0]));
- *((u_int32_t *)(&out[ 4])) = iv_i[1]^*((const u_int32_t *)(&in[ 4]));
- *((u_int32_t *)(&out[ 8])) = iv_i[2]^*((const u_int32_t *)(&in[ 8]));
- *((u_int32_t *)(&out[12])) = iv_i[3]^*((const u_int32_t *)(&in[12]));
+ *((uint32_t *)(&out[ 0])) = iv_i[0]^*((const uint32_t *)(&in[ 0]));
+ *((uint32_t *)(&out[ 4])) = iv_i[1]^*((const uint32_t *)(&in[ 4]));
+ *((uint32_t *)(&out[ 8])) = iv_i[2]^*((const uint32_t *)(&in[ 8]));
+ *((uint32_t *)(&out[12])) = iv_i[3]^*((const uint32_t *)(&in[12]));
encrypt_block(this, out, out);
in+=16;
out+=16;
METHOD(crypter_t, set_key, bool,
private_aes_crypter_t *this, chunk_t key)
{
- u_int32_t *kf, *kt, rci, f = 0;
- u_int8_t *in_key = key.ptr;
+ uint32_t *kf, *kt, rci, f = 0;
+ uint8_t *in_key = key.ptr;
this->aes_Nrnd = (this->aes_Nkey > (nc) ? this->aes_Nkey : (nc)) + 6;
if(!f)
{
- u_int32_t i;
+ uint32_t i;
kt = this->aes_d_key + nc * this->aes_Nrnd;
kf = this->aes_e_key;
* First block with control information
*/
typedef struct __attribute__((packed)) {
- BITFIELD4(u_int8_t,
+ BITFIELD4(uint8_t,
/* size of p length field q, as q-1 */
q_len: 3,
/* size of our ICV t, as (t-2)/2 */
* Counter block
*/
typedef struct __attribute__((packed)) {
- BITFIELD3(u_int8_t,
+ BITFIELD3(uint8_t,
/* size of p length field q, as q-1 */
q_len: 3,
zero: 3,
/**
* Build a counter block for counter i
*/
-static void build_ctr(private_aesni_ccm_t *this, u_int32_t i, u_char *iv,
+static void build_ctr(private_aesni_ccm_t *this, uint32_t i, u_char *iv,
void *out)
{
ctr_t *ctr = out;
* Calculate the ICV for the b0 and associated data
*/
static __m128i icv_header(private_aesni_ccm_t *this, size_t len, u_char *iv,
- u_int16_t alen, u_char *assoc)
+ uint16_t alen, u_char *assoc)
{
__m128i *ks, b, t, c;
u_int i, round, blocks, rem;
};
METHOD(mac_t, get_mac, bool,
- private_mac_t *this, chunk_t data, u_int8_t *out)
+ private_mac_t *this, chunk_t data, uint8_t *out)
{
__m128i *ks, t, l, *bi;
u_int blocks, rem, i;
struct {
char nonce[4];
char iv[8];
- u_int32_t counter;
+ uint32_t counter;
} __attribute__((packed, aligned(sizeof(__m128i)))) state;
};
__m128i b;
htoun64(&b, alen * 8);
- htoun64((u_char*)&b + sizeof(u_int64_t), dlen * 8);
+ htoun64((u_char*)&b + sizeof(uint64_t), dlen * 8);
return ghash(this->h, y, b);
}
};
METHOD(mac_t, get_mac, bool,
- private_aesni_mac_t *this, chunk_t data, u_int8_t *out)
+ private_aesni_mac_t *this, chunk_t data, uint8_t *out)
{
__m128i *ks, e, *bi;
u_int blocks, rem, i;
}
METHOD(hasher_t, get_hash, bool,
- private_af_alg_hasher_t *this, chunk_t chunk, u_int8_t *hash)
+ private_af_alg_hasher_t *this, chunk_t chunk, uint8_t *hash)
{
return this->ops->hash(this->ops, chunk, hash, this->size);
}
}
METHOD(af_alg_ops_t, crypt, bool,
- private_af_alg_ops_t *this, u_int32_t type, chunk_t iv, chunk_t data,
+ private_af_alg_ops_t *this, uint32_t type, chunk_t iv, chunk_t data,
char *out)
{
struct msghdr msg = {};
* @param out buffer write processed data to
* @return TRUE if successful
*/
- bool (*crypt)(af_alg_ops_t *this, u_int32_t type, chunk_t iv, chunk_t data,
+ bool (*crypt)(af_alg_ops_t *this, uint32_t type, chunk_t iv, chunk_t data,
char *out);
/**
}
METHOD(prf_t, get_bytes, bool,
- private_af_alg_prf_t *this, chunk_t seed, u_int8_t *buffer)
+ private_af_alg_prf_t *this, chunk_t seed, uint8_t *buffer)
{
return this->ops->hash(this->ops, seed, buffer, this->block_size);
}
}
METHOD(signer_t, get_signature, bool,
- private_af_alg_signer_t *this, chunk_t data, u_int8_t *buffer)
+ private_af_alg_signer_t *this, chunk_t data, uint8_t *buffer)
{
return this->ops->hash(this->ops, data, buffer, this->block_size);
}
}
/**
- * read a u_int32_t from a blob
+ * read a uint32_t from a blob
*/
-static u_int32_t read_uint32(chunk_t *blob)
+static uint32_t read_uint32(chunk_t *blob)
{
- u_int32_t val;
+ uint32_t val;
- if (blob->len < sizeof(u_int32_t))
+ if (blob->len < sizeof(uint32_t))
{
return 0;
}
- val = ntohl(*(u_int32_t*)blob->ptr);
- *blob = chunk_skip(*blob, sizeof(u_int32_t));
+ val = ntohl(*(uint32_t*)blob->ptr);
+ *blob = chunk_skip(*blob, sizeof(uint32_t));
return val;
}
blob = chunk_create(buf, sizeof(buf));
blob.len = read(this->socket, blob.ptr, blob.len);
- if (blob.len < sizeof(u_int32_t) + sizeof(u_char) ||
+ if (blob.len < sizeof(uint32_t) + sizeof(u_char) ||
read_uint32(&blob) != blob.len ||
read_byte(&blob) != SSH_AGENT_ID_RESPONSE)
{
private_agent_private_key_t *this, signature_scheme_t scheme,
chunk_t data, chunk_t *signature)
{
- u_int32_t len, flags;
+ uint32_t len, flags;
char buf[2048];
chunk_t blob;
return FALSE;
}
- len = htonl(1 + sizeof(u_int32_t) * 3 + this->key.len + data.len);
+ len = htonl(1 + sizeof(uint32_t) * 3 + this->key.len + data.len);
buf[0] = SSH_AGENT_SIGN_REQUEST;
if (write(this->socket, &len, sizeof(len)) != sizeof(len) ||
write(this->socket, &buf, 1) != 1)
blob = chunk_create(buf, sizeof(buf));
blob.len = read(this->socket, blob.ptr, blob.len);
- if (blob.len < sizeof(u_int32_t) + sizeof(u_char) ||
+ if (blob.len < sizeof(uint32_t) + sizeof(u_char) ||
read_uint32(&blob) != blob.len ||
read_byte(&blob) != SSH_AGENT_SIGN_RESPONSE)
{
#else
#include <sys/types.h>
#endif
-#define BF_LONG u_int32_t
+#define BF_LONG uint32_t
#endif
#define BF_ROUNDS 16
/**
* Key size of this Blowfish cipher object.
*/
- u_int32_t key_size;
+ uint32_t key_size;
};
METHOD(crypter_t, decrypt, bool,
private_blowfish_crypter_t *this, chunk_t data, chunk_t iv,
chunk_t *decrypted)
{
- u_int8_t *in, *out;
+ uint8_t *in, *out;
if (decrypted)
{
private_blowfish_crypter_t *this, chunk_t data, chunk_t iv,
chunk_t *encrypted)
{
- u_int8_t *in, *out;
+ uint8_t *in, *out;
if (encrypted)
{
* First block with control information
*/
typedef struct __attribute__((packed)) {
- BITFIELD4(u_int8_t,
+ BITFIELD4(uint8_t,
/* size of p length field q, as q-1 */
q_len: 3,
/* size of our ICV t, as (t-2)/2 */
* Counter block
*/
typedef struct __attribute__((packed)) {
- BITFIELD3(u_int8_t,
+ BITFIELD3(uint8_t,
/* size of p length field q, as q-1 */
q_len: 3,
zero: 3,
/**
* Build a counter block for counter i
*/
-static void build_ctr(private_ccm_aead_t *this, u_int32_t i, chunk_t iv,
+static void build_ctr(private_ccm_aead_t *this, uint32_t i, chunk_t iv,
char *out)
{
ctr_t *ctr = (ctr_t*)out;
static bool poly_tail(private_chapoly_aead_t *this, size_t alen, size_t clen)
{
struct {
- u_int64_t alen;
- u_int64_t clen;
+ uint64_t alen;
+ uint64_t clen;
} b;
b.alen = htole64(alen);
{
u_char *out;
- if (sizeof(plain.len) > sizeof(u_int32_t) && plain.len > P_MAX)
+ if (sizeof(plain.len) > sizeof(uint32_t) && plain.len > P_MAX)
{
return FALSE;
}
return FALSE;
}
encr.len -= POLY_ICV_SIZE;
- if (sizeof(encr.len) > sizeof(u_int32_t) && encr.len > P_MAX)
+ if (sizeof(encr.len) > sizeof(uint32_t) && encr.len > P_MAX)
{
return FALSE;
}
/**
* ChaCha20 state matrix
*/
- u_int32_t m[16];
+ uint32_t m[16];
/**
* Poly1305 update key
*/
- u_int32_t r[5];
+ uint32_t r[5];
/**
* Poly1305 state
*/
- u_int32_t h[5];
+ uint32_t h[5];
/**
* Poly1305 finalize key
*/
- u_int32_t s[4];
+ uint32_t s[4];
};
/**
* XOR a 32-bit integer into an unaligned destination
*/
-static inline void xor32u(void *p, u_int32_t x)
+static inline void xor32u(void *p, uint32_t x)
{
- u_int32_t y;
+ uint32_t y;
memcpy(&y, p, sizeof(y));
y ^= x;
/**
* Multiply two 64-bit words
*/
-static inline u_int64_t mlt(u_int64_t a, u_int64_t b)
+static inline uint64_t mlt(uint64_t a, uint64_t b)
{
return a * b;
}
/**
* Shift a 64-bit unsigned integer v right by n bits, clamp to 32 bit
*/
-static inline u_int32_t sr(u_int64_t v, u_char n)
+static inline uint32_t sr(uint64_t v, u_char n)
{
return v >> n;
}
/**
* Circular left shift by n bits
*/
-static inline u_int32_t rotl32(u_int32_t v, u_char n)
+static inline uint32_t rotl32(uint32_t v, u_char n)
{
return (v << n) | (v >> (sizeof(v) * 8 - n));
}
/**
- * AND two values, using a native integer size >= sizeof(u_int32_t)
+ * AND two values, using a native integer size >= sizeof(uint32_t)
*/
static inline u_long and(u_long v, u_long mask)
{
*/
static void chacha_block_xor(private_chapoly_drv_portable_t *this, void *data)
{
- u_int32_t x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xa, xb, xc, xd, xe, xf;
- u_int32_t *out = data;
+ uint32_t x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xa, xb, xc, xd, xe, xf;
+ uint32_t *out = data;
u_int i;
x0 = this->m[ 0];
METHOD(chapoly_drv_t, poly, bool,
private_chapoly_drv_portable_t *this, u_char *data, u_int blocks)
{
- u_int32_t r0, r1, r2, r3, r4;
- u_int32_t s1, s2, s3, s4;
- u_int32_t h0, h1, h2, h3, h4;
- u_int64_t d0, d1, d2, d3, d4;
+ uint32_t r0, r1, r2, r3, r4;
+ uint32_t s1, s2, s3, s4;
+ uint32_t h0, h1, h2, h3, h4;
+ uint64_t d0, d1, d2, d3, d4;
u_int i;
r0 = this->r[0];
METHOD(chapoly_drv_t, finish, bool,
private_chapoly_drv_portable_t *this, u_char *mac)
{
- u_int32_t h0, h1, h2, h3, h4;
- u_int32_t g0, g1, g2, g3, g4;
- u_int32_t mask;
- u_int64_t f = 0;
+ uint32_t h0, h1, h2, h3, h4;
+ uint32_t g0, g1, g2, g3, g4;
+ uint32_t mask;
+ uint64_t f = 0;
/* fully carry h */
h0 = this->h[0];
g4 = h4 + (g3 >> 26) - (1 << 26); g3 &= 0x3ffffff;
/* select h if h < p, or h + -p if h >= p */
- mask = (g4 >> ((sizeof(u_int32_t) * 8) - 1)) - 1;
+ mask = (g4 >> ((sizeof(uint32_t) * 8) - 1)) - 1;
g0 &= mask;
g1 &= mask;
g2 &= mask;
/**
* Poly1305 update key
*/
- u_int32_t r[5];
+ uint32_t r[5];
/**
* Poly1305 update key r^2
*/
- u_int32_t u[5];
+ uint32_t u[5];
/**
* Poly1305 state
*/
- u_int32_t h[5];
+ uint32_t h[5];
/**
* Poly1305 finalize key
*/
- u_int32_t s[4];
+ uint32_t s[4];
};
/**
* Read a 32-bit integer from an unaligned address
*/
-static inline u_int32_t ru32(void *p)
+static inline uint32_t ru32(void *p)
{
- u_int32_t ret;
+ uint32_t ret;
memcpy(&ret, p, sizeof(ret));
return ret;
/**
* Write a 32-bit word to an unaligned address
*/
-static inline void wu32(void *p, u_int32_t v)
+static inline void wu32(void *p, uint32_t v)
{
memcpy(p, &v, sizeof(v));
}
/**
* Shift a 64-bit unsigned integer v right by n bits, clamp to 32 bit
*/
-static inline u_int32_t sr(u_int64_t v, u_char n)
+static inline uint32_t sr(uint64_t v, u_char n)
{
return v >> n;
}
/**
- * AND two values, using a native integer size >= sizeof(u_int32_t)
+ * AND two values, using a native integer size >= sizeof(uint32_t)
*/
static inline u_long and(u_long v, u_long mask)
{
{
__m128i x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xa, xb, xc, xd, xe, xf;
__m128i r8, r16, ctrinc, t, *out = data;
- u_int32_t *m = (u_int32_t*)this->m;
+ uint32_t *m = (uint32_t*)this->m;
u_int i;
r8 = _mm_set_epi8(14, 13, 12, 15, 10, 9, 8, 11, 6, 5, 4, 7, 2, 1, 0, 3);
/**
* r[127:64] = h[95:64] * a, r[63:0] = h[31:0] * b
*/
-static inline __m128i mul2(__m128i h, u_int32_t a, u_int32_t b)
+static inline __m128i mul2(__m128i h, uint32_t a, uint32_t b)
{
return _mm_mul_epu32(h, _mm_set_epi32(0, a, 0, b));
}
* z = x[127:64] + x[63:0] + y[127:64] + y[63:0]
*/
static inline void sum2(__m128i a, __m128i b, __m128i x, __m128i y,
- u_int64_t *c, u_int64_t *z)
+ uint64_t *c, uint64_t *z)
{
__m128i r, s;
* r = a[127:64] + b[127:64] + c[127:64] + d[127:64] + e[127:64]
* + a[63:0] + b[63:0] + c[63:0] + d[63:0] + e[63:0]
*/
-static inline u_int64_t sum5(__m128i a, __m128i b, __m128i c,
+static inline uint64_t sum5(__m128i a, __m128i b, __m128i c,
__m128i d, __m128i e)
{
- u_int64_t r;
+ uint64_t r;
a = _mm_add_epi64(a, b);
c = _mm_add_epi64(c, d);
static void make_u(private_chapoly_drv_ssse3_t *this)
{
__m128i r01, r23, r44, x0, x1, y0, y1, z0;
- u_int32_t r0, r1, r2, r3, r4;
- u_int32_t u0, u1, u2, u3, u4;
- u_int32_t s1, s2, s3, s4;
- u_int64_t d0, d1, d2, d3, d4;
+ uint32_t r0, r1, r2, r3, r4;
+ uint32_t u0, u1, u2, u3, u4;
+ uint32_t s1, s2, s3, s4;
+ uint64_t d0, d1, d2, d3, d4;
r0 = this->r[0];
r1 = this->r[1];
*/
static void poly2(private_chapoly_drv_ssse3_t *this, u_char *data, u_int dblks)
{
- u_int32_t r0, r1, r2, r3, r4, u0, u1, u2, u3, u4;
- u_int32_t s1, s2, s3, s4, v1, v2, v3, v4;
+ uint32_t r0, r1, r2, r3, r4, u0, u1, u2, u3, u4;
+ uint32_t s1, s2, s3, s4, v1, v2, v3, v4;
__m128i hc0, hc1, hc2, hc3, hc4;
- u_int32_t h0, h1, h2, h3, h4;
- u_int32_t c0, c1, c2, c3, c4;
- u_int64_t d0, d1, d2, d3, d4;
+ uint32_t h0, h1, h2, h3, h4;
+ uint32_t c0, c1, c2, c3, c4;
+ uint64_t d0, d1, d2, d3, d4;
u_int i;
r0 = this->r[0];
*/
static void poly1(private_chapoly_drv_ssse3_t *this, u_char *data)
{
- u_int32_t r0, r1, r2, r3, r4;
- u_int32_t s1, s2, s3, s4;
- u_int32_t h0, h1, h2, h3, h4;
- u_int64_t d0, d1, d2, d3, d4;
+ uint32_t r0, r1, r2, r3, r4;
+ uint32_t s1, s2, s3, s4;
+ uint32_t h0, h1, h2, h3, h4;
+ uint64_t d0, d1, d2, d3, d4;
__m128i h01, h23, h44;
__m128i x0, x1, y0, y1, z0;
- u_int32_t t0, t1;
+ uint32_t t0, t1;
r0 = this->r[0];
r1 = this->r[1];
METHOD(chapoly_drv_t, finish, bool,
private_chapoly_drv_ssse3_t *this, u_char *mac)
{
- u_int32_t h0, h1, h2, h3, h4;
- u_int32_t g0, g1, g2, g3, g4;
- u_int32_t mask;
- u_int64_t f = 0;
+ uint32_t h0, h1, h2, h3, h4;
+ uint32_t g0, g1, g2, g3, g4;
+ uint32_t mask;
+ uint64_t f = 0;
/* fully carry h */
h0 = this->h[0];
g4 = h4 + (g3 >> 26) - (1 << 26); g3 &= 0x3ffffff;
/* select h if h < p, or h + -p if h >= p */
- mask = (g4 >> ((sizeof(u_int32_t) * 8) - 1)) - 1;
+ mask = (g4 >> ((sizeof(uint32_t) * 8) - 1)) - 1;
g0 &= mask;
g1 &= mask;
g2 &= mask;
/**
* Block size, in bytes
*/
- u_int8_t b;
+ uint8_t b;
/**
* Crypter with key K
/**
* K1
*/
- u_int8_t *k1;
+ uint8_t *k1;
/**
* K2
*/
- u_int8_t *k2;
+ uint8_t *k2;
/**
* T
*/
- u_int8_t *t;
+ uint8_t *t;
/**
* remaining, unprocessed bytes in append mode
*/
- u_int8_t *remaining;
+ uint8_t *remaining;
/**
* number of bytes in remaining
/**
* process last block M_last
*/
-static bool final(private_mac_t *this, u_int8_t *out)
+static bool final(private_mac_t *this, uint8_t *out)
{
chunk_t iv;
}
METHOD(mac_t, get_mac, bool,
- private_mac_t *this, chunk_t data, u_int8_t *out)
+ private_mac_t *this, chunk_t data, uint8_t *out)
{
/* update T, do not process last block */
if (!update(this, data))
{
private_mac_t *this;
crypter_t *crypter;
- u_int8_t b;
+ uint8_t b;
crypter = lib->crypto->create_crypter(lib->crypto, algo, key_size);
if (!crypter)
struct {
char nonce[4];
char iv[8];
- u_int32_t counter;
+ uint32_t counter;
} __attribute__((packed)) state;
};
#define DES_ENCRYPT 1
#define DES_DECRYPT 0
-#define DES_LONG u_int32_t
+#define DES_LONG uint32_t
#if defined(WIN32) || defined(WIN16)
#ifndef MSDOS
private_des_crypter_t *this, chunk_t data, chunk_t iv, chunk_t *decrypted)
{
des_cblock ivb;
- u_int8_t *out;
+ uint8_t *out;
out = data.ptr;
if (decrypted)
private_des_crypter_t *this, chunk_t data, chunk_t iv, chunk_t *encrypted)
{
des_cblock ivb;
- u_int8_t *out;
+ uint8_t *out;
out = data.ptr;
if (encrypted)
METHOD(crypter_t, decrypt_ecb, bool,
private_des_crypter_t *this, chunk_t data, chunk_t iv, chunk_t *decrypted)
{
- u_int8_t *out;
+ uint8_t *out;
out = data.ptr;
if (decrypted)
METHOD(crypter_t, encrypt_ecb, bool,
private_des_crypter_t *this, chunk_t data, chunk_t iv, chunk_t *encrypted)
{
- u_int8_t *out;
+ uint8_t *out;
out = data.ptr;
if (encrypted)
private_des_crypter_t *this, chunk_t data, chunk_t iv, chunk_t *decrypted)
{
des_cblock ivb;
- u_int8_t *out;
+ uint8_t *out;
out = data.ptr;
if (decrypted)
private_des_crypter_t *this, chunk_t data, chunk_t iv, chunk_t *encrypted)
{
des_cblock ivb;
- u_int8_t *out;
+ uint8_t *out;
out = data.ptr;
if (encrypted)
* Header of a DNSKEY resource record
*/
struct dnskey_rr_t {
- u_int16_t flags;
- u_int8_t protocol;
- u_int8_t algorithm;
- u_int8_t data[];
+ uint16_t flags;
+ uint8_t protocol;
+ uint8_t algorithm;
+ uint8_t data[];
} __attribute__((__packed__));
/**
/**
* key of prf function, "b" long
*/
- u_int8_t *key;
+ uint8_t *key;
/**
* size of "b" in bytes
/**
* G function, either SHA1 or DES
*/
- bool (*g)(private_fips_prf_t *this, chunk_t c, u_int8_t res[]);
+ bool (*g)(private_fips_prf_t *this, chunk_t c, uint8_t res[]);
};
/**
* sum = (a + b) mod 2 ^ (length * 8)
*/
-static void add_mod(size_t length, u_int8_t a[], u_int8_t b[], u_int8_t sum[])
+static void add_mod(size_t length, uint8_t a[], uint8_t b[], uint8_t sum[])
{
int i, c = 0;
for(i = length - 1; i >= 0; i--)
{
- u_int32_t tmp;
+ uint32_t tmp;
tmp = a[i] + b[i] + c;
sum[i] = 0xff & tmp;
/**
* calculate "chunk mod 2^(length*8)" and save it into buffer
*/
-static void chunk_mod(size_t length, chunk_t chunk, u_int8_t buffer[])
+static void chunk_mod(size_t length, chunk_t chunk, uint8_t buffer[])
{
if (chunk.len < length)
{
* 0x8e, 0x20, 0xd7, 0x37, 0xa3, 0x27, 0x51, 0x16
*/
METHOD(prf_t, get_bytes, bool,
- private_fips_prf_t *this, chunk_t seed, u_int8_t w[])
+ private_fips_prf_t *this, chunk_t seed, uint8_t w[])
{
int i;
- u_int8_t xval[this->b];
- u_int8_t xseed[this->b];
- u_int8_t sum[this->b];
- u_int8_t *xkey = this->key;
- u_int8_t one[this->b];
+ uint8_t xval[this->b];
+ uint8_t xseed[this->b];
+ uint8_t sum[this->b];
+ uint8_t *xkey = this->key;
+ uint8_t one[this->b];
if (!w)
{
/**
* Implementation of the G() function based on SHA1
*/
-static bool g_sha1(private_fips_prf_t *this, chunk_t c, u_int8_t res[])
+static bool g_sha1(private_fips_prf_t *this, chunk_t c, uint8_t res[])
{
- u_int8_t buf[64];
+ uint8_t buf[64];
if (c.len < sizeof(buf))
{
#if ULONG_MAX == 18446744073709551615UL && defined(htobe64)
# define htobeword htobe64
# define bewordtoh be64toh
-# define SHIFT_WORD_TYPE u_int64_t
+# define SHIFT_WORD_TYPE uint64_t
#else
# define htobeword htonl
# define bewordtoh ntohl
-# define SHIFT_WORD_TYPE u_int32_t
+# define SHIFT_WORD_TYPE uint32_t
#endif
/**
struct {
char nonce[4];
char iv[8];
- u_int32_t counter;
+ uint32_t counter;
} __attribute__((packed)) ctr;
};
}
METHOD(hasher_t, get_hash, bool,
- private_gcrypt_hasher_t *this, chunk_t chunk, u_int8_t *hash)
+ private_gcrypt_hasher_t *this, chunk_t chunk, uint8_t *hash)
{
gcry_md_write(this->hd, chunk.ptr, chunk.len);
if (hash)
};
METHOD(rng_t, get_bytes, bool,
- private_gcrypt_rng_t *this, size_t bytes, u_int8_t *buffer)
+ private_gcrypt_rng_t *this, size_t bytes, uint8_t *buffer)
{
switch (this->quality)
{
static void mpz_clear_sensitive(mpz_t z)
{
size_t len = mpz_size(z) * GMP_LIMB_BITS / BITS_PER_BYTE;
- u_int8_t *zeros = alloca(len);
+ uint8_t *zeros = alloca(len);
memset(zeros, 0, len);
/* overwrite mpz_t with zero bytes before clearing it */
/**
* Block size, as in RFC.
*/
- u_int8_t b;
+ uint8_t b;
/**
* Hash function.
};
METHOD(mac_t, get_mac, bool,
- private_mac_t *this, chunk_t data, u_int8_t *out)
+ private_mac_t *this, chunk_t data, uint8_t *out)
{
/* H(K XOR opad, H(K XOR ipad, text))
*
*
*/
- u_int8_t buffer[this->h->get_hash_size(this->h)];
+ uint8_t buffer[this->h->get_hash_size(this->h)];
chunk_t inner;
if (out == NULL)
private_mac_t *this, chunk_t key)
{
int i;
- u_int8_t buffer[this->b];
+ uint8_t buffer[this->b];
memset(buffer, 0, this->b);
#define S33 11
#define S34 15
-static u_int8_t PADDING[64] = {
+static uint8_t PADDING[64] = {
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
(a) = ROTATE_LEFT ((a), (s)); \
}
#define GG(a, b, c, d, x, s) { \
- (a) += G ((b), (c), (d)) + (x) + (u_int32_t)0x5a827999; \
+ (a) += G ((b), (c), (d)) + (x) + (uint32_t)0x5a827999; \
(a) = ROTATE_LEFT ((a), (s)); \
}
#define HH(a, b, c, d, x, s) { \
- (a) += H ((b), (c), (d)) + (x) + (u_int32_t)0x6ed9eba1; \
+ (a) += H ((b), (c), (d)) + (x) + (uint32_t)0x6ed9eba1; \
(a) = ROTATE_LEFT ((a), (s)); \
}
/*
* State of the hasher.
*/
- u_int32_t state[4];
- u_int32_t count[2];
- u_int8_t buffer[64];
+ uint32_t state[4];
+ uint32_t count[2];
+ uint8_t buffer[64];
};
#if BYTE_ORDER != LITTLE_ENDIAN
-/* Encodes input (u_int32_t) into output (u_int8_t). Assumes len is
+/* Encodes input (uint32_t) into output (uint8_t). Assumes len is
* a multiple of 4.
*/
-static void Encode (u_int8_t *output, u_int32_t *input, size_t len)
+static void Encode (uint8_t *output, uint32_t *input, size_t len)
{
size_t i, j;
for (i = 0, j = 0; j < len; i++, j += 4)
{
- output[j] = (u_int8_t)(input[i] & 0xff);
- output[j+1] = (u_int8_t)((input[i] >> 8) & 0xff);
- output[j+2] = (u_int8_t)((input[i] >> 16) & 0xff);
- output[j+3] = (u_int8_t)((input[i] >> 24) & 0xff);
+ output[j] = (uint8_t)(input[i] & 0xff);
+ output[j+1] = (uint8_t)((input[i] >> 8) & 0xff);
+ output[j+2] = (uint8_t)((input[i] >> 16) & 0xff);
+ output[j+3] = (uint8_t)((input[i] >> 24) & 0xff);
}
}
-/* Decodes input (u_int8_t) into output (u_int32_t). Assumes len is
+/* Decodes input (uint8_t) into output (uint32_t). Assumes len is
* a multiple of 4.
*/
-static void Decode(u_int32_t *output, u_int8_t *input, size_t len)
+static void Decode(uint32_t *output, uint8_t *input, size_t len)
{
size_t i, j;
for (i = 0, j = 0; j < len; i++, j += 4)
{
- output[i] = ((u_int32_t)input[j]) | (((u_int32_t)input[j+1]) << 8) |
- (((u_int32_t)input[j+2]) << 16) | (((u_int32_t)input[j+3]) << 24);
+ output[i] = ((uint32_t)input[j]) | (((uint32_t)input[j+1]) << 8) |
+ (((uint32_t)input[j+2]) << 16) | (((uint32_t)input[j+3]) << 24);
}
}
/*
* MD4 basic transformation. Transforms state based on block.
*/
-static void MD4Transform(u_int32_t state[4], u_int8_t block[64])
+static void MD4Transform(uint32_t state[4], uint8_t block[64])
{
- u_int32_t a = state[0], b = state[1], c = state[2], d = state[3], x[16];
+ uint32_t a = state[0], b = state[1], c = state[2], d = state[3], x[16];
Decode(x, block, 64);
* operation, processing another message block, and updating the
* context.
*/
-static void MD4Update(private_md4_hasher_t *this, u_int8_t *input, size_t inputLen)
+static void MD4Update(private_md4_hasher_t *this, uint8_t *input, size_t inputLen)
{
- u_int32_t i;
+ uint32_t i;
size_t index, partLen;
/* Compute number of bytes mod 64 */
- index = (u_int8_t)((this->count[0] >> 3) & 0x3F);
+ index = (uint8_t)((this->count[0] >> 3) & 0x3F);
/* Update number of bits */
if ((this->count[0] += (inputLen << 3)) < (inputLen << 3))
/* MD4 finalization. Ends an MD4 message-digest operation, writing the
* the message digest and zeroizing the context.
*/
-static void MD4Final (private_md4_hasher_t *this, u_int8_t digest[16])
+static void MD4Final (private_md4_hasher_t *this, uint8_t digest[16])
{
- u_int8_t bits[8];
+ uint8_t bits[8];
size_t index, padLen;
/* Save number of bits */
}
METHOD(hasher_t, get_hash, bool,
- private_md4_hasher_t *this, chunk_t chunk, u_int8_t *buffer)
+ private_md4_hasher_t *this, chunk_t chunk, uint8_t *buffer)
{
MD4Update(this, chunk.ptr, chunk.len);
if (buffer != NULL)
#define S43 15
#define S44 21
-static u_int8_t PADDING[64] = {
+static uint8_t PADDING[64] = {
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
Rotation is separate from addition to prevent recomputation.
*/
#define FF(a, b, c, d, x, s, ac) { \
- (a) += F ((b), (c), (d)) + (x) + (u_int32_t)(ac); \
+ (a) += F ((b), (c), (d)) + (x) + (uint32_t)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
#define GG(a, b, c, d, x, s, ac) { \
- (a) += G ((b), (c), (d)) + (x) + (u_int32_t)(ac); \
+ (a) += G ((b), (c), (d)) + (x) + (uint32_t)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
#define HH(a, b, c, d, x, s, ac) { \
- (a) += H ((b), (c), (d)) + (x) + (u_int32_t)(ac); \
+ (a) += H ((b), (c), (d)) + (x) + (uint32_t)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
#define II(a, b, c, d, x, s, ac) { \
- (a) += I ((b), (c), (d)) + (x) + (u_int32_t)(ac); \
+ (a) += I ((b), (c), (d)) + (x) + (uint32_t)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
/*
* State of the hasher.
*/
- u_int32_t state[5];
- u_int32_t count[2];
- u_int8_t buffer[64];
+ uint32_t state[5];
+ uint32_t count[2];
+ uint8_t buffer[64];
};
#if BYTE_ORDER != LITTLE_ENDIAN
-/* Encodes input (u_int32_t) into output (u_int8_t). Assumes len is
+/* Encodes input (uint32_t) into output (uint8_t). Assumes len is
* a multiple of 4.
*/
-static void Encode (u_int8_t *output, u_int32_t *input, size_t len)
+static void Encode (uint8_t *output, uint32_t *input, size_t len)
{
size_t i, j;
for (i = 0, j = 0; j < len; i++, j += 4)
{
- output[j] = (u_int8_t)(input[i] & 0xff);
- output[j+1] = (u_int8_t)((input[i] >> 8) & 0xff);
- output[j+2] = (u_int8_t)((input[i] >> 16) & 0xff);
- output[j+3] = (u_int8_t)((input[i] >> 24) & 0xff);
+ output[j] = (uint8_t)(input[i] & 0xff);
+ output[j+1] = (uint8_t)((input[i] >> 8) & 0xff);
+ output[j+2] = (uint8_t)((input[i] >> 16) & 0xff);
+ output[j+3] = (uint8_t)((input[i] >> 24) & 0xff);
}
}
-/* Decodes input (u_int8_t) into output (u_int32_t). Assumes len is
+/* Decodes input (uint8_t) into output (uint32_t). Assumes len is
* a multiple of 4.
*/
-static void Decode(u_int32_t *output, u_int8_t *input, size_t len)
+static void Decode(uint32_t *output, uint8_t *input, size_t len)
{
size_t i, j;
for (i = 0, j = 0; j < len; i++, j += 4)
{
- output[i] = ((u_int32_t)input[j]) | (((u_int32_t)input[j+1]) << 8) |
- (((u_int32_t)input[j+2]) << 16) | (((u_int32_t)input[j+3]) << 24);
+ output[i] = ((uint32_t)input[j]) | (((uint32_t)input[j+1]) << 8) |
+ (((uint32_t)input[j+2]) << 16) | (((uint32_t)input[j+3]) << 24);
}
}
/* MD5 basic transformation. Transforms state based on block.
*/
-static void MD5Transform(u_int32_t state[4], u_int8_t block[64])
+static void MD5Transform(uint32_t state[4], uint8_t block[64])
{
- u_int32_t a = state[0], b = state[1], c = state[2], d = state[3], x[16];
+ uint32_t a = state[0], b = state[1], c = state[2], d = state[3], x[16];
Decode(x, block, 64);
* operation, processing another message block, and updating the
* context.
*/
-static void MD5Update(private_md5_hasher_t *this, u_int8_t *input, size_t inputLen)
+static void MD5Update(private_md5_hasher_t *this, uint8_t *input, size_t inputLen)
{
- u_int32_t i;
+ uint32_t i;
size_t index, partLen;
/* Compute number of bytes mod 64 */
- index = (u_int8_t)((this->count[0] >> 3) & 0x3F);
+ index = (uint8_t)((this->count[0] >> 3) & 0x3F);
/* Update number of bits */
if ((this->count[0] += (inputLen << 3)) < (inputLen << 3))
/* MD5 finalization. Ends an MD5 message-digest operation, writing the
* the message digest and zeroizing the context.
*/
-static void MD5Final (private_md5_hasher_t *this, u_int8_t digest[16])
+static void MD5Final (private_md5_hasher_t *this, uint8_t digest[16])
{
- u_int8_t bits[8];
+ uint8_t bits[8];
size_t index, padLen;
/* Save number of bits */
}
METHOD(hasher_t, get_hash, bool,
- private_md5_hasher_t *this, chunk_t chunk, u_int8_t *buffer)
+ private_md5_hasher_t *this, chunk_t chunk, uint8_t *buffer)
{
MD5Update(this, chunk.ptr, chunk.len);
if (buffer != NULL)
};
METHOD(nonce_gen_t, get_nonce, bool,
- private_nonce_nonceg_t *this, size_t size, u_int8_t *buffer)
+ private_nonce_nonceg_t *this, size_t size, uint8_t *buffer)
{
return this->rng->get_bytes(this->rng, size, buffer);
}
/**
* Security strength in bits of the DRBG
*/
- u_int32_t strength;
+ uint32_t strength;
/**
* Number of requests for pseudorandom bits
*/
- u_int32_t reseed_counter;
+ uint32_t reseed_counter;
/**
* Maximum number of requests for pseudorandom bits
*/
- u_int32_t max_requests;
+ uint32_t max_requests;
/**
* True entropy source
return TRUE;
}
-METHOD(ntru_drbg_t, get_strength, u_int32_t,
+METHOD(ntru_drbg_t, get_strength, uint32_t,
private_ntru_drbg_t *this)
{
return this->strength;
}
METHOD(ntru_drbg_t, generate, bool,
- private_ntru_drbg_t *this, u_int32_t strength, u_int32_t len, u_int8_t *out)
+ private_ntru_drbg_t *this, uint32_t strength, uint32_t len, uint8_t *out)
{
size_t delta;
chunk_t output;
/*
* Described in header.
*/
-ntru_drbg_t *ntru_drbg_create(u_int32_t strength, chunk_t pers_str,
+ntru_drbg_t *ntru_drbg_create(uint32_t strength, chunk_t pers_str,
rng_t *entropy)
{
private_ntru_drbg_t *this;
chunk_t seed;
signer_t *hmac;
size_t entropy_len;
- u_int32_t max_requests;
+ uint32_t max_requests;
if (strength > MAX_STRENGTH_BITS)
{
*
* @return configured security strength in bits
*/
- u_int32_t (*get_strength)(ntru_drbg_t *this);
+ uint32_t (*get_strength)(ntru_drbg_t *this);
/**
* Reseed the instantiated DRBG
* @param out address of output buffer
* @return TRUE if successful
*/
- bool (*generate)(ntru_drbg_t *this, u_int32_t strength, u_int32_t len,
- u_int8_t *out);
+ bool (*generate)(ntru_drbg_t *this, uint32_t strength, uint32_t len,
+ uint8_t *out);
/**
* Get a reference on an ntru_drbg_t object increasing the count by one
* @param pers_str personalization string
* @param entropy entropy source to use
*/
-ntru_drbg_t *ntru_drbg_create(u_int32_t strength, chunk_t pers_str,
+ntru_drbg_t *ntru_drbg_create(uint32_t strength, chunk_t pers_str,
rng_t *entropy);
#endif /** NTRU_DRBG_H_ @}*/
/**
* Cryptographical strength in bits of the NTRU Parameter Set
*/
- u_int32_t strength;
+ uint32_t strength;
/**
* NTRU Public Key
rng_t *entropy;
ntru_drbg_t *drbg;
char *parameter_set;
- u_int32_t strength;
+ uint32_t strength;
parameter_set = lib->settings->get_str(lib->settings,
"%s.plugins.ntru.parameter_set", "optimum", lib->ns);
/**
* Look up an OpenSSL algorithm name and validate its key size
*/
-static char* lookup_algorithm(u_int16_t ikev2_algo, size_t *key_size)
+static char* lookup_algorithm(uint16_t ikev2_algo, size_t *key_size)
{
struct {
/* identifier specified in IKEv2 */
}
METHOD(hasher_t, get_hash, bool,
- private_openssl_hasher_t *this, chunk_t chunk, u_int8_t *hash)
+ private_openssl_hasher_t *this, chunk_t chunk, uint8_t *hash)
{
if (EVP_DigestUpdate(this->ctx, chunk.ptr, chunk.len) != 1)
{
}
METHOD(mac_t, get_mac, bool,
- private_mac_t *this, chunk_t data, u_int8_t *out)
+ private_mac_t *this, chunk_t data, uint8_t *out)
{
if (!this->key_set)
{
};
METHOD(rng_t, get_bytes, bool,
- private_openssl_rng_t *this, size_t bytes, u_int8_t *buffer)
+ private_openssl_rng_t *this, size_t bytes, uint8_t *buffer)
{
if (this->quality == RNG_WEAK)
{
};
METHOD(prf_t, get_bytes, bool,
- private_openssl_sha1_prf_t *this, chunk_t seed, u_int8_t *bytes)
+ private_openssl_sha1_prf_t *this, chunk_t seed, uint8_t *bytes)
{
#if OPENSSL_VERSION_NUMBER >= 0x10000000L
if (!SHA1_Update(&this->ctx, seed.ptr, seed.len))
if (bytes)
{
- u_int32_t *hash = (u_int32_t*)bytes;
+ uint32_t *hash = (uint32_t*)bytes;
hash[0] = htonl(this->ctx.h0);
hash[1] = htonl(this->ctx.h1);
}
METHOD(rng_t, get_bytes, bool,
- private_padlock_rng_t *this, size_t bytes, u_int8_t *buffer)
+ private_padlock_rng_t *this, size_t bytes, uint8_t *buffer)
{
chunk_t chunk;
/**
* sha1() a buffer of data into digest
*/
-static void sha1(chunk_t data, u_int32_t *digest)
+static void sha1(chunk_t data, uint32_t *digest)
{
- u_int32_t hash[128] PADLOCK_ALIGN;
+ uint32_t hash[128] PADLOCK_ALIGN;
hash[0] = 0x67452301;
hash[1] = 0xefcdab89;
}
METHOD(hasher_t, get_hash, bool,
- private_padlock_sha1_hasher_t *this, chunk_t chunk, u_int8_t *hash)
+ private_padlock_sha1_hasher_t *this, chunk_t chunk, uint8_t *hash)
{
if (hash)
{
if (this->data.len)
{
append_data(this, chunk);
- sha1(this->data, (u_int32_t*)hash);
+ sha1(this->data, (uint32_t*)hash);
}
else
{ /* hash directly if no previous data found */
- sha1(chunk, (u_int32_t*)hash);
+ sha1(chunk, (uint32_t*)hash);
}
reset(this);
}
chunk_t hash;
chunk_t decrypted;
chunk_t key = {alloca(key_size), key_size};
- u_int8_t padding, *last_padding_pos, *first_padding_pos;
+ uint8_t padding, *last_padding_pos, *first_padding_pos;
/* build key from passphrase and IV */
hasher = lib->crypto->create_hasher(lib->crypto, HASH_MD5);
*/
static public_key_t *parse_public_key(chunk_t blob)
{
- u_int32_t alg;
+ uint32_t alg;
public_key_t *key;
if (!pgp_read_scalar(&blob, 1, &alg))
static private_key_t *parse_rsa_private_key(chunk_t blob)
{
chunk_t mpi[6];
- u_int32_t s2k;
+ uint32_t s2k;
int i;
for (i = 0; i < 2; i++)
{
chunk_t packet;
pgp_packet_tag_t tag;
- u_int32_t version, created, days, alg;
+ uint32_t version, created, days, alg;
private_key_t *key;
if (!pgp_read_packet(&blob, &packet, &tag))
/**
* version of the public key
*/
- u_int32_t version;
+ uint32_t version;
/**
* creation time
*/
- u_int32_t created;
+ uint32_t created;
/**
* days the certificate is valid
*/
- u_int32_t valid;
+ uint32_t valid;
/**
* userid of the certificate
*/
static bool parse_signature(private_pgp_cert_t *this, chunk_t packet)
{
- u_int32_t version, len, type, created;
+ uint32_t version, len, type, created;
if (!pgp_read_scalar(&packet, 1, &version))
{
/**
* Read a PGP scalar of bytes length, advance blob
*/
-bool pgp_read_scalar(chunk_t *blob, size_t bytes, u_int32_t *scalar)
+bool pgp_read_scalar(chunk_t *blob, size_t bytes, uint32_t *scalar)
{
- u_int32_t res = 0;
+ uint32_t res = 0;
if (bytes > blob->len)
{
*/
bool pgp_read_mpi(chunk_t *blob, chunk_t *mpi)
{
- u_int32_t bits, bytes;
+ uint32_t bits, bytes;
if (!pgp_read_scalar(blob, 2, &bits))
{
/**
* Read length of an PGP old packet length encoding
*/
-static bool pgp_old_packet_length(chunk_t *blob, u_int32_t *length)
+static bool pgp_old_packet_length(chunk_t *blob, uint32_t *length)
{
/* bits 0 and 1 define the packet length type */
u_char type;
*/
bool pgp_read_packet(chunk_t *blob, chunk_t *data, pgp_packet_tag_t *tag)
{
- u_int32_t len;
+ uint32_t len;
u_char t;
if (!blob->len)
* @param scalar resultin scalar
* @return TRUE if scalar parsed successfully
*/
-bool pgp_read_scalar(chunk_t *blob, size_t bytes, u_int32_t *scalar);
+bool pgp_read_scalar(chunk_t *blob, size_t bytes, uint32_t *scalar);
/**
* Parse a PGP packet.
}
METHOD(hasher_t, get_hash, bool,
- private_pkcs11_hasher_t *this, chunk_t chunk, u_int8_t *hash)
+ private_pkcs11_hasher_t *this, chunk_t chunk, uint8_t *hash)
{
CK_RV rv;
CK_ULONG len;
};
METHOD(rng_t, get_bytes, bool,
- private_pkcs11_rng_t *this, size_t bytes, u_int8_t *buffer)
+ private_pkcs11_rng_t *this, size_t bytes, uint8_t *buffer)
{
CK_RV rv;
rv = this->lib->f->C_GenerateRandom(this->session, buffer, bytes);
* Verify the given MAC with available passwords.
*/
static bool verify_mac(hash_algorithm_t hash, chunk_t salt,
- u_int64_t iterations, chunk_t data, chunk_t mac)
+ uint64_t iterations, chunk_t data, chunk_t mac)
{
integrity_algorithm_t integ;
enumerator_t *enumerator;
data = chunk_empty;
hash_algorithm_t hash = HASH_UNKNOWN;
container_t *container = NULL;
- u_int64_t iterations = 0;
+ uint64_t iterations = 0;
bool success = FALSE;
parser = asn1_parser_create(PFXObjects, blob);
/**
* See header.
*/
-u_int32_t plugin_feature_hash(plugin_feature_t *feature)
+uint32_t plugin_feature_hash(plugin_feature_t *feature)
{
chunk_t data = chunk_empty;
* @param feature feature to hash
* @return hash value of the feature
*/
-u_int32_t plugin_feature_hash(plugin_feature_t *feature);
+uint32_t plugin_feature_hash(plugin_feature_t *feature);
/**
* Check if feature a matches to feature b.
};
METHOD(rng_t, get_bytes, bool,
- private_random_rng_t *this, size_t bytes, u_int8_t *buffer)
+ private_random_rng_t *this, size_t bytes, uint8_t *buffer)
{
size_t done;
ssize_t got;
#define RC2_BLOCK_SIZE 8
-#define ROL16(x, k) ({ u_int16_t _x = (x); (_x << (k)) | (_x >> (16 - (k))); })
-#define ROR16(x, k) ({ u_int16_t _x = (x); (_x >> (k)) | (_x << (16 - (k))); })
+#define ROL16(x, k) ({ uint16_t _x = (x); (_x << (k)) | (_x >> (16 - (k))); })
+#define ROR16(x, k) ({ uint16_t _x = (x); (_x >> (k)) | (_x << (16 - (k))); })
-#define GET16(x) ({ u_char *_x = (x); (u_int16_t)_x[0] | ((u_int16_t)_x[1] << 8); })
-#define PUT16(x, v) ({ u_char *_x = (x); u_int16_t _v = (v); _x[0] = _v, _x[1] = _v >> 8; })
+#define GET16(x) ({ u_char *_x = (x); (uint16_t)_x[0] | ((uint16_t)_x[1] << 8); })
+#define PUT16(x, v) ({ u_char *_x = (x); uint16_t _v = (v); _x[0] = _v, _x[1] = _v >> 8; })
/**
* Private data of rc2_crypter_t
/**
* The expanded key in 16-bit words
*/
- u_int16_t K[64];
+ uint16_t K[64];
/**
* Key size in bytes
*/
static void encrypt_block(private_rc2_crypter_t *this, u_char R[])
{
- register u_int16_t R0, R1, R2, R3, *Kj;
+ register uint16_t R0, R1, R2, R3, *Kj;
int rounds = 3, mix = 5;
R0 = GET16(R);
*/
static void decrypt_block(private_rc2_crypter_t *this, u_char R[])
{
- register u_int16_t R0, R1, R2, R3, *Kj;
+ register uint16_t R0, R1, R2, R3, *Kj;
int rounds = 3, mix = 5;
R0 = GET16(R);
METHOD(crypter_t, decrypt, bool,
private_rc2_crypter_t *this, chunk_t data, chunk_t iv, chunk_t *decrypted)
{
- u_int8_t *in, *out, *prev;
+ uint8_t *in, *out, *prev;
if (data.len % RC2_BLOCK_SIZE || iv.len != RC2_BLOCK_SIZE)
{
METHOD(crypter_t, encrypt, bool,
private_rc2_crypter_t *this, chunk_t data, chunk_t iv, chunk_t *encrypted)
{
- u_int8_t *in, *out, *end, *prev;
+ uint8_t *in, *out, *end, *prev;
if (data.len % RC2_BLOCK_SIZE || iv.len != RC2_BLOCK_SIZE)
{
METHOD(crypter_t, set_key, bool,
private_rc2_crypter_t *this, chunk_t key)
{
- u_int8_t L[128], T8, TM, idx;
+ uint8_t L[128], T8, TM, idx;
int i;
if (key.len != this->T)
/**
* Get a two byte word using RDRAND
*/
-static bool rdrand16(u_int16_t *out)
+static bool rdrand16(uint16_t *out)
{
u_char res;
int i;
/**
* Get a four byte word using RDRAND
*/
-static bool rdrand32(u_int32_t *out)
+static bool rdrand32(uint32_t *out)
{
u_char res;
int i;
/**
* Get a eight byte word using RDRAND
*/
-static bool rdrand64(u_int64_t *out)
+static bool rdrand64(uint64_t *out)
{
u_char res;
int i;
/**
* Get a one byte word using RDRAND
*/
-static bool rdrand8(u_int8_t *out)
+static bool rdrand8(uint8_t *out)
{
- u_int16_t u16;
+ uint16_t u16;
if (!rdrand16(&u16))
{
{
#ifdef __x86_64__
if (!rdrand64(out) ||
- !rdrand64(out + sizeof(u_int64_t)))
+ !rdrand64(out + sizeof(uint64_t)))
{
return FALSE;
}
#else /* __i386__ */
if (!rdrand32(out) ||
- !rdrand32(out + 1 * sizeof(u_int32_t)) ||
- !rdrand32(out + 2 * sizeof(u_int32_t)) ||
- !rdrand32(out + 3 * sizeof(u_int32_t)))
+ !rdrand32(out + 1 * sizeof(uint32_t)) ||
+ !rdrand32(out + 2 * sizeof(uint32_t)) ||
+ !rdrand32(out + 3 * sizeof(uint32_t)))
{
return FALSE;
}
int i;
#ifdef __x86_64__
- u_int64_t tmp;
+ uint64_t tmp;
- for (i = 0; i < 511 * 16 / sizeof(u_int64_t); i++)
+ for (i = 0; i < 511 * 16 / sizeof(uint64_t); i++)
{
if (!rdrand64(&tmp))
{
}
}
#else /* __i386__ */
- u_int32_t tmp;
+ uint32_t tmp;
- for (i = 0; i < 511 * 16 / sizeof(u_int32_t); i++)
+ for (i = 0; i < 511 * 16 / sizeof(uint32_t); i++)
{
if (!rdrand32(&tmp))
{
}
/* align to 2 byte */
- if (chunk.len >= sizeof(u_int8_t))
+ if (chunk.len >= sizeof(uint8_t))
{
if ((uintptr_t)chunk.ptr % 2)
{
- if (!rdrand8((u_int8_t*)chunk.ptr))
+ if (!rdrand8((uint8_t*)chunk.ptr))
{
return FALSE;
}
- chunk = chunk_skip(chunk, sizeof(u_int8_t));
+ chunk = chunk_skip(chunk, sizeof(uint8_t));
}
}
/* align to 4 byte */
- if (chunk.len >= sizeof(u_int16_t))
+ if (chunk.len >= sizeof(uint16_t))
{
if ((uintptr_t)chunk.ptr % 4)
{
- if (!rdrand16((u_int16_t*)chunk.ptr))
+ if (!rdrand16((uint16_t*)chunk.ptr))
{
return FALSE;
}
- chunk = chunk_skip(chunk, sizeof(u_int16_t));
+ chunk = chunk_skip(chunk, sizeof(uint16_t));
}
}
#ifdef __x86_64__
/* align to 8 byte */
- if (chunk.len >= sizeof(u_int32_t))
+ if (chunk.len >= sizeof(uint32_t))
{
if ((uintptr_t)chunk.ptr % 8)
{
- if (!rdrand32((u_int32_t*)chunk.ptr))
+ if (!rdrand32((uint32_t*)chunk.ptr))
{
return FALSE;
}
- chunk = chunk_skip(chunk, sizeof(u_int32_t));
+ chunk = chunk_skip(chunk, sizeof(uint32_t));
}
}
/* fill with 8 byte words */
- while (chunk.len >= sizeof(u_int64_t))
+ while (chunk.len >= sizeof(uint64_t))
{
if (this->quality == RNG_STRONG && chunk.len % FORCE_RESEED == 0)
{
return FALSE;
}
}
- if (!rdrand64((u_int64_t*)chunk.ptr))
+ if (!rdrand64((uint64_t*)chunk.ptr))
{
return FALSE;
}
- chunk = chunk_skip(chunk, sizeof(u_int64_t));
+ chunk = chunk_skip(chunk, sizeof(uint64_t));
}
/* append 4 byte word */
- if (chunk.len >= sizeof(u_int32_t))
+ if (chunk.len >= sizeof(uint32_t))
{
- if (!rdrand32((u_int32_t*)chunk.ptr))
+ if (!rdrand32((uint32_t*)chunk.ptr))
{
return FALSE;
}
- chunk = chunk_skip(chunk, sizeof(u_int32_t));
+ chunk = chunk_skip(chunk, sizeof(uint32_t));
}
#else /* __i386__ */
/* fill with 4 byte words */
- while (chunk.len >= sizeof(u_int32_t))
+ while (chunk.len >= sizeof(uint32_t))
{
if (this->quality == RNG_STRONG && chunk.len % FORCE_RESEED == 0)
{
return FALSE;
}
}
- if (!rdrand32((u_int32_t*)chunk.ptr))
+ if (!rdrand32((uint32_t*)chunk.ptr))
{
return FALSE;
}
- chunk = chunk_skip(chunk, sizeof(u_int32_t));
+ chunk = chunk_skip(chunk, sizeof(uint32_t));
}
#endif /* __x86_64__ / __i386__ */
}
/* append 2 byte word */
- if (chunk.len >= sizeof(u_int16_t))
+ if (chunk.len >= sizeof(uint16_t))
{
- if (!rdrand16((u_int16_t*)chunk.ptr))
+ if (!rdrand16((uint16_t*)chunk.ptr))
{
return FALSE;
}
- chunk = chunk_skip(chunk, sizeof(u_int16_t));
+ chunk = chunk_skip(chunk, sizeof(uint16_t));
}
/* append 1 byte word */
- if (chunk.len >= sizeof(u_int8_t))
+ if (chunk.len >= sizeof(uint8_t))
{
- if (!rdrand8((u_int8_t*)chunk.ptr))
+ if (!rdrand8((uint8_t*)chunk.ptr))
{
return FALSE;
}
- chunk = chunk_skip(chunk, sizeof(u_int8_t));
+ chunk = chunk_skip(chunk, sizeof(uint8_t));
}
return TRUE;
}
METHOD(rng_t, get_bytes, bool,
- private_rdrand_rng_t *this, size_t bytes, u_int8_t *buffer)
+ private_rdrand_rng_t *this, size_t bytes, uint8_t *buffer)
{
switch (this->quality)
{
/*
* State of the hasher. Shared with sha1_prf.c, do not change it!!!
*/
- u_int32_t state[5];
- u_int32_t count[2];
- u_int8_t buffer[64];
+ uint32_t state[5];
+ uint32_t count[2];
+ uint8_t buffer[64];
};
/*
* Hash a single 512-bit block. This is the core of the algorithm. *
*/
-static void SHA1Transform(u_int32_t state[5], const unsigned char buffer[64])
+static void SHA1Transform(uint32_t state[5], const unsigned char buffer[64])
{
- u_int32_t a, b, c, d, e;
+ uint32_t a, b, c, d, e;
typedef union {
- u_int8_t c[64];
- u_int32_t l[16];
+ uint8_t c[64];
+ uint32_t l[16];
} CHAR64LONG16;
CHAR64LONG16 block[1]; /* use array to appear as a pointer */
memcpy(block, buffer, 64);
/**
* Run your data through this. Also used in sha1_prf.
*/
-void SHA1Update(private_sha1_hasher_t* this, u_int8_t *data, u_int32_t len)
+void SHA1Update(private_sha1_hasher_t* this, uint8_t *data, uint32_t len)
{
- u_int32_t i;
- u_int32_t j;
+ uint32_t i;
+ uint32_t j;
j = this->count[0];
if ((this->count[0] += len << 3) < j)
/*
* Add padding and return the message digest.
*/
-static void SHA1Final(private_sha1_hasher_t *this, u_int8_t *digest)
+static void SHA1Final(private_sha1_hasher_t *this, uint8_t *digest)
{
- u_int32_t i;
- u_int8_t finalcount[8];
- u_int8_t c;
+ uint32_t i;
+ uint8_t finalcount[8];
+ uint8_t c;
for (i = 0; i < 8; i++)
{
- finalcount[i] = (u_int8_t)((this->count[(i >= 4 ? 0 : 1)]
+ finalcount[i] = (uint8_t)((this->count[(i >= 4 ? 0 : 1)]
>> ((3-(i & 3)) * 8) ) & 255); /* Endian independent */
}
c = 0200;
SHA1Update(this, finalcount, 8); /* Should cause a SHA1Transform() */
for (i = 0; i < 20; i++)
{
- digest[i] = (u_int8_t)((this->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255);
+ digest[i] = (uint8_t)((this->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255);
}
}
}
METHOD(hasher_t, get_hash, bool,
- private_sha1_hasher_t *this, chunk_t chunk, u_int8_t *buffer)
+ private_sha1_hasher_t *this, chunk_t chunk, uint8_t *buffer)
{
SHA1Update(this, chunk.ptr, chunk.len);
if (buffer != NULL)
/*
* State of the hasher. From sha1_hasher.c, do not change it!
*/
- u_int32_t state[5];
- u_int32_t count[2];
- u_int8_t buffer[64];
+ uint32_t state[5];
+ uint32_t count[2];
+ uint8_t buffer[64];
};
/**
/**
* From sha1_hasher.c
*/
-extern void SHA1Update(private_sha1_hasher_t* this, u_int8_t *data, u_int32_t len);
+extern void SHA1Update(private_sha1_hasher_t* this, uint8_t *data, uint32_t len);
METHOD(prf_t, get_bytes, bool,
- private_sha1_prf_t *this, chunk_t seed, u_int8_t *bytes)
+ private_sha1_prf_t *this, chunk_t seed, uint8_t *bytes)
{
- u_int32_t *hash = (u_int32_t*)bytes;
+ uint32_t *hash = (uint32_t*)bytes;
SHA1Update(this->hasher, seed.ptr, seed.len);
private_sha1_prf_t *this, chunk_t key)
{
int i, rounds;
- u_int32_t *iv = (u_int32_t*)key.ptr;
+ uint32_t *iv = (uint32_t*)key.ptr;
if (!this->hasher->public.hasher_interface.reset(
&this->hasher->public.hasher_interface))
{
return FALSE;
}
- rounds = min(key.len/sizeof(u_int32_t), sizeof(this->hasher->state));
+ rounds = min(key.len/sizeof(uint32_t), sizeof(this->hasher->state));
for (i = 0; i < rounds; i++)
{
this->hasher->state[i] ^= htonl(iv[i]);
sha2_hasher_t public;
unsigned char sha_out[128]; /* results are here, bytes 0..47/0..63 */
- u_int64_t sha_H[8];
- u_int64_t sha_blocks;
- u_int64_t sha_blocksMSB;
+ uint64_t sha_H[8];
+ uint64_t sha_blocks;
+ uint64_t sha_blocksMSB;
int sha_bufCnt;
};
sha2_hasher_t public;
unsigned char sha_out[64]; /* results are here, bytes 0...31 */
- u_int32_t sha_H[8];
- u_int64_t sha_blocks;
+ uint32_t sha_H[8];
+ uint64_t sha_blocks;
int sha_bufCnt;
};
-static const u_int32_t sha224_hashInit[8] = {
+static const uint32_t sha224_hashInit[8] = {
0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511,
0x64f98fa7, 0xbefa4fa4
};
-static const u_int32_t sha256_hashInit[8] = {
+static const uint32_t sha256_hashInit[8] = {
0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c,
0x1f83d9ab, 0x5be0cd19
};
-static const u_int32_t sha256_K[64] = {
+static const uint32_t sha256_K[64] = {
0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1,
0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786,
0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
};
-static const u_int64_t sha512_hashInit[8] = {
+static const uint64_t sha512_hashInit[8] = {
0x6a09e667f3bcc908ULL, 0xbb67ae8584caa73bULL, 0x3c6ef372fe94f82bULL,
0xa54ff53a5f1d36f1ULL, 0x510e527fade682d1ULL, 0x9b05688c2b3e6c1fULL,
0x1f83d9abfb41bd6bULL, 0x5be0cd19137e2179ULL
};
-static const u_int64_t sha384_hashInit[8] = {
+static const uint64_t sha384_hashInit[8] = {
0xcbbb9d5dc1059ed8ULL, 0x629a292a367cd507ULL, 0x9159015a3070dd17ULL,
0x152fecd8f70e5939ULL, 0x67332667ffc00b31ULL, 0x8eb44a8768581511ULL,
0xdb0c2e0d64f98fa7ULL, 0x47b5481dbefa4fa4ULL
};
-static const u_int64_t sha512_K[80] = {
+static const uint64_t sha512_K[80] = {
0x428a2f98d728ae22ULL, 0x7137449123ef65cdULL, 0xb5c0fbcfec4d3b2fULL,
0xe9b5dba58189dbbcULL, 0x3956c25bf348b538ULL, 0x59f111f1b605d019ULL,
0x923f82a4af194f9bULL, 0xab1c5ed5da6d8118ULL, 0xd807aa98a3030242ULL,
const unsigned char *datap)
{
register int j;
- u_int32_t a, b, c, d, e, f, g, h;
- u_int32_t T1, T2, W[64], Wm2, Wm15;
+ uint32_t a, b, c, d, e, f, g, h;
+ uint32_t T1, T2, W[64], Wm2, Wm15;
/* read the data, big endian byte order */
j = 0;
do {
- W[j] = (((u_int32_t)(datap[0]))<<24) | (((u_int32_t)(datap[1]))<<16) |
- (((u_int32_t)(datap[2]))<<8 ) | ((u_int32_t)(datap[3]));
+ W[j] = (((uint32_t)(datap[0]))<<24) | (((uint32_t)(datap[1]))<<16) |
+ (((uint32_t)(datap[2]))<<8 ) | ((uint32_t)(datap[3]));
datap += 4;
} while(++j < 16);
static void sha256_final(private_sha256_hasher_t *ctx)
{
register int j;
- u_int64_t bitLength;
- u_int32_t i;
+ uint64_t bitLength;
+ uint32_t i;
unsigned char padByte, *datap;
bitLength = (ctx->sha_blocks << 9) | (ctx->sha_bufCnt << 3);
const unsigned char *datap)
{
register int j;
- u_int64_t a, b, c, d, e, f, g, h;
- u_int64_t T1, T2, W[80], Wm2, Wm15;
+ uint64_t a, b, c, d, e, f, g, h;
+ uint64_t T1, T2, W[80], Wm2, Wm15;
/* read the data, big endian byte order */
j = 0;
do {
- W[j] = (((u_int64_t)(datap[0]))<<56) | (((u_int64_t)(datap[1]))<<48) |
- (((u_int64_t)(datap[2]))<<40) | (((u_int64_t)(datap[3]))<<32) |
- (((u_int64_t)(datap[4]))<<24) | (((u_int64_t)(datap[5]))<<16) |
- (((u_int64_t)(datap[6]))<<8 ) | ((u_int64_t)(datap[7]));
+ W[j] = (((uint64_t)(datap[0]))<<56) | (((uint64_t)(datap[1]))<<48) |
+ (((uint64_t)(datap[2]))<<40) | (((uint64_t)(datap[3]))<<32) |
+ (((uint64_t)(datap[4]))<<24) | (((uint64_t)(datap[5]))<<16) |
+ (((uint64_t)(datap[6]))<<8 ) | ((uint64_t)(datap[7]));
datap += 8;
} while(++j < 16);
static void sha512_final(private_sha512_hasher_t *ctx)
{
register int j;
- u_int64_t bitLength, bitLengthMSB;
- u_int64_t i;
+ uint64_t bitLength, bitLengthMSB;
+ uint64_t i;
unsigned char padByte, *datap;
bitLength = (ctx->sha_blocks << 10) | (ctx->sha_bufCnt << 3);
}
METHOD(hasher_t, get_hash224, bool,
- private_sha256_hasher_t *this, chunk_t chunk, u_int8_t *buffer)
+ private_sha256_hasher_t *this, chunk_t chunk, uint8_t *buffer)
{
sha256_write(this, chunk.ptr, chunk.len);
if (buffer != NULL)
}
METHOD(hasher_t, get_hash256, bool,
- private_sha256_hasher_t *this, chunk_t chunk, u_int8_t *buffer)
+ private_sha256_hasher_t *this, chunk_t chunk, uint8_t *buffer)
{
sha256_write(this, chunk.ptr, chunk.len);
if (buffer != NULL)
}
METHOD(hasher_t, get_hash384, bool,
- private_sha512_hasher_t *this, chunk_t chunk, u_int8_t *buffer)
+ private_sha512_hasher_t *this, chunk_t chunk, uint8_t *buffer)
{
sha512_write(this, chunk.ptr, chunk.len);
if (buffer != NULL)
}
METHOD(hasher_t, get_hash512, bool,
- private_sha512_hasher_t *this, chunk_t chunk, u_int8_t *buffer)
+ private_sha512_hasher_t *this, chunk_t chunk, uint8_t *buffer)
{
sha512_write(this, chunk.ptr, chunk.len);
if (buffer != NULL)
{
DWORD received;
char buf[1024];
- u_int32_t code;
+ uint32_t code;
DWORD codelen = sizeof(code);
if (!WinHttpReceiveResponse(request, NULL))
/**
* Block size, in bytes
*/
- u_int8_t b;
+ uint8_t b;
/**
* crypter using k1
/**
* k2
*/
- u_int8_t *k2;
+ uint8_t *k2;
/**
* k3
*/
- u_int8_t *k3;
+ uint8_t *k3;
/**
* E
*/
- u_int8_t *e;
+ uint8_t *e;
/**
* remaining, unprocessed bytes in append mode
*/
- u_int8_t *remaining;
+ uint8_t *remaining;
/**
* number of bytes in remaining
/**
* run last round, data is in this->e
*/
-static bool final(private_mac_t *this, u_int8_t *out)
+static bool final(private_mac_t *this, uint8_t *out)
{
chunk_t iv;
}
METHOD(mac_t, get_mac, bool,
- private_mac_t *this, chunk_t data, u_int8_t *out)
+ private_mac_t *this, chunk_t data, uint8_t *out)
{
/* update E, do not process last block */
if (!update(this, data))
{
private_mac_t *this;
crypter_t *crypter;
- u_int8_t b;
+ uint8_t b;
crypter = lib->crypto->create_crypter(lib->crypto, algo, key_size);
if (!crypter)
} schedule;
/** Time to reschedule the job */
union {
- u_int32_t rel;
+ uint32_t rel;
timeval_t abs;
} time;
};
}
METHOD(scheduler_t, schedule_job, void,
- private_scheduler_t *this, job_t *job, u_int32_t s)
+ private_scheduler_t *this, job_t *job, uint32_t s)
{
timeval_t tv;
}
METHOD(scheduler_t, schedule_job_ms, void,
- private_scheduler_t *this, job_t *job, u_int32_t ms)
+ private_scheduler_t *this, job_t *job, uint32_t ms)
{
timeval_t tv, add;
* @param job job to schedule
* @param time relative time to schedule job, in s
*/
- void (*schedule_job) (scheduler_t *this, job_t *job, u_int32_t s);
+ void (*schedule_job) (scheduler_t *this, job_t *job, uint32_t s);
/**
* Adds a event to the queue, using a relative time offset in ms.
* @param job job to schedule
* @param time relative time to schedule job, in ms
*/
- void (*schedule_job_ms) (scheduler_t *this, job_t *job, u_int32_t ms);
+ void (*schedule_job_ms) (scheduler_t *this, job_t *job, uint32_t ms);
/**
* Adds a event to the queue, using an absolut time.
/**
* IP protocol (UDP, TCP, ICMP, ...)
*/
- u_int8_t protocol;
+ uint8_t protocol;
/**
* narrow this traffic selector to hosts external ip
/**
* subnet size in CIDR notation, 255 means a non-subnet address range
*/
- u_int8_t netbits;
+ uint8_t netbits;
/**
* begin of address range, network order
/** dummy char for common address manipulation */
char from[0];
/** IPv4 address */
- u_int32_t from4[1];
+ uint32_t from4[1];
/** IPv6 address */
- u_int32_t from6[4];
+ uint32_t from6[4];
};
/**
/** dummy char for common address manipulation */
char to[0];
/** IPv4 address */
- u_int32_t to4[1];
+ uint32_t to4[1];
/** IPv6 address */
- u_int32_t to6[4];
+ uint32_t to6[4];
};
/**
* begin of port range
*/
- u_int16_t from_port;
+ uint16_t from_port;
/**
* end of port range
*/
- u_int16_t to_port;
+ uint16_t to_port;
};
/**
* calculate the "to"-address for the "from" address and a subnet size
*/
-static void calc_range(private_traffic_selector_t *this, u_int8_t netbits)
+static void calc_range(private_traffic_selector_t *this, uint8_t netbits)
{
size_t len;
int bytes, bits;
- u_int8_t mask;
+ uint8_t mask;
this->netbits = netbits;
/**
* calculate the subnet size from the "to" and "from" addresses
*/
-static u_int8_t calc_netbits(private_traffic_selector_t *this)
+static uint8_t calc_netbits(private_traffic_selector_t *this)
{
int byte, bit;
- u_int8_t netbits;
+ uint8_t netbits;
size_t size = (this->type == TS_IPV4_ADDR_RANGE) ? 4 : 16;
bool prefix = TRUE;
{
for (bit = 7; bit >= 0; bit--)
{
- u_int8_t bitmask = 1 << bit;
+ uint8_t bitmask = 1 << bit;
if (prefix)
{
/**
* internal generic constructor
*/
-static private_traffic_selector_t *traffic_selector_create(u_int8_t protocol,
- ts_type_t type, u_int16_t from_port, u_int16_t to_port);
+static private_traffic_selector_t *traffic_selector_create(uint8_t protocol,
+ ts_type_t type, uint16_t from_port, uint16_t to_port);
/**
* Check if TS contains "opaque" ports
/**
* Print ICMP/ICMPv6 type and code
*/
-static int print_icmp(printf_hook_data_t *data, u_int16_t port)
+static int print_icmp(printf_hook_data_t *data, uint16_t port)
{
- u_int8_t type, code;
+ uint8_t type, code;
type = traffic_selector_icmp_type(port);
code = traffic_selector_icmp_code(port);
char *serv_proto = NULL, *sep = "";
bool has_proto, has_ports;
size_t written = 0;
- u_int32_t from[4], to[4];
+ uint32_t from[4], to[4];
if (this == NULL)
{
private_traffic_selector_t *this, traffic_selector_t *other_public)
{
private_traffic_selector_t *other, *subset;
- u_int16_t from_port, to_port;
+ uint16_t from_port, to_port;
u_char *from, *to;
- u_int8_t protocol;
+ uint8_t protocol;
size_t size;
other = (private_traffic_selector_t*)other_public;
}
}
-METHOD(traffic_selector_t, get_from_port, u_int16_t,
+METHOD(traffic_selector_t, get_from_port, uint16_t,
private_traffic_selector_t *this)
{
return this->from_port;
}
-METHOD(traffic_selector_t, get_to_port, u_int16_t,
+METHOD(traffic_selector_t, get_to_port, uint16_t,
private_traffic_selector_t *this)
{
return this->to_port;
return this->type;
}
-METHOD(traffic_selector_t, get_protocol, u_int8_t,
+METHOD(traffic_selector_t, get_protocol, uint8_t,
private_traffic_selector_t *this)
{
return this->protocol;
}
METHOD(traffic_selector_t, to_subnet, bool,
- private_traffic_selector_t *this, host_t **net, u_int8_t *mask)
+ private_traffic_selector_t *this, host_t **net, uint8_t *mask)
{
/* there is no way to do this cleanly, as the address range may
* be anything else but a subnet. We use from_addr as subnet
* and try to calculate a usable subnet mask.
*/
int family, non_zero_bytes;
- u_int16_t port = 0;
+ uint16_t port = 0;
chunk_t net_chunk;
*mask = (this->netbits == NON_SUBNET_ADDRESS_RANGE) ? calc_netbits(this)
/*
* see header
*/
-traffic_selector_t *traffic_selector_create_from_bytes(u_int8_t protocol,
+traffic_selector_t *traffic_selector_create_from_bytes(uint8_t protocol,
ts_type_t type,
- chunk_t from, u_int16_t from_port,
- chunk_t to, u_int16_t to_port)
+ chunk_t from, uint16_t from_port,
+ chunk_t to, uint16_t to_port)
{
private_traffic_selector_t *this = traffic_selector_create(protocol, type,
from_port, to_port);
}
if (to.len > 1)
{
- u_int8_t mask = to.ptr[0] ? (1 << to.ptr[0]) - 1 : 0;
+ uint8_t mask = to.ptr[0] ? (1 << to.ptr[0]) - 1 : 0;
memcpy(this->to, to.ptr+1, to.len-1);
this->to[to.len-2] |= mask;
* see header
*/
traffic_selector_t *traffic_selector_create_from_subnet(host_t *net,
- u_int8_t netbits, u_int8_t protocol,
- u_int16_t from_port, u_int16_t to_port)
+ uint8_t netbits, uint8_t protocol,
+ uint16_t from_port, uint16_t to_port)
{
private_traffic_selector_t *this;
chunk_t from;
* see header
*/
traffic_selector_t *traffic_selector_create_from_string(
- u_int8_t protocol, ts_type_t type,
- char *from_addr, u_int16_t from_port,
- char *to_addr, u_int16_t to_port)
+ uint8_t protocol, ts_type_t type,
+ char *from_addr, uint16_t from_port,
+ char *to_addr, uint16_t to_port)
{
private_traffic_selector_t *this;
int family;
* see header
*/
traffic_selector_t *traffic_selector_create_from_cidr(
- char *string, u_int8_t protocol,
- u_int16_t from_port, u_int16_t to_port)
+ char *string, uint8_t protocol,
+ uint16_t from_port, uint16_t to_port)
{
host_t *net;
int bits;
/*
* see header
*/
-traffic_selector_t *traffic_selector_create_dynamic(u_int8_t protocol,
- u_int16_t from_port, u_int16_t to_port)
+traffic_selector_t *traffic_selector_create_dynamic(uint8_t protocol,
+ uint16_t from_port, uint16_t to_port)
{
private_traffic_selector_t *this = traffic_selector_create(
protocol, TS_IPV4_ADDR_RANGE, from_port, to_port);
/*
* see declaration
*/
-static private_traffic_selector_t *traffic_selector_create(u_int8_t protocol,
- ts_type_t type, u_int16_t from_port, u_int16_t to_port)
+static private_traffic_selector_t *traffic_selector_create(uint8_t protocol,
+ ts_type_t type, uint16_t from_port, uint16_t to_port)
{
private_traffic_selector_t *this;
*
* @return port
*/
- u_int16_t (*get_from_port) (traffic_selector_t *this);
+ uint16_t (*get_from_port) (traffic_selector_t *this);
/**
* Get ending port of this ts.
*
* @return port
*/
- u_int16_t (*get_to_port) (traffic_selector_t *this);
+ uint16_t (*get_to_port) (traffic_selector_t *this);
/**
* Get the type of the traffic selector.
*
* @return protocol id
*/
- u_int8_t (*get_protocol) (traffic_selector_t *this);
+ uint8_t (*get_protocol) (traffic_selector_t *this);
/**
* Check if the traffic selector is for a single host.
* @param mask converted net mask
* @return TRUE if traffic selector matches exactly to the subnet
*/
- bool (*to_subnet) (traffic_selector_t *this, host_t **net, u_int8_t *mask);
+ bool (*to_subnet) (traffic_selector_t *this, host_t **net, uint8_t *mask);
/**
* Create a hash value for the traffic selector.
* @param port port number in host order
* @return ICMP/ICMPv6 message type
*/
-static inline u_int8_t traffic_selector_icmp_type(u_int16_t port)
+static inline uint8_t traffic_selector_icmp_type(uint16_t port)
{
return port >> 8;
}
* @param port port number in host order
* @return ICMP/ICMPv6 message code
*/
-static inline u_int8_t traffic_selector_icmp_code(u_int16_t port)
+static inline uint8_t traffic_selector_icmp_code(uint16_t port)
{
return port & 0xff;
}
* - NULL if invalid address strings/protocol
*/
traffic_selector_t *traffic_selector_create_from_string(
- u_int8_t protocol, ts_type_t type,
- char *from_addr, u_int16_t from_port,
- char *to_addr, u_int16_t to_port);
+ uint8_t protocol, ts_type_t type,
+ char *from_addr, uint16_t from_port,
+ char *to_addr, uint16_t to_port);
* @return traffic selector, NULL if string invalid
*/
traffic_selector_t *traffic_selector_create_from_cidr(
- char *string, u_int8_t protocol,
- u_int16_t from_port, u_int16_t to_port);
+ char *string, uint8_t protocol,
+ uint16_t from_port, uint16_t to_port);
/**
* Create a new traffic selector using data read from the net.
* @return traffic_selector_t object
*/
traffic_selector_t *traffic_selector_create_from_bytes(
- u_int8_t protocol, ts_type_t type,
- chunk_t from_address, u_int16_t from_port,
- chunk_t to_address, u_int16_t to_port);
+ uint8_t protocol, ts_type_t type,
+ chunk_t from_address, uint16_t from_port,
+ chunk_t to_address, uint16_t to_port);
/**
* Create a new traffic selector using the RFC 3779 ASN.1 min/max address format
* - NULL if address family of net not supported
*/
traffic_selector_t *traffic_selector_create_from_subnet(
- host_t *net, u_int8_t netbits, u_int8_t protocol,
- u_int16_t from_port, u_int16_t to_port);
+ host_t *net, uint8_t netbits, uint8_t protocol,
+ uint16_t from_port, uint16_t to_port);
/**
* Create a traffic selector for host-to-host cases.
* - traffic_selector_t object
* - NULL if type not supported
*/
-traffic_selector_t *traffic_selector_create_dynamic(u_int8_t protocol,
- u_int16_t from_port, u_int16_t to_port);
+traffic_selector_t *traffic_selector_create_dynamic(uint8_t protocol,
+ uint16_t from_port, uint16_t to_port);
/**
* printf hook function for traffic_selector_t.
/**
* Described in header
*/
-inline u_int64_t settings_value_as_uint64(char *value, u_int64_t def)
+inline uint64_t settings_value_as_uint64(char *value, uint64_t def)
{
- u_int64_t intval;
+ uint64_t intval;
char *end;
int base = 10;
/**
* Described in header
*/
-inline u_int32_t settings_value_as_time(char *value, u_int32_t def)
+inline uint32_t settings_value_as_time(char *value, uint32_t def)
{
char *endptr;
- u_int32_t timeval;
+ uint32_t timeval;
if (value)
{
errno = 0;
return def;
}
-METHOD(settings_t, get_time, u_int32_t,
- private_settings_t *this, char *key, u_int32_t def, ...)
+METHOD(settings_t, get_time, uint32_t,
+ private_settings_t *this, char *key, uint32_t def, ...)
{
char *value;
va_list args;
}
METHOD(settings_t, set_time, void,
- private_settings_t *this, char *key, u_int32_t value, ...)
+ private_settings_t *this, char *key, uint32_t value, ...)
{
char val[16];
va_list args;
int settings_value_as_int(char *value, int def);
/**
- * Convert a string value returned by a key/value enumerator to an u_int64_t.
+ * Convert a string value returned by a key/value enumerator to an uint64_t.
*
* @see settings_t.create_key_value_enumerator()
* @param value the string value
* @param def the default value, if value is NULL or invalid
*/
-u_int64_t settings_value_as_uint64(char *value, u_int64_t def);
+uint64_t settings_value_as_uint64(char *value, uint64_t def);
/**
* Convert a string value returned by a key/value enumerator to a double.
* @param value the string value
* @param def the default value, if value is NULL or invalid
*/
-u_int32_t settings_value_as_time(char *value, u_int32_t def);
+uint32_t settings_value_as_time(char *value, uint32_t def);
/**
* Generic configuration options read from a config file.
* @param ... argument list for key
* @return value of the key (in seconds)
*/
- u_int32_t (*get_time)(settings_t *this, char *key, u_int32_t def, ...);
+ uint32_t (*get_time)(settings_t *this, char *key, uint32_t def, ...);
/**
* Set a string value.
* @param def value to set
* @param ... argument list for key
*/
- void (*set_time)(settings_t *this, char *key, u_int32_t value, ...);
+ void (*set_time)(settings_t *this, char *key, uint32_t value, ...);
/**
* Set a default for string value.
START_TEST(test_insert_create_value)
{
array_t *array = NULL;
- u_int16_t v;
+ uint16_t v;
v = 1;
array_insert_create_value(&array, sizeof(v), ARRAY_TAIL, &v);
{
typedef struct {
time_t time;
- u_int8_t type;
+ uint8_t type;
char *string;
} testdata_t;
{
typedef struct {
time_t time;
- u_int8_t type;
+ uint8_t type;
chunk_t chunk;
} testdata_t;
START_TEST(test_asn1_parse_integer_uint64)
{
typedef struct {
- u_int64_t n;
+ uint64_t n;
chunk_t chunk;
} testdata_t;
START_TEST(test_read_uint8)
{
chunk_t data = chunk_from_chars(0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07);
- u_int8_t val;
+ uint8_t val;
assert_integer_read(data, 8, val);
assert_basic_read(8, val);
START_TEST(test_read_uint16)
{
chunk_t data = chunk_from_chars(0x00, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x03);
- u_int16_t val;
+ uint16_t val;
assert_integer_read(data, 16, val);
assert_basic_read(16, val);
START_TEST(test_read_uint24)
{
chunk_t data = chunk_from_chars(0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x03);
- u_int32_t val;
+ uint32_t val;
assert_integer_read(data, 24, val);
assert_basic_read(24, val);
{
chunk_t data = chunk_from_chars(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03);
- u_int32_t val;
+ uint32_t val;
assert_integer_read(data, 32, val);
assert_basic_read(32, val);
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03);
- u_int64_t val;
+ uint64_t val;
assert_integer_read(data, 64, val);
assert_basic_read(64, val);
START_TEST(test_read_uint8_end)
{
chunk_t data = chunk_from_chars(0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00);
- u_int8_t val;
+ uint8_t val;
assert_integer_read_end(data, 8, val);
assert_basic_read_end(8, val);
START_TEST(test_read_uint16_end)
{
chunk_t data = chunk_from_chars(0x00, 0x03, 0x00, 0x02, 0x00, 0x01, 0x00, 0x00);
- u_int16_t val;
+ uint16_t val;
assert_integer_read_end(data, 16, val);
assert_basic_read_end(16, val);
START_TEST(test_read_uint24_end)
{
chunk_t data = chunk_from_chars(0x00, 0x00, 0x03, 0x00, 0x00, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00);
- u_int32_t val;
+ uint32_t val;
assert_integer_read_end(data, 24, val);
assert_basic_read_end(24, val);
{
chunk_t data = chunk_from_chars(0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02,
0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00);
- u_int32_t val;
+ uint32_t val;
assert_integer_read_end(data, 32, val);
assert_basic_read_end(32, val);
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
- u_int64_t val;
+ uint64_t val;
assert_integer_read_end(data, 64, val);
assert_basic_read_end(64, val);
{
chunk_t in;
u_char key[16];
- u_int64_t out;
+ uint64_t out;
int i, count;
count = countof(sip_vectors);
START_TEST(test_chunk_hash)
{
chunk_t chunk;
- u_int32_t hash_a, hash_b, hash_c;
+ uint32_t hash_a, hash_b, hash_c;
chunk = chunk_from_str("asdf");
START_TEST(test_chunk_hash_static)
{
chunk_t in;
- u_int32_t out, hash_a, hash_b, hash_inc = 0x7b891a95;
+ uint32_t out, hash_a, hash_b, hash_inc = 0x7b891a95;
int i, count;
count = countof(sip_vectors);
* test for chunk_internet_checksum[_inc]()
*/
-static inline u_int16_t compensate_alignment(u_int16_t val)
+static inline uint16_t compensate_alignment(uint16_t val)
{
return ((val & 0xff) << 8) | (val >> 8);
}
START_TEST(test_chunk_internet_checksum)
{
chunk_t chunk;
- u_int16_t sum;
+ uint16_t sum;
chunk = chunk_from_chars(0x45,0x00,0x00,0x30,0x44,0x22,0x40,0x00,0x80,0x06,
0x00,0x00,0x8c,0x7c,0x19,0xac,0xae,0x24,0x1e,0x2b);
* host_create_any
*/
-static void verify_any(host_t *host, int family, u_int16_t port)
+static void verify_any(host_t *host, int family, uint16_t port)
{
verify_netmask(host->get_address(host), 0);
ck_assert(host->is_anyaddr(host));
* host_create_from_string
*/
-static void verify_address(host_t *host, chunk_t addr, int family, u_int16_t port)
+static void verify_address(host_t *host, chunk_t addr, int family, uint16_t port)
{
ck_assert(chunk_equals(host->get_address(host), addr));
ck_assert(!host->is_anyaddr(host));
static struct {
char *addr;
- u_int16_t port;
+ uint16_t port;
/* results for %H, %+H, %#H (falls back to [0]) */
char *result[3];
} printf_data[] = {
START_TEST(test_iv_gen_seq)
{
iv_gen_t *iv_gen;
- u_int64_t iv0, iv1_1, iv1_2;
+ uint64_t iv0, iv1_1, iv1_2;
iv_gen = iv_gen_seq_create();
- ck_assert(iv_gen->get_iv(iv_gen, 0, 8, (u_int8_t*)&iv0));
- ck_assert(iv_gen->get_iv(iv_gen, 1, 8, (u_int8_t*)&iv1_1));
+ ck_assert(iv_gen->get_iv(iv_gen, 0, 8, (uint8_t*)&iv0));
+ ck_assert(iv_gen->get_iv(iv_gen, 1, 8, (uint8_t*)&iv1_1));
ck_assert(iv0 != iv1_1);
/* every sequence number may be used twice, but results in a different IV */
- ck_assert(iv_gen->get_iv(iv_gen, 1, 8, (u_int8_t*)&iv1_2));
+ ck_assert(iv_gen->get_iv(iv_gen, 1, 8, (uint8_t*)&iv1_2));
ck_assert(iv0 != iv1_2);
ck_assert(iv1_1 != iv1_2);
- ck_assert(!iv_gen->get_iv(iv_gen, 1, 8, (u_int8_t*)&iv1_2));
+ ck_assert(!iv_gen->get_iv(iv_gen, 1, 8, (uint8_t*)&iv1_2));
iv_gen->destroy(iv_gen);
}
END_TEST
START_TEST(test_iv_gen_seq_len)
{
iv_gen_t *iv_gen;
- u_int64_t iv;
- u_int8_t buf[9];
+ uint64_t iv;
+ uint8_t buf[9];
iv_gen = iv_gen_seq_create();
- ck_assert(!iv_gen->get_iv(iv_gen, 0, 0, (u_int8_t*)&iv));
- ck_assert(!iv_gen->get_iv(iv_gen, 0, 1, (u_int8_t*)&iv));
- ck_assert(!iv_gen->get_iv(iv_gen, 0, 2, (u_int8_t*)&iv));
- ck_assert(!iv_gen->get_iv(iv_gen, 0, 3, (u_int8_t*)&iv));
- ck_assert(!iv_gen->get_iv(iv_gen, 0, 4, (u_int8_t*)&iv));
- ck_assert(!iv_gen->get_iv(iv_gen, 0, 5, (u_int8_t*)&iv));
- ck_assert(!iv_gen->get_iv(iv_gen, 0, 6, (u_int8_t*)&iv));
- ck_assert(!iv_gen->get_iv(iv_gen, 0, 7, (u_int8_t*)&iv));
- ck_assert(iv_gen->get_iv(iv_gen, 0, 8, (u_int8_t*)&iv));
+ ck_assert(!iv_gen->get_iv(iv_gen, 0, 0, (uint8_t*)&iv));
+ ck_assert(!iv_gen->get_iv(iv_gen, 0, 1, (uint8_t*)&iv));
+ ck_assert(!iv_gen->get_iv(iv_gen, 0, 2, (uint8_t*)&iv));
+ ck_assert(!iv_gen->get_iv(iv_gen, 0, 3, (uint8_t*)&iv));
+ ck_assert(!iv_gen->get_iv(iv_gen, 0, 4, (uint8_t*)&iv));
+ ck_assert(!iv_gen->get_iv(iv_gen, 0, 5, (uint8_t*)&iv));
+ ck_assert(!iv_gen->get_iv(iv_gen, 0, 6, (uint8_t*)&iv));
+ ck_assert(!iv_gen->get_iv(iv_gen, 0, 7, (uint8_t*)&iv));
+ ck_assert(iv_gen->get_iv(iv_gen, 0, 8, (uint8_t*)&iv));
ck_assert(iv_gen->get_iv(iv_gen, 0, 9, buf));
iv_gen->destroy(iv_gen);
}
#include <plugins/ntru/ntru_private_key.h>
IMPORT_FUNCTION_FOR_TESTS(ntru, ntru_drbg_create, ntru_drbg_t*,
- u_int32_t strength, chunk_t pers_str, rng_t *entropy)
+ uint32_t strength, chunk_t pers_str, rng_t *entropy)
IMPORT_FUNCTION_FOR_TESTS(ntru, ntru_trits_create, ntru_trits_t*,
size_t len, hash_algorithm_t alg, chunk_t seed)
uint32_t indices_len_m, bool is_product_form)
IMPORT_FUNCTION_FOR_TESTS(ntru, ntru_poly_create_from_data, ntru_poly_t*,
- u_int16_t *data, uint16_t N, uint16_t q,
+ uint16_t *data, uint16_t N, uint16_t q,
uint32_t indices_len_p, uint32_t indices_len_m,
bool is_product_form)
};
typedef struct {
- u_int32_t requested;
- u_int32_t standard;
+ uint32_t requested;
+ uint32_t standard;
}strength_t;
strength_t strengths[] = {
START_TEST(test_printf_unsigned)
{
- verify("1 23 456", "%u %lu %llu", 1, (u_long)23, (u_int64_t)456);
+ verify("1 23 456", "%u %lu %llu", 1, (u_long)23, (uint64_t)456);
verify("65535 255", "%hu %hhu", 0x1ffff, 0x1ff);
verify("123456789", "%zu", (size_t)123456789);
verify(" 12", "%5u", 12);
START_TEST(test_printf_hex)
{
- verify("1 23 456", "%x %lx %llx", 1, (u_long)0x23, (u_int64_t)0x456);
+ verify("1 23 456", "%x %lx %llx", 1, (u_long)0x23, (uint64_t)0x456);
verify("12abcdef 12ABCDEF", "%x %X", 0x12ABCDEF, 0x12ABCDEF);
verify("ffff ff", "%hx %hhx", 0x1ffff, 0x1ff);
verify("23456789", "%zx", (size_t)0x23456789);
START_TEST(test_printf_pri)
{
- verify("255", "%" PRIu8, (u_int8_t)0xFF);
- verify("65535", "%" PRIu16, (u_int16_t)0xFFFF);
- verify("4294967295", "%" PRIu32, (u_int32_t)0x1FFFFFFFFll);
- verify("18446744073709551615", "%" PRIu64, (u_int64_t)0xFFFFFFFFFFFFFFFFll);
+ verify("255", "%" PRIu8, (uint8_t)0xFF);
+ verify("65535", "%" PRIu16, (uint16_t)0xFFFF);
+ verify("4294967295", "%" PRIu32, (uint32_t)0x1FFFFFFFFll);
+ verify("18446744073709551615", "%" PRIu64, (uint64_t)0xFFFFFFFFFFFFFFFFll);
verify("-1", "%" PRId8, (int8_t)-1);
verify("-1", "%" PRId16, (int16_t)-1);
char *from;
char *to;
char *net;
- u_int8_t mask;
+ uint8_t mask;
bool exact;
} to_subnet_tests[] = {
{ TS_IPV4_ADDR_RANGE, "10.0.0.1", "10.0.0.1", "10.0.0.1", 32, TRUE },
{
traffic_selector_t *ts;
host_t *net, *exp_net;
- u_int8_t mask;
+ uint8_t mask;
ts = traffic_selector_create_from_string(0, to_subnet_tests[_i].type,
to_subnet_tests[_i].from, 0, to_subnet_tests[_i].to, 0);
struct {
char *cidr;
- u_int16_t from_port;
- u_int16_t to_port;
- u_int16_t port;
+ uint16_t from_port;
+ uint16_t to_port;
+ uint16_t port;
} to_subnet_port_tests[] = {
{ "10.0.0.0/8", 0, 0, 0 },
{ "10.0.0.1/32", 80, 80, 80 },
{
traffic_selector_t *ts;
host_t *net, *exp_net;
- u_int8_t mask;
+ uint8_t mask;
int exp_mask;
ts = traffic_selector_create_from_cidr(to_subnet_port_tests[_i].cidr, 0,
bool contained;
struct {
char *net;
- u_int8_t proto;
- u_int16_t from_port;
- u_int16_t to_port;
+ uint8_t proto;
+ uint16_t from_port;
+ uint16_t to_port;
} a, b;
} is_contained_in_tests[] = {
{ TRUE, { "10.0.0.0/16", 0, 0, 65535 }, { "10.0.0.0/16", 0, 0, 65535 }, },
int res;
struct {
char *net;
- u_int8_t proto;
- u_int16_t from_port;
- u_int16_t to_port;
+ uint8_t proto;
+ uint16_t from_port;
+ uint16_t to_port;
} a, b;
} cmp_tests[] = {
{ 0, { "10.0.0.0/8", 0, 0, 65535 }, { "10.0.0.0/8", 0, 0, 65535 }, },
END_TEST
struct {
- u_int8_t proto;
- u_int16_t from_port;
- u_int16_t to_port;
- u_int8_t from_type;
- u_int8_t from_code;
- u_int8_t to_type;
- u_int8_t to_code;
+ uint8_t proto;
+ uint16_t from_port;
+ uint16_t to_port;
+ uint8_t from_type;
+ uint8_t from_code;
+ uint8_t to_type;
+ uint8_t to_code;
char *str;
char *str_alt;
} icmp_tests[] = {
START_TEST(test_icmp)
{
traffic_selector_t *ts;
- u_int16_t from, to;
+ uint16_t from, to;
ts = traffic_selector_create_dynamic(icmp_tests[_i].proto,
icmp_tests[_i].from_port, icmp_tests[_i].to_port);
START_TEST(test_htoun)
{
chunk_t net64, expected;
- u_int16_t host16 = 513;
- u_int32_t net16 = 0, host32 = 67305985;
- u_int64_t net32 = 0, host64 = 578437695752307201ULL;
+ uint16_t host16 = 513;
+ uint32_t net16 = 0, host32 = 67305985;
+ uint64_t net32 = 0, host64 = 578437695752307201ULL;
net64 = chunk_alloca(16);
memset(net64.ptr, 0, net64.len);
ck_assert(chunk_equals(expected, chunk_from_thing(net16)));
expected = chunk_from_chars(0x00, 0x00, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00);
- htoun32((u_int16_t*)&net32 + 1, host32);
+ htoun32((uint16_t*)&net32 + 1, host32);
ck_assert(chunk_equals(expected, chunk_from_thing(net32)));
expected = chunk_from_chars(0x00, 0x00, 0x00, 0x00,
0x08, 0x07, 0x06, 0x05,
0x04, 0x03, 0x02, 0x01,
0x00, 0x00, 0x00, 0x00);
- htoun64((u_int32_t*)net64.ptr + 1, host64);
+ htoun64((uint32_t*)net64.ptr + 1, host64);
ck_assert(chunk_equals(expected, net64));
}
END_TEST
START_TEST(test_untoh)
{
chunk_t net;
- u_int16_t host16;
- u_int32_t host32;
- u_int64_t host64;
+ uint16_t host16;
+ uint32_t host32;
+ uint64_t host64;
net = chunk_from_chars(0x00, 0x02, 0x01, 0x00);
host16 = untoh16(net.ptr + 1);
START_TEST(test_memxor_aligned)
{
- u_int64_t a = 0, b = 0;
+ uint64_t a = 0, b = 0;
chunk_t ca, cb;
int i;
};
METHOD(rng_t, get_bytes, bool,
- private_rng_t *this, size_t bytes, u_int8_t *buffer)
+ private_rng_t *this, size_t bytes, uint8_t *buffer)
{
if (bytes > this->entropy.len)
{
/**
* Helper functions for chunk_mac()
*/
-static inline u_int64_t sipget(u_char *in)
+static inline uint64_t sipget(u_char *in)
{
- u_int64_t v = 0;
+ uint64_t v = 0;
int i;
for (i = 0; i < 64; i += 8, ++in)
{
- v |= ((u_int64_t)*in) << i;
+ v |= ((uint64_t)*in) << i;
}
return v;
}
-static inline u_int64_t siprotate(u_int64_t v, int shift)
+static inline uint64_t siprotate(uint64_t v, int shift)
{
return (v << shift) | (v >> (64 - shift));
}
-static inline void sipround(u_int64_t *v0, u_int64_t *v1, u_int64_t *v2,
- u_int64_t *v3)
+static inline void sipround(uint64_t *v0, uint64_t *v1, uint64_t *v2,
+ uint64_t *v3)
{
*v0 += *v1;
*v1 = siprotate(*v1, 13);
*v3 ^= *v0;
}
-static inline void sipcompress(u_int64_t *v0, u_int64_t *v1, u_int64_t *v2,
- u_int64_t *v3, u_int64_t m)
+static inline void sipcompress(uint64_t *v0, uint64_t *v1, uint64_t *v2,
+ uint64_t *v3, uint64_t m)
{
*v3 ^= m;
sipround(v0, v1, v2, v3);
*v0 ^= m;
}
-static inline u_int64_t siplast(size_t len, u_char *pos)
+static inline uint64_t siplast(size_t len, u_char *pos)
{
- u_int64_t b;
+ uint64_t b;
int rem = len & 7;
- b = ((u_int64_t)len) << 56;
+ b = ((uint64_t)len) << 56;
switch (rem)
{
case 7:
- b |= ((u_int64_t)pos[6]) << 48;
+ b |= ((uint64_t)pos[6]) << 48;
case 6:
- b |= ((u_int64_t)pos[5]) << 40;
+ b |= ((uint64_t)pos[5]) << 40;
case 5:
- b |= ((u_int64_t)pos[4]) << 32;
+ b |= ((uint64_t)pos[4]) << 32;
case 4:
- b |= ((u_int64_t)pos[3]) << 24;
+ b |= ((uint64_t)pos[3]) << 24;
case 3:
- b |= ((u_int64_t)pos[2]) << 16;
+ b |= ((uint64_t)pos[2]) << 16;
case 2:
- b |= ((u_int64_t)pos[1]) << 8;
+ b |= ((uint64_t)pos[1]) << 8;
case 1:
- b |= ((u_int64_t)pos[0]);
+ b |= ((uint64_t)pos[0]);
break;
case 0:
break;
/**
* Caculate SipHash-2-4 with an optional first block given as argument.
*/
-static u_int64_t chunk_mac_inc(chunk_t chunk, u_char *key, u_int64_t m)
+static uint64_t chunk_mac_inc(chunk_t chunk, u_char *key, uint64_t m)
{
- u_int64_t v0, v1, v2, v3, k0, k1;
+ uint64_t v0, v1, v2, v3, k0, k1;
size_t len = chunk.len;
u_char *pos = chunk.ptr, *end;
/**
* Described in header.
*/
-u_int64_t chunk_mac(chunk_t chunk, u_char *key)
+uint64_t chunk_mac(chunk_t chunk, u_char *key)
{
return chunk_mac_inc(chunk, key, 0);
}
/**
* Described in header.
*/
-u_int32_t chunk_hash_inc(chunk_t chunk, u_int32_t hash)
+uint32_t chunk_hash_inc(chunk_t chunk, uint32_t hash)
{
/* we could use a mac of the previous hash, but this is faster */
- return chunk_mac_inc(chunk, key, ((u_int64_t)hash) << 32 | hash);
+ return chunk_mac_inc(chunk, key, ((uint64_t)hash) << 32 | hash);
}
/**
* Described in header.
*/
-u_int32_t chunk_hash(chunk_t chunk)
+uint32_t chunk_hash(chunk_t chunk)
{
return chunk_mac(chunk, key);
}
/**
* Described in header.
*/
-u_int32_t chunk_hash_static_inc(chunk_t chunk, u_int32_t hash)
+uint32_t chunk_hash_static_inc(chunk_t chunk, uint32_t hash)
{ /* we could use a mac of the previous hash, but this is faster */
- return chunk_mac_inc(chunk, static_key, ((u_int64_t)hash) << 32 | hash);
+ return chunk_mac_inc(chunk, static_key, ((uint64_t)hash) << 32 | hash);
}
/**
* Described in header.
*/
-u_int32_t chunk_hash_static(chunk_t chunk)
+uint32_t chunk_hash_static(chunk_t chunk)
{
return chunk_mac(chunk, static_key);
}
/**
* Described in header.
*/
-u_int16_t chunk_internet_checksum_inc(chunk_t data, u_int16_t checksum)
+uint16_t chunk_internet_checksum_inc(chunk_t data, uint16_t checksum)
{
- u_int32_t sum = ntohs((u_int16_t)~checksum);
+ uint32_t sum = ntohs((uint16_t)~checksum);
while (data.len > 1)
{
}
if (data.len)
{
- sum += (u_int16_t)*data.ptr << 8;
+ sum += (uint16_t)*data.ptr << 8;
}
while (sum >> 16)
{
/**
* Described in header.
*/
-u_int16_t chunk_internet_checksum(chunk_t data)
+uint16_t chunk_internet_checksum(chunk_t data)
{
return chunk_internet_checksum_inc(data, 0xffff);
}
* @param chunk data to hash
* @return hash value
*/
-u_int32_t chunk_hash(chunk_t chunk);
+uint32_t chunk_hash(chunk_t chunk);
/**
* Incremental version of chunk_hash. Use this to hash two or more chunks.
* @param hash previous hash value
* @return hash value
*/
-u_int32_t chunk_hash_inc(chunk_t chunk, u_int32_t hash);
+uint32_t chunk_hash_inc(chunk_t chunk, uint32_t hash);
/**
* Computes a 32 bit hash of the given chunk.
* @param chunk data to hash
* @return hash value
*/
-u_int32_t chunk_hash_static(chunk_t chunk);
+uint32_t chunk_hash_static(chunk_t chunk);
/**
* Incremental version of chunk_hash_static(). Use this to hash two or more
* @param hash previous hash value
* @return hash value
*/
-u_int32_t chunk_hash_static_inc(chunk_t chunk, u_int32_t hash);
+uint32_t chunk_hash_static_inc(chunk_t chunk, uint32_t hash);
/**
* Computes a quick MAC from the given chunk and key using SipHash.
* @param key key to use
* @return MAC for given input and key
*/
-u_int64_t chunk_mac(chunk_t chunk, u_char *key);
+uint64_t chunk_mac(chunk_t chunk, u_char *key);
/**
* Calculate the Internet Checksum according to RFC 1071 for the given chunk.
* @param data data to process
* @return checksum (one's complement, network order)
*/
-u_int16_t chunk_internet_checksum(chunk_t data);
+uint16_t chunk_internet_checksum(chunk_t data);
/**
* Extend the given Internet Checksum (one's complement, in network byte order)
* @param checksum previous checksum (one's complement, network order)
* @return checksum (one's complement, network order)
*/
-u_int16_t chunk_internet_checksum_inc(chunk_t data, u_int16_t checksum);
+uint16_t chunk_internet_checksum_inc(chunk_t data, uint16_t checksum);
/**
* printf hook function for chunk_t.
*/
cpu_feature_t cpu_feature_get_all()
{
- char vendor[3 * sizeof(u_int32_t) + 1];
+ char vendor[3 * sizeof(uint32_t) + 1];
cpu_feature_t f = 0;
u_int a, b, c, d;
int checksum_count;
};
-METHOD(integrity_checker_t, build_file, u_int32_t,
+METHOD(integrity_checker_t, build_file, uint32_t,
private_integrity_checker_t *this, char *file, size_t *len)
{
- u_int32_t checksum;
+ uint32_t checksum;
chunk_t *contents;
contents = chunk_map(file, FALSE);
return 0;
}
-METHOD(integrity_checker_t, build_segment, u_int32_t,
+METHOD(integrity_checker_t, build_segment, uint32_t,
private_integrity_checker_t *this, void *sym, size_t *len)
{
chunk_t segment;
private_integrity_checker_t *this, char *name, char *file)
{
integrity_checksum_t *cs;
- u_int32_t sum;
+ uint32_t sum;
size_t len = 0;
cs = find_checksum(this, name);
private_integrity_checker_t *this, char *name, void *sym)
{
integrity_checksum_t *cs;
- u_int32_t sum;
+ uint32_t sum;
size_t len = 0;
cs = find_checksum(this, name);
/* size in bytes of the file on disk */
size_t file_len;
/* checksum of the file on disk */
- u_int32_t file;
+ uint32_t file;
/* size in bytes of executable segment in memory */
size_t segment_len;
/* checksum of the executable segment in memory */
- u_int32_t segment;
+ uint32_t segment;
};
/**
* @param len return length in bytes of file
* @return checksum, 0 on error
*/
- u_int32_t (*build_file)(integrity_checker_t *this, char *file, size_t *len);
+ uint32_t (*build_file)(integrity_checker_t *this, char *file, size_t *len);
/**
* Check the integrity of the code segment in memory.
* @param len return length in bytes of code segment in memory
* @return checksum, 0 on error
*/
- u_int32_t (*build_segment)(integrity_checker_t *this, void *sym, size_t *len);
+ uint32_t (*build_segment)(integrity_checker_t *this, void *sym, size_t *len);
/**
* Check both, on disk file integrity and loaded segment.
/**
* Padding to make sizeof(memory_header_t) == 32
*/
- u_int32_t padding[sizeof(void*) == sizeof(u_int32_t) ? 3 : 0];
+ uint32_t padding[sizeof(void*) == sizeof(uint32_t) ? 3 : 0];
/**
* Number of bytes following after the header
*/
- u_int32_t bytes;
+ uint32_t bytes;
/**
* magic bytes to detect bad free or heap underflow, MEMORY_HEADER_MAGIC
*/
- u_int32_t magic;
+ uint32_t magic;
}__attribute__((__packed__));
/**
* Magic bytes to detect heap overflow, MEMORY_TAIL_MAGIC
*/
- u_int32_t magic;
+ uint32_t magic;
}__attribute__((__packed__));
/* This is from the kernel sources. We limit the length of directory names to
* 256 as we only use it to enumerate FDs. */
struct linux_dirent64 {
- u_int64_t d_ino;
+ uint64_t d_ino;
int64_t d_off;
unsigned short d_reclen;
unsigned char d_type;
/**
* Described in header.
*/
-void* malloc_align(size_t size, u_int8_t align)
+void* malloc_align(size_t size, uint8_t align)
{
- u_int8_t pad;
+ uint8_t pad;
void *ptr;
if (align == 0)
*/
void free_align(void *ptr)
{
- u_int8_t pad, *pos;
+ uint8_t pad, *pos;
pos = ptr - 1;
/* verify padding to check any corruption */
* @param align alignment, up to 255 bytes, usually a power of 2
* @return allocated hunk, aligned to align bytes
*/
-void* malloc_align(size_t size, u_int8_t align);
+void* malloc_align(size_t size, uint8_t align);
/**
* Free a hunk allocated by malloc_align().
* Architecture independent bitfield definition helpers (at least with GCC).
*
* Defines a bitfield with a type t and a fixed size of bitfield members, e.g.:
- * BITFIELD2(u_int8_t,
+ * BITFIELD2(uint8_t,
* low: 4,
* high: 4,
* ) flags;
* @param host host order 16-bit value
* @param network unaligned address to write network order value to
*/
-static inline void htoun16(void *network, u_int16_t host)
+static inline void htoun16(void *network, uint16_t host)
{
char *unaligned = (char*)network;
* @param host host order 32-bit value
* @param network unaligned address to write network order value to
*/
-static inline void htoun32(void *network, u_int32_t host)
+static inline void htoun32(void *network, uint32_t host)
{
char *unaligned = (char*)network;
* @param host host order 64-bit value
* @param network unaligned address to write network order value to
*/
-static inline void htoun64(void *network, u_int64_t host)
+static inline void htoun64(void *network, uint64_t host)
{
char *unaligned = (char*)network;
* @param network unaligned address to read network order value from
* @return host order value
*/
-static inline u_int16_t untoh16(void *network)
+static inline uint16_t untoh16(void *network)
{
char *unaligned = (char*)network;
- u_int16_t tmp;
+ uint16_t tmp;
memcpy(&tmp, unaligned, sizeof(tmp));
return ntohs(tmp);
* @param network unaligned address to read network order value from
* @return host order value
*/
-static inline u_int32_t untoh32(void *network)
+static inline uint32_t untoh32(void *network)
{
char *unaligned = (char*)network;
- u_int32_t tmp;
+ uint32_t tmp;
memcpy(&tmp, unaligned, sizeof(tmp));
return ntohl(tmp);
* @param network unaligned address to read network order value from
* @return host order value
*/
-static inline u_int64_t untoh64(void *network)
+static inline uint64_t untoh64(void *network)
{
char *unaligned = (char*)network;
- u_int64_t tmp;
+ uint64_t tmp;
memcpy(&tmp, unaligned, sizeof(tmp));
return be64toh(tmp);
* @param p unaligned address to read little endian value from
* @return host order value
*/
-static inline u_int32_t uletoh32(void *p)
+static inline uint32_t uletoh32(void *p)
{
- u_int32_t ret;
+ uint32_t ret;
memcpy(&ret, p, sizeof(ret));
ret = le32toh(ret);
* @param p host order 32-bit value
* @param v unaligned address to write little endian value to
*/
-static inline void htoule32(void *p, u_int32_t v)
+static inline void htoule32(void *p, uint32_t v)
{
v = htole32(v);
memcpy(p, &v, sizeof(v));
/**
* Described in header.
*/
-void memxor(u_int8_t dst[], u_int8_t src[], size_t n)
+void memxor(uint8_t dst[], uint8_t src[], size_t n)
{
int m, i;
/**
* Same as memcpy, but XORs src into dst instead of copy
*/
-void memxor(u_int8_t dest[], u_int8_t src[], size_t n);
+void memxor(uint8_t dest[], uint8_t src[], size_t n);
/**
* Safely overwrite n bytes of memory at ptr with zero, non-inlining variant.
char* unit = "second";
time_t *arg1 = *((time_t**)(args[0]));
time_t *arg2 = *((time_t**)(args[1]));
- u_int64_t delta = llabs(*arg1 - *arg2);
+ uint64_t delta = llabs(*arg1 - *arg2);
if (delta > 2 * 60 * 60 * 24)
{
*/
#if defined __sun || defined WIN32
#include <stdint.h>
-typedef uint8_t u_int8_t;
-typedef uint16_t u_int16_t;
-typedef uint32_t u_int32_t;
-typedef uint64_t u_int64_t;
+typedef uint8_t uint8_t;
+typedef uint16_t uint16_t;
+typedef uint32_t uint32_t;
+typedef uint64_t uint64_t;
#endif
#ifdef HAVE_INT128
# define MAX_UINT_TYPE u_int128_t
#else
# define MAX_INT_TYPE int64_t
-# define MAX_UINT_TYPE u_int64_t
+# define MAX_UINT_TYPE uint64_t
#endif
/**
*/
typedef struct {
tls_version_t version;
- u_int16_t port;
+ uint16_t port;
char *addr;
chunk_t data;
int fd;
/**
* Common test wrapper function for different test variants
*/
-static void test_tls(tls_version_t version, u_int16_t port, bool cauth, u_int i)
+static void test_tls(tls_version_t version, uint16_t port, bool cauth, u_int i)
{
echo_server_config_t *config;
tls_cipher_suite_t *suites;
* TLS record
*/
typedef struct __attribute__((packed)) {
- u_int8_t type;
- u_int16_t version;
- u_int16_t length;
+ uint8_t type;
+ uint16_t version;
+ uint16_t length;
char data[];
} tls_record_t;
* Associated header data to create signature over
*/
typedef struct __attribute__((__packed__)) {
- u_int64_t seq;
- u_int8_t type;
- u_int16_t version;
- u_int16_t length;
+ uint64_t seq;
+ uint8_t type;
+ uint16_t version;
+ uint16_t length;
} sigheader_t;
METHOD(tls_aead_t, encrypt, bool,
private_tls_aead_t *this, tls_version_t version, tls_content_type_t type,
- u_int64_t seq, chunk_t *data)
+ uint64_t seq, chunk_t *data)
{
chunk_t assoc, encrypted, iv, plain;
- u_int8_t icvlen;
+ uint8_t icvlen;
sigheader_t hdr;
iv_gen_t *gen;
METHOD(tls_aead_t, decrypt, bool,
private_tls_aead_t *this, tls_version_t version, tls_content_type_t type,
- u_int64_t seq, chunk_t *data)
+ uint64_t seq, chunk_t *data)
{
chunk_t assoc, iv;
- u_int8_t icvlen;
+ uint8_t icvlen;
sigheader_t hdr;
iv.len = this->aead->get_iv_size(this->aead);
* @return TRUE if successfully encrypted
*/
bool (*encrypt)(tls_aead_t *this, tls_version_t version,
- tls_content_type_t type, u_int64_t seq, chunk_t *data);
+ tls_content_type_t type, uint64_t seq, chunk_t *data);
/**
* Decrypt and verify a TLS record.
* @return TRUE if successfully decrypted
*/
bool (*decrypt)(tls_aead_t *this, tls_version_t version,
- tls_content_type_t type, u_int64_t seq, chunk_t *data);
+ tls_content_type_t type, uint64_t seq, chunk_t *data);
/**
* Get the authentication key size.
* Associated header data to create signature over
*/
typedef struct __attribute__((__packed__)) {
- u_int64_t seq;
- u_int8_t type;
- u_int16_t version;
- u_int16_t length;
+ uint64_t seq;
+ uint8_t type;
+ uint16_t version;
+ uint16_t length;
} sigheader_t;
METHOD(tls_aead_t, encrypt, bool,
private_tls_aead_t *this, tls_version_t version, tls_content_type_t type,
- u_int64_t seq, chunk_t *data)
+ uint64_t seq, chunk_t *data)
{
chunk_t assoc, mac, padding, iv;
- u_int8_t bs, padlen;
+ uint8_t bs, padlen;
sigheader_t hdr;
hdr.type = type;
METHOD(tls_aead_t, decrypt, bool,
private_tls_aead_t *this, tls_version_t version, tls_content_type_t type,
- u_int64_t seq, chunk_t *data)
+ uint64_t seq, chunk_t *data)
{
chunk_t assoc, mac, iv;
- u_int8_t bs, padlen;
+ uint8_t bs, padlen;
sigheader_t hdr;
size_t i;
* Associated header data to create signature over
*/
typedef struct __attribute__((__packed__)) {
- u_int64_t seq;
- u_int8_t type;
- u_int16_t version;
- u_int16_t length;
+ uint64_t seq;
+ uint8_t type;
+ uint16_t version;
+ uint16_t length;
} sigheader_t;
METHOD(tls_aead_t, encrypt, bool,
private_tls_aead_t *this, tls_version_t version,
- tls_content_type_t type, u_int64_t seq, chunk_t *data)
+ tls_content_type_t type, uint64_t seq, chunk_t *data)
{
chunk_t assoc, mac, padding;
- u_int8_t bs, padlen;
+ uint8_t bs, padlen;
sigheader_t hdr;
hdr.type = type;
METHOD(tls_aead_t, decrypt, bool,
private_tls_aead_t *this, tls_version_t version,
- tls_content_type_t type, u_int64_t seq, chunk_t *data)
+ tls_content_type_t type, uint64_t seq, chunk_t *data)
{
chunk_t assoc, mac, iv;
- u_int8_t bs, padlen;
+ uint8_t bs, padlen;
sigheader_t hdr;
size_t i;
* Associated header data to create signature over
*/
typedef struct __attribute__((__packed__)) {
- u_int64_t seq;
- u_int8_t type;
- u_int16_t version;
- u_int16_t length;
+ uint64_t seq;
+ uint8_t type;
+ uint16_t version;
+ uint16_t length;
} sigheader_t;
METHOD(tls_aead_t, encrypt, bool,
private_tls_aead_t *this, tls_version_t version,
- tls_content_type_t type, u_int64_t seq, chunk_t *data)
+ tls_content_type_t type, uint64_t seq, chunk_t *data)
{
chunk_t assoc, mac;
sigheader_t hdr;
METHOD(tls_aead_t, decrypt, bool,
private_tls_aead_t *this, tls_version_t version,
- tls_content_type_t type, u_int64_t seq, chunk_t *data)
+ tls_content_type_t type, uint64_t seq, chunk_t *data)
{
chunk_t assoc, mac;
sigheader_t hdr;
METHOD(tls_crypto_t, append_handshake, void,
private_tls_crypto_t *this, tls_handshake_type_t type, chunk_t data)
{
- u_int32_t header;
+ uint32_t header;
/* reconstruct handshake header */
header = htonl(data.len | (type << 24));
{
signature_scheme_t scheme;
bio_reader_t *reader;
- u_int8_t hash, alg;
+ uint8_t hash, alg;
chunk_t sig;
bool done = FALSE;
if (this->tls->get_version(this->tls) >= TLS_1_2)
{
signature_scheme_t scheme = SIGN_UNKNOWN;
- u_int8_t hash, alg;
+ uint8_t hash, alg;
chunk_t sig;
if (!reader->read_uint8(reader, &hash) ||
static status_t process_alert(private_tls_fragmentation_t *this,
bio_reader_t *reader)
{
- u_int8_t level, description;
+ uint8_t level, description;
if (!reader->read_uint8(reader, &level) ||
!reader->read_uint8(reader, &description))
while (reader->remaining(reader))
{
bio_reader_t *msg;
- u_int8_t type;
- u_int32_t len;
+ uint8_t type;
+ uint32_t len;
status_t status;
chunk_t data;
static status_t process_server_hello(private_tls_peer_t *this,
bio_reader_t *reader)
{
- u_int8_t compression;
- u_int16_t version, cipher;
+ uint8_t compression;
+ uint16_t version, cipher;
chunk_t random, session, ext = chunk_empty;
tls_cipher_suite_t suite = 0;
{
diffie_hellman_group_t group;
public_key_t *public;
- u_int8_t type;
- u_int16_t curve;
+ uint8_t type;
+ uint16_t curve;
chunk_t pub, chunk;
chunk = reader->peek(reader);
private_key_t *key = NULL;
bio_reader_t *reader;
key_type_t type;
- u_int8_t cert;
+ uint8_t cert;
if (!this->peer)
{
/**
* Sequence number of incoming records
*/
- u_int64_t seq_in;
+ uint64_t seq_in;
/**
* Sequence number for outgoing records
*/
- u_int64_t seq_out;
+ uint64_t seq_out;
/**
* AEAD transform for inbound traffic
static status_t process_client_hello(private_tls_server_t *this,
bio_reader_t *reader)
{
- u_int16_t version, extension;
+ uint16_t version, extension;
chunk_t random, session, ciphers, compression, ext = chunk_empty;
bio_reader_t *extensions;
tls_cipher_suite_t *suites;
}
else
{
- count = ciphers.len / sizeof(u_int16_t);
+ count = ciphers.len / sizeof(uint16_t);
suites = alloca(count * sizeof(tls_cipher_suite_t));
DBG2(DBG_TLS, "received %d TLS cipher suites:", count);
for (i = 0; i < count; i++)
{
- suites[i] = untoh16(&ciphers.ptr[i * sizeof(u_int16_t)]);
+ suites[i] = untoh16(&ciphers.ptr[i * sizeof(uint16_t)]);
DBG2(DBG_TLS, " %N", tls_cipher_suite_names, suites[i]);
}
if (!select_suite_and_key(this, suites, count))
bool peer_supports_curve(private_tls_server_t *this, tls_named_curve_t curve)
{
bio_reader_t *reader;
- u_int16_t current;
+ uint16_t current;
if (!this->curves_received)
{ /* none received, assume yes */
/**
* Maximum size of a PA-TNC message
*/
- u_int32_t max_msg_len;
+ uint32_t max_msg_len;
/**
* collection of IMV recommendations
METHOD(tnccs_manager_t, create_connection, TNC_ConnectionID,
private_tnc_tnccs_manager_t *this, tnccs_type_t type, tnccs_t *tnccs,
tnccs_send_message_t send_message, bool* request_handshake_retry,
- u_int32_t max_msg_len, recommendations_t **recs)
+ uint32_t max_msg_len, recommendations_t **recs)
{
tnccs_connection_entry_t *entry;
}
/**
- * Write the value of an u_int32_t attribute into the buffer
+ * Write the value of an uint32_t attribute into the buffer
*/
static TNC_Result uint_attribute(TNC_UInt32 buffer_len,
TNC_BufferReference buffer,
TNC_UInt32 *value_len,
- u_int32_t value)
+ uint32_t value)
{
- *value_len = sizeof(u_int32_t);
+ *value_len = sizeof(uint32_t);
if (buffer && buffer_len >= *value_len)
{
{
bio_writer_t *writer;
enumerator_t *enumerator;
- u_int32_t count;
+ uint32_t count;
chunk_t value;
tncif_identity_t *tnc_id;
TNC_Result result = TNC_RESULT_INVALID_PARAMETER;
host_t *peer_ip;
tnccs_t *tnccs;
tncif_identity_t *tnc_id;
- u_int32_t id_type, subject_type;
+ uint32_t id_type, subject_type;
chunk_t id_value;
char *id_str;
TNC_Result result;
/**
* Type of TNC client authentication
*/
- u_int32_t auth_type;
+ uint32_t auth_type;
/**
* Connection ID assigned to this TNCCS connection
imc_imv_msg_t *imc_imv_msg;
TNC_MessageType msg_type;
chunk_t msg_body;
- u_int32_t msg_vid, msg_subtype;
+ uint32_t msg_vid, msg_subtype;
enum_name_t *pa_subtype_names;
imc_imv_msg = (imc_imv_msg_t*)msg;
this->transport = transport;
}
-METHOD(tnccs_t, get_auth_type, u_int32_t,
+METHOD(tnccs_t, get_auth_type, uint32_t,
private_tnccs_11_t *this)
{
return this->auth_type;
}
METHOD(tnccs_t, set_auth_type, void,
- private_tnccs_11_t *this, u_int32_t auth_type)
+ private_tnccs_11_t *this, uint32_t auth_type)
{
this->auth_type = auth_type;
}
METHOD(tnccs_t, get_pdp_server, chunk_t,
- private_tnccs_11_t *this, u_int16_t *port)
+ private_tnccs_11_t *this, uint16_t *port)
{
*port = 0;
/**
* Offset into encoding (used for error reporting)
*/
- u_int32_t offset;
+ uint32_t offset;
};
METHOD(pb_tnc_batch_t, get_type, pb_tnc_batch_type_t,
METHOD(pb_tnc_batch_t, build, void,
private_pb_tnc_batch_t *this)
{
- u_int8_t version;
- u_int32_t msg_len;
+ uint8_t version;
+ uint32_t msg_len;
chunk_t msg_value;
enumerator_t *enumerator;
pen_type_t msg_type;
enumerator = this->messages->create_enumerator(this->messages);
while (enumerator->enumerate(enumerator, &msg))
{
- u_int8_t flags = PB_TNC_FLAG_NONE;
+ uint8_t flags = PB_TNC_FLAG_NONE;
/* build PB-TNC message */
msg_value = msg->get_encoding(msg);
bio_reader_t *reader;
pb_tnc_msg_t *msg;
pb_error_msg_t *err_msg;
- u_int8_t version, flags, reserved, type;
- u_int32_t batch_len;
+ uint8_t version, flags, reserved, type;
+ uint32_t batch_len;
if (this->encoding.len < PB_TNC_BATCH_HEADER_SIZE)
{
bio_reader_t *reader;
pb_tnc_msg_t *pb_tnc_msg, *msg;
pb_tnc_msg_info_t *msg_infos;
- u_int8_t flags;
- u_int32_t vendor_id, msg_type, msg_len, offset;
+ uint8_t flags;
+ uint32_t vendor_id, msg_type, msg_len, offset;
chunk_t data, msg_value;
bool noskip_flag;
enum_name_t *msg_type_names;
/**
* Access recommendation code
*/
- u_int16_t recommendation;
+ uint16_t recommendation;
/**
* Encoded message
}
METHOD(pb_tnc_msg_t, process, status_t,
- private_pb_access_recommendation_msg_t *this, u_int32_t *offset)
+ private_pb_access_recommendation_msg_t *this, uint32_t *offset)
{
bio_reader_t *reader;
- u_int16_t reserved;
+ uint16_t reserved;
reader = bio_reader_create(this->encoding);
reader->read_uint16(reader, &reserved);
free(this);
}
-METHOD(pb_access_recommendation_msg_t, get_access_recommendation, u_int16_t,
+METHOD(pb_access_recommendation_msg_t, get_access_recommendation, uint16_t,
private_pb_access_recommendation_msg_t *this)
{
return this->recommendation;
/**
* See header
*/
-pb_tnc_msg_t *pb_access_recommendation_msg_create(u_int16_t recommendation)
+pb_tnc_msg_t *pb_access_recommendation_msg_create(uint16_t recommendation)
{
private_pb_access_recommendation_msg_t *this;
*
* @return PB Access Recommendation
*/
- u_int16_t (*get_access_recommendation)(pb_access_recommendation_msg_t *this);
+ uint16_t (*get_access_recommendation)(pb_access_recommendation_msg_t *this);
};
/**
*
* @param recommendation Access Recommendation code
*/
-pb_tnc_msg_t* pb_access_recommendation_msg_create(u_int16_t recommendation);
+pb_tnc_msg_t* pb_access_recommendation_msg_create(uint16_t recommendation);
/**
* Create an unprocessed PB-Access-Recommendation message from raw data
/**
* Assessment result code
*/
- u_int32_t assessment_result;
+ uint32_t assessment_result;
/**
* Encoded message
}
METHOD(pb_tnc_msg_t, process, status_t,
- private_pb_assessment_result_msg_t *this, u_int32_t *offset)
+ private_pb_assessment_result_msg_t *this, uint32_t *offset)
{
bio_reader_t *reader;
free(this);
}
-METHOD(pb_assessment_result_msg_t, get_assessment_result, u_int32_t,
+METHOD(pb_assessment_result_msg_t, get_assessment_result, uint32_t,
private_pb_assessment_result_msg_t *this)
{
return this->assessment_result;
/**
* See header
*/
-pb_tnc_msg_t *pb_assessment_result_msg_create(u_int32_t assessment_result)
+pb_tnc_msg_t *pb_assessment_result_msg_create(uint32_t assessment_result)
{
private_pb_assessment_result_msg_t *this;
*
* @return PB Assessment result
*/
- u_int32_t (*get_assessment_result)(pb_assessment_result_msg_t *this);
+ uint32_t (*get_assessment_result)(pb_assessment_result_msg_t *this);
};
/**
*
* @param assessment_result Assessment result code
*/
-pb_tnc_msg_t* pb_assessment_result_msg_create(u_int32_t assessment_result);
+pb_tnc_msg_t* pb_assessment_result_msg_create(uint32_t assessment_result);
/**
* Create an unprocessed PB-Assessment-Result message from raw data
/**
* PB Error Code Vendor ID
*/
- u_int32_t vendor_id;
+ uint32_t vendor_id;
/**
* PB Error Code
*/
- u_int16_t error_code;
+ uint16_t error_code;
/**
* PB Error Offset
*/
- u_int32_t error_offset;
+ uint32_t error_offset;
/**
* Bad PB-TNC version received
*/
- u_int8_t bad_version;
+ uint8_t bad_version;
/**
* Encoded message
}
METHOD(pb_tnc_msg_t, process, status_t,
- private_pb_error_msg_t *this, u_int32_t *offset)
+ private_pb_error_msg_t *this, uint32_t *offset)
{
- u_int8_t flags, max_version, min_version;
- u_int16_t reserved;
+ uint8_t flags, max_version, min_version;
+ uint16_t reserved;
bio_reader_t *reader;
if (this->encoding.len < ERROR_HEADER_SIZE)
return this->fatal;
}
-METHOD(pb_error_msg_t, get_vendor_id, u_int32_t,
+METHOD(pb_error_msg_t, get_vendor_id, uint32_t,
private_pb_error_msg_t *this)
{
return this->vendor_id;
}
-METHOD(pb_error_msg_t, get_error_code, u_int16_t,
+METHOD(pb_error_msg_t, get_error_code, uint16_t,
private_pb_error_msg_t *this)
{
return this->error_code;
}
-METHOD(pb_error_msg_t, get_offset, u_int32_t,
+METHOD(pb_error_msg_t, get_offset, uint32_t,
private_pb_error_msg_t *this)
{
return this->error_offset;
}
-METHOD(pb_error_msg_t, get_bad_version, u_int8_t,
+METHOD(pb_error_msg_t, get_bad_version, uint8_t,
private_pb_error_msg_t *this)
{
return this->bad_version;
}
METHOD(pb_error_msg_t, set_bad_version, void,
- private_pb_error_msg_t *this, u_int8_t version)
+ private_pb_error_msg_t *this, uint8_t version)
{
this->bad_version = version;
}
/**
* See header
*/
-pb_tnc_msg_t* pb_error_msg_create(bool fatal, u_int32_t vendor_id,
+pb_tnc_msg_t* pb_error_msg_create(bool fatal, uint32_t vendor_id,
pb_tnc_error_code_t error_code)
{
private_pb_error_msg_t *this;
/**
* See header
*/
-pb_tnc_msg_t* pb_error_msg_create_with_offset(bool fatal, u_int32_t vendor_id,
+pb_tnc_msg_t* pb_error_msg_create_with_offset(bool fatal, uint32_t vendor_id,
pb_tnc_error_code_t error_code,
- u_int32_t error_offset)
+ uint32_t error_offset)
{
private_pb_error_msg_t *this;
*
* @return PB Error Code Vendor ID
*/
- u_int32_t (*get_vendor_id)(pb_error_msg_t *this);
+ uint32_t (*get_vendor_id)(pb_error_msg_t *this);
/**
* Get PB Error Code
*
* @return PB Error Code
*/
- u_int16_t (*get_error_code)(pb_error_msg_t *this);
+ uint16_t (*get_error_code)(pb_error_msg_t *this);
/**
* Get the PB Error Offset
*
* @return PB Error Offset
*/
- u_int32_t (*get_offset)(pb_error_msg_t *this);
+ uint32_t (*get_offset)(pb_error_msg_t *this);
/**
* Get the PB Bad Version
*
* @return PB Bad Version
*/
- u_int8_t (*get_bad_version)(pb_error_msg_t *this);
+ uint8_t (*get_bad_version)(pb_error_msg_t *this);
/**
* Set the PB Bad Version
*
* @param version PB Bad Version
*/
- void (*set_bad_version)(pb_error_msg_t *this, u_int8_t version);
+ void (*set_bad_version)(pb_error_msg_t *this, uint8_t version);
};
/**
* @param vendor_id Error Code Vendor ID
* @param error_code Error Code
*/
-pb_tnc_msg_t* pb_error_msg_create(bool fatal, u_int32_t vendor_id,
+pb_tnc_msg_t* pb_error_msg_create(bool fatal, uint32_t vendor_id,
pb_tnc_error_code_t error_code);
/**
* @param error_code Error Code
* @param error_offset Error Offset
*/
-pb_tnc_msg_t* pb_error_msg_create_with_offset(bool fatal, u_int32_t vendor_id,
+pb_tnc_msg_t* pb_error_msg_create_with_offset(bool fatal, uint32_t vendor_id,
pb_tnc_error_code_t error_code,
- u_int32_t error_offset);
+ uint32_t error_offset);
/**
* Create an unprocessed PB-Error message from raw data
}
METHOD(pb_tnc_msg_t, process, status_t,
- private_pb_experimental_msg_t *this, u_int32_t *offset)
+ private_pb_experimental_msg_t *this, uint32_t *offset)
{
return SUCCESS;
}
}
METHOD(pb_tnc_msg_t, process, status_t,
- private_pb_language_preference_msg_t *this, u_int32_t *offset)
+ private_pb_language_preference_msg_t *this, uint32_t *offset)
{
chunk_t lang;
/**
* Posture Validator Identifier
*/
- u_int16_t collector_id;
+ uint16_t collector_id;
/**
* Posture Validator Identifier
*/
- u_int16_t validator_id;
+ uint16_t validator_id;
/**
* PA Message Body
}
METHOD(pb_tnc_msg_t, process, status_t,
- private_pb_pa_msg_t *this, u_int32_t *offset)
+ private_pb_pa_msg_t *this, uint32_t *offset)
{
- u_int8_t flags;
+ uint8_t flags;
size_t msg_body_len;
bio_reader_t *reader;
return this->subtype;
}
-METHOD(pb_pa_msg_t, get_collector_id, u_int16_t,
+METHOD(pb_pa_msg_t, get_collector_id, uint16_t,
private_pb_pa_msg_t *this)
{
return this->collector_id;
}
-METHOD(pb_pa_msg_t, get_validator_id, u_int16_t,
+METHOD(pb_pa_msg_t, get_validator_id, uint16_t,
private_pb_pa_msg_t *this)
{
return this->validator_id;
/**
* See header
*/
-pb_tnc_msg_t *pb_pa_msg_create(u_int32_t vendor_id, u_int32_t subtype,
- u_int16_t collector_id, u_int16_t validator_id,
+pb_tnc_msg_t *pb_pa_msg_create(uint32_t vendor_id, uint32_t subtype,
+ uint16_t collector_id, uint16_t validator_id,
bool excl, chunk_t msg_body)
{
private_pb_pa_msg_t *this;
*
* @return Posture Collector ID
*/
- u_int16_t (*get_collector_id)(pb_pa_msg_t *this);
+ uint16_t (*get_collector_id)(pb_pa_msg_t *this);
/**
* Get Posture Validator ID
*
* @return Posture Validator ID
*/
- u_int16_t (*get_validator_id)(pb_pa_msg_t *this);
+ uint16_t (*get_validator_id)(pb_pa_msg_t *this);
/**
* Get the PA Message Body
* @param excl Exclusive Flag
* @param msg_body PA Message Body
*/
-pb_tnc_msg_t *pb_pa_msg_create(u_int32_t vendor_id, u_int32_t subtype,
- u_int16_t collector_id, u_int16_t validator_id,
+pb_tnc_msg_t *pb_pa_msg_create(uint32_t vendor_id, uint32_t subtype,
+ uint16_t collector_id, uint16_t validator_id,
bool excl, chunk_t msg_body);
/**
}
METHOD(pb_tnc_msg_t, process, status_t,
- private_pb_reason_string_msg_t *this, u_int32_t *offset)
+ private_pb_reason_string_msg_t *this, uint32_t *offset)
{
bio_reader_t *reader;
}
METHOD(pb_tnc_msg_t, process, status_t,
- private_pb_remediation_parameters_msg_t *this, u_int32_t *offset)
+ private_pb_remediation_parameters_msg_t *this, uint32_t *offset)
{
bio_reader_t *reader;
- u_int8_t reserved;
+ uint8_t reserved;
status_t status = SUCCESS;
u_char *pos;
}
METHOD(pb_tnc_msg_t, process, status_t,
- private_pb_mutual_capability_msg_t *this, u_int32_t *offset)
+ private_pb_mutual_capability_msg_t *this, uint32_t *offset)
{
bio_reader_t *reader;
}
METHOD(pb_tnc_msg_t, process, status_t,
- private_pb_noskip_test_msg_t *this, u_int32_t *offset)
+ private_pb_noskip_test_msg_t *this, uint32_t *offset)
{
return SUCCESS;
}
* Information entry describing a PB-TNC Message Type
*/
struct pb_tnc_msg_info_t {
- u_int32_t min_size;
+ uint32_t min_size;
bool exact_size;
bool in_result_batch;
signed char has_noskip_flag;
* @param relative offset where an error occurred
* @return return processing status
*/
- status_t (*process)(pb_tnc_msg_t *this, u_int32_t *offset);
+ status_t (*process)(pb_tnc_msg_t *this, uint32_t *offset);
/**
* Get a new reference to the message.
/**
* PT protocol the PDP is using
*/
- u_int8_t protocol;
+ uint8_t protocol;
/**
* PT port the PDP is using
*/
- u_int16_t port;
+ uint16_t port;
/**
* Encoded message
}
METHOD(pb_tnc_msg_t, process, status_t,
- private_pb_pdp_referral_msg_t *this, u_int32_t *offset)
+ private_pb_pdp_referral_msg_t *this, uint32_t *offset)
{
bio_reader_t *reader;
- u_int8_t reserved;
+ uint8_t reserved;
*offset = 0;
}
METHOD(pb_pdp_referral_msg_t, get_fqdn, chunk_t,
- private_pb_pdp_referral_msg_t *this, u_int8_t *protocol, u_int16_t *port)
+ private_pb_pdp_referral_msg_t *this, uint8_t *protocol, uint16_t *port)
{
if (protocol)
{
/**
* See header
*/
-pb_tnc_msg_t* pb_pdp_referral_msg_create_from_fqdn(chunk_t fqdn, u_int16_t port)
+pb_tnc_msg_t* pb_pdp_referral_msg_create_from_fqdn(chunk_t fqdn, uint16_t port)
{
pb_tnc_msg_t *msg;
bio_writer_t *writer;
* @param port PT port the PDP is listening on
* @return Fully Qualified Domain Name of PDP
*/
- chunk_t (*get_fqdn)(pb_pdp_referral_msg_t *this, u_int8_t *protocol,
- u_int16_t *port);
+ chunk_t (*get_fqdn)(pb_pdp_referral_msg_t *this, uint8_t *protocol,
+ uint16_t *port);
};
* @param fqdn Fully Qualified Domain Name of PDP
* @param port PT-TLS port the PDP is listening on
*/
-pb_tnc_msg_t* pb_pdp_referral_msg_create_from_fqdn(chunk_t fqdn, u_int16_t port);
+pb_tnc_msg_t* pb_pdp_referral_msg_create_from_fqdn(chunk_t fqdn, uint16_t port);
/**
* Create an unprocessed PB-PDP-Referral message from raw data
/**
* Type of TNC client authentication
*/
- u_int32_t auth_type;
+ uint32_t auth_type;
/**
* Mutual PB-TNC protocol enabled
this->transport = transport;
}
-METHOD(tnccs_t, get_auth_type, u_int32_t,
+METHOD(tnccs_t, get_auth_type, uint32_t,
private_tnccs_20_t *this)
{
return this->auth_type;
}
METHOD(tnccs_t, set_auth_type, void,
- private_tnccs_20_t *this, u_int32_t auth_type)
+ private_tnccs_20_t *this, uint32_t auth_type)
{
this->auth_type = auth_type;
}
METHOD(tnccs_t, get_pdp_server, chunk_t,
- private_tnccs_20_t *this, u_int16_t *port)
+ private_tnccs_20_t *this, uint16_t *port)
{
if (this->tnc_client)
{
/**
* PDP server port
*/
- u_int16_t pdp_port;
+ uint16_t pdp_port;
/**
* Mutual PB-TNC protocol enabled
void tnccs_20_handle_ietf_error_msg(pb_tnc_msg_t *msg, bool *fatal_error)
{
pb_error_msg_t *err_msg;
- u_int32_t vendor_id;
- u_int16_t error_code;
+ uint32_t vendor_id;
+ uint16_t error_code;
bool fatal;
err_msg = (pb_error_msg_t*)msg;
{
pb_pa_msg_t *pa_msg;
pen_type_t msg_subtype;
- u_int16_t imc_id, imv_id;
+ uint16_t imc_id, imv_id;
chunk_t msg_body;
bool excl;
enum_name_t *pa_subtype_names;
case PB_MSG_ASSESSMENT_RESULT:
{
pb_assessment_result_msg_t *assess_msg;
- u_int32_t result;
+ uint32_t result;
assess_msg = (pb_assessment_result_msg_t*)msg;
result = assess_msg->get_assessment_result(assess_msg);
{
pb_pdp_referral_msg_t *pdp_msg;
pen_type_t pdp_id_type;
- u_int8_t pdp_protocol;
+ uint8_t pdp_protocol;
pdp_msg = (pb_pdp_referral_msg_t*)msg;
pdp_id_type = pdp_msg->get_identifier_type(pdp_msg);
}
METHOD(tnccs_20_client_t, get_pdp_server, chunk_t,
- private_tnccs_20_client_t *this, u_int16_t *port)
+ private_tnccs_20_client_t *this, uint16_t *port)
{
*port = this->pdp_port;
* @param port PT-TLS port of the PDP server
* @return FQDN of PDP server
*/
- chunk_t (*get_pdp_server)(tnccs_20_client_t *this, u_int16_t *port);
+ chunk_t (*get_pdp_server)(tnccs_20_client_t *this, uint16_t *port);
};
{
pb_pa_msg_t *pa_msg;
pen_type_t msg_subtype;
- u_int16_t imc_id, imv_id;
+ uint16_t imc_id, imv_id;
chunk_t msg_body;
bool excl;
enum_name_t *pa_subtype_names;
{
pb_tnc_msg_t *msg;
identification_t *pdp_server;
- u_int16_t *pdp_port;
+ uint16_t *pdp_port;
tnc->imvs->notify_connection_change(tnc->imvs, this->connection_id,
TNC_CONNECTION_STATE_HANDSHAKE);
/* Send a PB-TNC TCG PDP Referral message if PDP is known */
pdp_server = (identification_t*)lib->get(lib, "pt-tls-server");
- pdp_port = (u_int16_t*)lib->get(lib, "pt-tls-port");
+ pdp_port = (uint16_t*)lib->get(lib, "pt-tls-port");
if (this->eap_transport && pdp_server && pdp_port)
{
/**
* Type of TNC client authentication
*/
- u_int32_t auth_type;
+ uint32_t auth_type;
/**
* Callback function to communicate recommendation (TNC Server only)
this->transport = transport;
}
-METHOD(tnccs_t, get_auth_type, u_int32_t,
+METHOD(tnccs_t, get_auth_type, uint32_t,
private_tnccs_dynamic_t *this)
{
return this->auth_type;
}
METHOD(tnccs_t, set_auth_type, void,
- private_tnccs_dynamic_t *this, u_int32_t auth_type)
+ private_tnccs_dynamic_t *this, uint32_t auth_type)
{
this->auth_type = auth_type;
}
METHOD(tnccs_t, get_pdp_server, chunk_t,
- private_tnccs_dynamic_t *this, u_int16_t *port)
+ private_tnccs_dynamic_t *this, uint16_t *port)
{
tnccs_t *tnccs = (tnccs_t*)this->tls;
*
* @return TNC Client authentication type
*/
- u_int32_t (*get_auth_type)(tnccs_t *this);
+ uint32_t (*get_auth_type)(tnccs_t *this);
/**
* Set type of TNC Client authentication
*
* @param auth_type TNC Client authentication type
*/
- void (*set_auth_type)(tnccs_t *this, u_int32_t auth_type);
+ void (*set_auth_type)(tnccs_t *this, uint32_t auth_type);
/**
* Get PDP server name and port number
* @param port PDP port number
* @return PDP server name
*/
- chunk_t (*get_pdp_server)(tnccs_t *this, u_int16_t *port);
+ chunk_t (*get_pdp_server)(tnccs_t *this, uint16_t *port);
/**
* Get a new reference to the TNCCS object.
tnccs_type_t type, tnccs_t *tnccs,
tnccs_send_message_t send_message,
bool *request_handshake_retry,
- u_int32_t max_msg_len,
+ uint32_t max_msg_len,
recommendations_t **recs);
/**
METHOD(tncif_identity_t, process, bool,
private_tncif_identity_t *this, bio_reader_t *reader)
{
- u_int8_t reserved;
- u_int32_t vendor_id, type;
+ uint8_t reserved;
+ uint32_t vendor_id, type;
chunk_t identity_value;
if (reader->remaining(reader) < TNCIF_IDENTITY_MIN_SIZE)
* terminate an IKE or CHILD SA
*/
static void terminate(private_control_controller_t *this, fast_request_t *r,
- bool ike, u_int32_t id)
+ bool ike, uint32_t id)
{
gateway_t *gateway;
enumerator_t *e;
}
if (action)
{
- u_int32_t id;
+ uint32_t id;
if (streq(action, "terminateike"))
{
}
METHOD(gateway_t, terminate, enumerator_t*,
- private_gateway_t *this, bool ike, u_int32_t id)
+ private_gateway_t *this, bool ike, uint32_t id)
{
char *str, *kind;
* @param id ID of the SA to terminate
* @return enumerator over control response XML children
*/
- enumerator_t* (*terminate)(gateway_t *this, bool ike, u_int32_t id);
+ enumerator_t* (*terminate)(gateway_t *this, bool ike, uint32_t id);
/**
* Initiate an IKE or a CHILD SA.
/**
* Client routine
*/
-static int client(char *address, u_int16_t port, char *identity)
+static int client(char *address, uint16_t port, char *identity)
{
pt_tls_client_t *assessment;
tls_t *tnccs;
DBG1(DBG_APP, "# bad protocol: %s=%s", key, value);
goto err;
}
- end->protocol = (u_int8_t)p;
+ end->protocol = (uint8_t)p;
}
}
if (streq(port, "%any"))
bool hostaccess;
bool allow_any;
char *updown;
- u_int16_t from_port;
- u_int16_t to_port;
- u_int8_t protocol;
+ uint16_t from_port;
+ uint16_t to_port;
+ uint8_t protocol;
char *sourceip;
char *dns;
};
time_t sa_ike_life_seconds;
time_t sa_ipsec_life_seconds;
time_t sa_rekey_margin;
- u_int64_t sa_ipsec_life_bytes;
- u_int64_t sa_ipsec_margin_bytes;
- u_int64_t sa_ipsec_life_packets;
- u_int64_t sa_ipsec_margin_packets;
+ uint64_t sa_ipsec_life_bytes;
+ uint64_t sa_ipsec_margin_bytes;
+ uint64_t sa_ipsec_life_packets;
+ uint64_t sa_ipsec_margin_packets;
unsigned long sa_keying_tries;
unsigned long sa_rekey_fuzz;
- u_int32_t reqid;
+ uint32_t reqid;
mark_t mark_in;
mark_t mark_out;
- u_int32_t replay_window;
- u_int32_t tfc;
+ uint32_t replay_window;
+ uint32_t tfc;
bool install_policy;
bool aggressive;
starter_end_t left, right;
char *cert_policy;
char *updown;
char *address;
- u_int16_t ikeport;
+ uint16_t ikeport;
char *sourceip;
char *dns;
char *subnets;
int hostaccess;
int tohost;
int allow_any;
- u_int8_t protocol;
- u_int16_t from_port;
- u_int16_t to_port;
+ uint8_t protocol;
+ uint16_t from_port;
+ uint16_t to_port;
};
typedef struct stroke_msg_t stroke_msg_t;
*/
struct stroke_msg_t {
/* length of this message with all strings */
- u_int16_t length;
+ uint16_t length;
/* type of the message */
enum {
int proxy_mode;
int install_policy;
int close_action;
- u_int32_t reqid;
- u_int32_t tfc;
- u_int8_t ikedscp;
+ uint32_t reqid;
+ uint32_t tfc;
+ uint8_t ikedscp;
crl_policy_t crl_policy;
int unique;
time_t ipsec_lifetime;
time_t ike_lifetime;
time_t margin;
- u_int64_t life_bytes;
- u_int64_t margin_bytes;
- u_int64_t life_packets;
- u_int64_t margin_packets;
+ uint64_t life_bytes;
+ uint64_t margin_bytes;
+ uint64_t life_packets;
+ uint64_t margin_packets;
unsigned long tries;
unsigned long fuzz;
} rekey;
char *peerid;
} ikeme;
struct {
- u_int32_t value;
- u_int32_t mask;
+ uint32_t value;
+ uint32_t mask;
} mark_in, mark_out;
stroke_end_t me, other;
- u_int32_t replay_window;
+ uint32_t replay_window;
} add_conn;
/* data for STR_ADD_CA */
} counters;
};
/* length of the string buffer */
- u_int16_t buflen;
+ uint16_t buflen;
/* string buffer */
char buffer[];
};
projects / people / ms / strongswan.git / commitdiff
