struct ipv4_prefix {
struct in_addr addr;
- unsigned int len;
+ uint8_t len;
};
struct ipv6_prefix {
struct in6_addr addr;
- unsigned int len;
+ uint8_t len;
};
struct ipv4_range {
}
static int
-create_client(int fd, struct sockaddr_storage *addr, u_int8_t rtr_version)
+create_client(int fd, struct sockaddr_storage *addr, uint8_t rtr_version)
{
struct client client;
int error;
* isn't the same as in the DB.
*/
int
-update_client(int fd, struct sockaddr_storage *addr, u_int8_t rtr_version)
+update_client(int fd, struct sockaddr_storage *addr, uint8_t rtr_version)
{
struct client *client;
client = get_client(addr);
struct in6_addr sin6;
} addr;
in_port_t sin_port;
- u_int8_t rtr_version;
+ uint8_t rtr_version;
};
int clients_db_init(void);
-int update_client(int, struct sockaddr_storage *, u_int8_t);
+int update_client(int, struct sockaddr_storage *, uint8_t);
size_t client_list(struct client **);
void clients_forget(int);
unsigned int vrps_check_interval;
/** Intervals use at RTR v1 End of data PDU **/
- u_int32_t refresh_interval;
- u_int32_t retry_interval;
- u_int32_t expire_interval;
+ uint32_t refresh_interval;
+ uint32_t retry_interval;
+ uint32_t expire_interval;
} server;
struct {
}, {
.id = 1002,
.name = "maximum-certificate-depth",
- .type = >_u_int,
+ .type = >_uint,
.offset = offsetof(struct rpki_config,
maximum_certificate_depth),
.doc = "Maximum allowable certificate chain length",
}, {
.id = 5003,
.name = "server.queue",
- .type = >_u_int,
+ .type = >_uint,
.offset = offsetof(struct rpki_config, server.queue),
.doc = "Maximum accepted client connections",
.min = 1,
}, {
.id = 5004,
.name = "server.vrps-check-interval",
- .type = >_u_int,
+ .type = >_uint,
.offset = offsetof(struct rpki_config, server.vrps_check_interval),
.doc = "Interval used to look for updates at VRPs location",
/*
}, {
.id = 5005,
.name = "server.rtr-interval.refresh",
- .type = >_u_int32,
+ .type = >_uint32,
.offset = offsetof(struct rpki_config, server.refresh_interval),
.doc = "Intervals use at RTR v1 End of data PDU",
.min = 1,
}, {
.id = 5006,
.name = "server.rtr-interval.retry",
- .type = >_u_int32,
+ .type = >_uint32,
.offset = offsetof(struct rpki_config, server.retry_interval),
.doc = "",
.min = 1,
}, {
.id = 5007,
.name = "server.rtr-interval.expire",
- .type = >_u_int32,
+ .type = >_uint32,
.offset = offsetof(struct rpki_config, server.expire_interval),
.doc = "",
.min = 600,
return rpki_config.server.vrps_check_interval;
}
-u_int32_t
+uint32_t
config_get_refresh_interval(void)
{
return rpki_config.server.refresh_interval;
}
-u_int32_t
+uint32_t
config_get_retry_interval(void)
{
return rpki_config.server.retry_interval;
}
-u_int32_t
+uint32_t
config_get_expire_interval(void)
{
return rpki_config.server.expire_interval;
#include "log.h"
static void
-print_u_int(struct option_field const *field, void *value)
+print_uint(struct option_field const *field, void *value)
{
pr_info("%s: %u", field->name, *((unsigned int *) value));
}
int
-parse_argv_u_int(struct option_field const *field, char const *str,
+parse_argv_uint(struct option_field const *field, char const *str,
void *result)
{
unsigned long parsed;
}
int
-parse_json_u_int(struct option_field const *opt, json_t *json, void *result)
+parse_json_uint(struct option_field const *opt, json_t *json, void *result)
{
json_int_t value;
return 0;
}
-const struct global_type gt_u_int = {
+const struct global_type gt_uint = {
.has_arg = required_argument,
.size = sizeof(unsigned int),
- .print = print_u_int,
- .parse.argv = parse_argv_u_int,
- .parse.json = parse_json_u_int,
+ .print = print_uint,
+ .parse.argv = parse_argv_uint,
+ .parse.json = parse_json_uint,
.arg_doc = "<unsigned integer>",
};
#include "config/types.h"
-extern const struct global_type gt_u_int;
+extern const struct global_type gt_uint;
-int parse_argv_u_int(struct option_field const *, char const *, void *);
-int parse_json_u_int(struct option_field const *, struct json_t *, void *);
+int parse_argv_uint(struct option_field const *, char const *, void *);
+int parse_json_uint(struct option_field const *, struct json_t *, void *);
#endif /* SRC_CONFIG_UINT_H_ */
#include "config/uint.h"
static void
-print_u_int32(struct option_field const *field, void *value)
+print_uint32(struct option_field const *field, void *value)
{
- pr_info("%s: %u", field->name, *((u_int32_t *) value));
+ pr_info("%s: %u", field->name, *((uint32_t *) value));
}
static int
-parse_argv_u_int32(struct option_field const *field, char const *str,
+parse_argv_uint32(struct option_field const *field, char const *str,
void *result)
{
unsigned int tmp;
int error;
- error = parse_argv_u_int(field, str, &tmp);
+ error = parse_argv_uint(field, str, &tmp);
if (error)
return error;
/* Range already validated (from field->min and field->max). */
- *((u_int32_t *) result) = tmp;
+ *((uint32_t *) result) = tmp;
return 0;
}
static int
-parse_json_u_int32(struct option_field const *opt, json_t *json, void *result)
+parse_json_uint32(struct option_field const *opt, json_t *json, void *result)
{
unsigned int tmp;
int error;
- error = parse_json_u_int(opt, json, &tmp);
+ error = parse_json_uint(opt, json, &tmp);
if (error)
return error;
/* Range already validated (from opt->min and opt->max). */
- *((u_int32_t *) result) = tmp;
+ *((uint32_t *) result) = tmp;
return 0;
}
-const struct global_type gt_u_int32 = {
+const struct global_type gt_uint32 = {
.has_arg = required_argument,
- .size = sizeof(u_int32_t),
- .print = print_u_int32,
- .parse.argv = parse_argv_u_int32,
- .parse.json = parse_json_u_int32,
+ .size = sizeof(uint32_t),
+ .print = print_uint32,
+ .parse.argv = parse_argv_uint32,
+ .parse.json = parse_json_uint32,
.arg_doc = "<32-bit unsigned integer>",
};
#include "config/types.h"
-extern const struct global_type gt_u_int32;
+extern const struct global_type gt_uint32;
#endif /* SRC_CONFIG_UINT32_H_ */
#include "vrps.h"
static int
-send_notify(int fd, u_int8_t rtr_version)
+send_notify(int fd, uint8_t rtr_version)
{
struct sender_common common;
- u_int32_t serial;
- u_int16_t session_id;
+ uint32_t serial;
+ uint16_t session_id;
serial = get_last_serial_number();
session_id = get_current_session_id(rtr_version);
}
int
-roa_handle_v4(u_int32_t asn, struct ipv4_prefix *prefix, u_int8_t max_length)
+roa_handle_v4(uint32_t asn, struct ipv4_prefix *prefix, uint8_t max_length)
{
return -ENOTIMPLEMENTED;
}
}
int
-roa_handle_v6(u_int32_t asn, struct ipv6_prefix *prefix, u_int8_t max_length)
+roa_handle_v6(uint32_t asn, struct ipv6_prefix *prefix, uint8_t max_length)
{
return -ENOTIMPLEMENTED;
}
int roa_traverse(struct rpki_uri const *, struct rpp *, STACK_OF(X509_CRL) *);
-int roa_handle_v4(u_int32_t, struct ipv4_prefix *, u_int8_t);
-int roa_handle_v6(u_int32_t, struct ipv6_prefix *, u_int8_t);
+int roa_handle_v4(uint32_t, struct ipv4_prefix *, uint8_t);
+int roa_handle_v6(uint32_t, struct ipv6_prefix *, uint8_t);
#endif /* SRC_OBJECT_ROA_H_ */
#include <sys/cdefs.h>
#include <sys/queue.h>
#include <sys/stat.h>
-#include <sys/types.h>
#include <sys/wait.h>
#include "config.h"
#include "log.h"
int
-err_pdu_send(int fd, u_int8_t version, u_int16_t code, void *err_pdu_header,
+err_pdu_send(int fd, uint8_t version, uint16_t code, void *err_pdu_header,
char const *message)
{
int error;
}
bool
-err_pdu_is_fatal(u_int16_t code)
+err_pdu_is_fatal(uint16_t code)
{
/* Only NO_DATA_AVAILABLE error isn't fatal */
return code != ERR_PDU_NO_DATA_AVAILABLE;
}
void
-err_pdu_log(u_int16_t code, char *message)
+err_pdu_log(uint16_t code, char *message)
{
char const *code_title;
#define SRC_RTR_ERR_PDU_H_
#include <stdbool.h>
-#include <sys/types.h>
+#include <stdint.h>
#define ERR_PDU_CORRUPT_DATA 0
#define ERR_PDU_INTERNAL_ERROR 1
#define ERR_PDU_UNEXPECTED_PROTO_VERSION 8
-int err_pdu_send(int, u_int8_t, u_int16_t, void *, char const *);
-bool err_pdu_is_fatal(u_int16_t);
-void err_pdu_log(u_int16_t, char *);
+int err_pdu_send(int, uint8_t, uint16_t, void *, char const *);
+bool err_pdu_is_fatal(uint16_t);
+void err_pdu_log(uint16_t, char *);
#endif /* SRC_RTR_ERR_PDU_H_ */
int
pdu_load(int fd, void **pdu, struct pdu_metadata const **metadata,
- u_int8_t *rtr_version)
+ uint8_t *rtr_version)
{
struct pdu_header header;
struct pdu_metadata const *meta;
error_report_from_stream(struct pdu_header *header, int fd, void *pdu_void)
{
struct error_report_pdu *pdu = pdu_void;
- u_int32_t sub_pdu_len; /* TODO use this for something */
- u_int8_t rtr_version;
+ uint32_t sub_pdu_len; /* TODO use this for something */
+ uint8_t rtr_version;
int error;
memcpy(&pdu->header, header, sizeof(*header));
};
struct pdu_metadata const *
-pdu_get_metadata(u_int8_t type)
+pdu_get_metadata(uint8_t type)
{
return (ARRAY_LEN(pdu_metadatas) <= type) ? NULL : pdu_metadatas[type];
}
#define PDU_TYPE_ERROR_REPORT 10
struct pdu_header {
- u_int8_t protocol_version;
- u_int8_t pdu_type;
+ uint8_t protocol_version;
+ uint8_t pdu_type;
union {
- u_int16_t session_id;
- u_int16_t reserved;
- u_int16_t error_code;
+ uint16_t session_id;
+ uint16_t reserved;
+ uint16_t error_code;
} m; /* Note: "m" stands for "meh." I have no idea what to call this. */
- u_int32_t length;
+ uint32_t length;
};
struct serial_notify_pdu {
struct pdu_header header;
- u_int32_t serial_number;
+ uint32_t serial_number;
};
struct serial_query_pdu {
struct pdu_header header;
- u_int32_t serial_number;
+ uint32_t serial_number;
};
struct reset_query_pdu {
struct ipv4_prefix_pdu {
struct pdu_header header;
- u_int8_t flags;
- u_int8_t prefix_length;
- u_int8_t max_length;
- u_int8_t zero;
+ uint8_t flags;
+ uint8_t prefix_length;
+ uint8_t max_length;
+ uint8_t zero;
struct in_addr ipv4_prefix;
- u_int32_t asn;
+ uint32_t asn;
};
struct ipv6_prefix_pdu {
struct pdu_header header;
- u_int8_t flags;
- u_int8_t prefix_length;
- u_int8_t max_length;
- u_int8_t zero;
+ uint8_t flags;
+ uint8_t prefix_length;
+ uint8_t max_length;
+ uint8_t zero;
struct in6_addr ipv6_prefix;
- u_int32_t asn;
+ uint32_t asn;
};
struct end_of_data_pdu {
struct pdu_header header;
- u_int32_t serial_number;
- u_int32_t refresh_interval;
- u_int32_t retry_interval;
- u_int32_t expire_interval;
+ uint32_t serial_number;
+ uint32_t refresh_interval;
+ uint32_t retry_interval;
+ uint32_t expire_interval;
};
struct cache_reset_pdu {
struct error_report_pdu {
struct pdu_header header;
- u_int32_t error_pdu_length;
+ uint32_t error_pdu_length;
void *erroneous_pdu;
- u_int32_t error_message_length;
+ uint32_t error_message_length;
rtr_char *error_message;
};
};
__BEGIN_DECLS
-int pdu_load(int, void **, struct pdu_metadata const **, u_int8_t *);
-struct pdu_metadata const *pdu_get_metadata(u_int8_t);
+int pdu_load(int, void **, struct pdu_metadata const **, uint8_t *);
+struct pdu_metadata const *pdu_get_metadata(uint8_t);
struct pdu_header *pdu_get_header(void *);
__END_DECLS
struct serial_query_pdu *received = pdu;
struct sender_common common;
int error, updates;
- u_int32_t current_serial;
- u_int16_t session_id;
- u_int8_t version;
+ uint32_t current_serial;
+ uint16_t session_id;
+ uint8_t version;
/*
* RFC 6810 and 8210:
{
struct reset_query_pdu *received = pdu;
struct sender_common common;
- u_int32_t current_serial;
- u_int16_t session_id;
- u_int8_t version;
+ uint32_t current_serial;
+ uint16_t session_id;
+ uint8_t version;
int updates;
version = received->header.protocol_version;
#define IPV6_PREFIX_LENGTH 24
void
-init_sender_common(struct sender_common *common, int fd, u_int8_t version,
- u_int16_t *session_id, u_int32_t *start_serial, u_int32_t *end_serial)
+init_sender_common(struct sender_common *common, int fd, uint8_t version,
+ uint16_t *session_id, uint32_t *start_serial, uint32_t *end_serial)
{
common->fd = fd;
common->version = version;
* Set all the header values, EXCEPT length field.
*/
static void
-set_header_values(struct pdu_header *header, u_int8_t version, u_int8_t type,
- u_int16_t reserved)
+set_header_values(struct pdu_header *header, uint8_t version, uint8_t type,
+ uint16_t reserved)
{
header->protocol_version = version;
header->pdu_type = type;
header->m.reserved = reserved;
}
-static u_int32_t
+static uint32_t
length_serial_notify_pdu(struct serial_notify_pdu *pdu)
{
return HEADER_LENGTH + sizeof(pdu->serial_number);
}
-static u_int32_t
+static uint32_t
length_ipvx_prefix_pdu(bool isv4)
{
return HEADER_LENGTH +
(isv4 ? IPV4_PREFIX_LENGTH : IPV6_PREFIX_LENGTH);
}
-static u_int32_t
+static uint32_t
length_end_of_data_pdu(struct end_of_data_pdu *pdu)
{
- u_int32_t len;
+ uint32_t len;
len = HEADER_LENGTH;
len += sizeof(pdu->serial_number);
return len;
}
-static u_int32_t
+static uint32_t
length_error_report_pdu(struct error_report_pdu *pdu)
{
return HEADER_LENGTH +
}
int
-send_error_report_pdu(int fd, u_int8_t version, u_int16_t code,
+send_error_report_pdu(int fd, uint8_t version, uint16_t code,
struct pdu_header *err_pdu_header, char const *message)
{
struct error_report_pdu pdu;
#ifndef SRC_RTR_PDU_SENDER_H_
#define SRC_RTR_PDU_SENDER_H_
-#include <sys/types.h>
#include "pdu.h"
struct sender_common {
int fd;
- u_int8_t version;
- u_int16_t *session_id;
- u_int32_t *start_serial;
- u_int32_t *end_serial;
+ uint8_t version;
+ uint16_t *session_id;
+ uint32_t *start_serial;
+ uint32_t *end_serial;
};
-void init_sender_common(struct sender_common *, int, u_int8_t, u_int16_t *,
- u_int32_t *, u_int32_t *);
+void init_sender_common(struct sender_common *, int, uint8_t, uint16_t *,
+ uint32_t *, uint32_t *);
int send_serial_notify_pdu(struct sender_common *);
int send_cache_reset_pdu(struct sender_common *);
int send_cache_response_pdu(struct sender_common *);
int send_payload_pdus(struct sender_common *);
int send_end_of_data_pdu(struct sender_common *);
-int send_error_report_pdu(int, u_int8_t, u_int16_t, struct pdu_header *,
+int send_error_report_pdu(int, uint8_t, uint16_t, struct pdu_header *,
char const *);
}
static size_t
-serialize_pdu_header(struct pdu_header *header, u_int16_t union_value,
- char *buf)
+serialize_pdu_header(struct pdu_header *header, uint16_t union_value, char *buf)
{
char *ptr;
#include "log.h"
static int read_exact(int, unsigned char *, size_t);
-static int read_and_waste(int, unsigned char *, size_t, u_int32_t);
+static int read_and_waste(int, unsigned char *, size_t, uint32_t);
static int get_octets(unsigned char);
static void place_null_character(rtr_char *, size_t);
}
int
-read_int8(int fd, u_int8_t *result)
+read_int8(int fd, uint8_t *result)
{
- return read_exact(fd, result, sizeof(u_int8_t));
+ return read_exact(fd, result, sizeof(uint8_t));
}
/** Big Endian. */
int
-read_int16(int fd, u_int16_t *result)
+read_int16(int fd, uint16_t *result)
{
unsigned char buffer[2];
int err;
if (err)
return err;
- *result = (((u_int16_t)buffer[0]) << 8) | ((u_int16_t)buffer[1]);
+ *result = (((uint16_t)buffer[0]) << 8) | ((uint16_t)buffer[1]);
return 0;
}
/** Big Endian. */
int
-read_int32(int fd, u_int32_t *result)
+read_int32(int fd, uint32_t *result)
{
unsigned char buffer[4];
int err;
if (err)
return err;
- *result = (((u_int32_t)buffer[0]) << 24)
- | (((u_int32_t)buffer[1]) << 16)
- | (((u_int32_t)buffer[2]) << 8)
- | (((u_int32_t)buffer[3]) );
+ *result = (((uint32_t)buffer[0]) << 24)
+ | (((uint32_t)buffer[1]) << 16)
+ | (((uint32_t)buffer[2]) << 8)
+ | (((uint32_t)buffer[3]) );
return 0;
}
* It is required that @str_len <= @total_len.
*/
static int
-read_and_waste(int fd, unsigned char *str, size_t str_len, u_int32_t total_len)
+read_and_waste(int fd, unsigned char *str, size_t str_len, uint32_t total_len)
{
#define TLEN 1024 /* "Trash length" */
unsigned char *trash;
read_string(int fd, rtr_char **result)
{
/* Actual string length claimed by the PDU, in octets. */
- u_int32_t full_length32; /* Excludes the null chara */
- u_int64_t full_length64; /* Includes the null chara */
+ uint32_t full_length32; /* Excludes the null chara */
+ uint64_t full_length64; /* Includes the null chara */
/*
* Actual length that we allocate. Octets.
* This exists because there might be value in truncating the string;
if (err)
return err;
- full_length64 = ((u_int64_t) full_length32) + 1;
+ full_length64 = ((uint64_t) full_length32) + 1;
alloc_length = (full_length64 > 4096) ? 4096 : full_length64;
str = malloc(alloc_length);
typedef char rtr_char;
__BEGIN_DECLS
-int read_int8(int, u_int8_t *);
-int read_int16(int, u_int16_t *);
-int read_int32(int, u_int32_t *);
+int read_int8(int, uint8_t *);
+int read_int16(int, uint16_t *);
+int read_int32(int, uint32_t *);
int read_in_addr(int, struct in_addr *);
int read_in6_addr(int, struct in6_addr *);
int read_string(int, rtr_char **);
#include "primitive_writer.h"
char *
-write_int8(char *buf, u_int8_t value)
+write_int8(char *buf, uint8_t value)
{
buf[0] = value;
return buf + 1;
/** Big Endian. */
char *
-write_int16(char *buf, u_int16_t value)
+write_int16(char *buf, uint16_t value)
{
buf[0] = value >> 8;
buf[1] = value;
/** Big Endian. */
char *
-write_int32(char *buf, u_int32_t value)
+write_int32(char *buf, uint32_t value)
{
buf[0] = value >> 24;
buf[1] = value >> 16;
#include <netinet/in.h>
__BEGIN_DECLS
-char *write_int8(char *, u_int8_t);
-char *write_int16(char *, u_int16_t);
-char *write_int32(char *, u_int32_t);
+char *write_int8(char *, uint8_t);
+char *write_int16(char *, uint16_t);
+char *write_int32(char *, uint32_t);
char *write_in_addr(char *, struct in_addr);
char *write_in6_addr(char *, struct in6_addr);
__END_DECLS
struct pdu_metadata const *meta;
void *pdu;
int err;
- u_int8_t rtr_version;
+ uint8_t rtr_version;
memcpy(¶m, param_void, sizeof(param));
ARRAY_LIST(vrps, struct vrp)
struct delta {
- u_int32_t serial;
+ uint32_t serial;
struct vrps vrps;
};
struct delta base_db;
/** ROA changes over time */
struct deltasdb deltas_db;
- u_int32_t current_serial;
- u_int16_t v0_session_id;
- u_int16_t v1_session_id;
+ uint32_t current_serial;
+ uint16_t v0_session_id;
+ uint16_t v1_session_id;
time_t last_modified_date;
} state;
/* Get the bits that'll fit in session_id */
shift = sizeof(time_t) - sizeof(state.v0_session_id);
- state.v0_session_id = (u_int16_t)((time(NULL) << shift) >> shift);
+ state.v0_session_id = (uint16_t)((time(NULL) << shift) >> shift);
/* Minus 1 to prevent same ID */
state.v1_session_id = state.v0_session_id - 1;
}
static void
-init_vrp (struct vrp *vrp, u_int32_t asn, u_int8_t prefix_length,
- u_int8_t max_prefix_length)
+init_vrp (struct vrp *vrp, uint32_t asn, uint8_t prefix_length,
+ uint8_t max_prefix_length)
{
vrp->asn = asn;
vrp->prefix_length = prefix_length;
}
struct vrp
-create_vrp4(u_int32_t asn, struct in_addr ipv4_prefix, u_int8_t prefix_length,
- u_int8_t max_prefix_length)
+create_vrp4(uint32_t asn, struct in_addr ipv4_prefix, uint8_t prefix_length,
+ uint8_t max_prefix_length)
{
struct vrp result;
}
struct vrp
-create_vrp6(u_int32_t asn, struct in6_addr ipv6_prefix, u_int8_t prefix_length,
- u_int8_t max_prefix_length)
+create_vrp6(uint32_t asn, struct in6_addr ipv6_prefix, uint8_t prefix_length,
+ uint8_t max_prefix_length)
{
struct vrp result;
* DIFF_AVAILABLE -> There are diffs between SERIAL and the last DB serial
*/
int
-deltas_db_status(u_int32_t *serial)
+deltas_db_status(uint32_t *serial)
{
struct delta *delta;
int result;
* received values.
*/
unsigned int
-get_vrps_delta(u_int32_t *start_serial, u_int32_t *end_serial,
+get_vrps_delta(uint32_t *start_serial, uint32_t *end_serial,
struct vrp **result)
{
struct delta *delta1;
sem_post(&wlock);
}
-u_int32_t
+uint32_t
get_last_serial_number(void)
{
- u_int32_t serial;
+ uint32_t serial;
read_lock(&rlock, &wlock, &rcounter);
serial = state.current_serial - 1;
return serial;
}
-u_int16_t
-get_current_session_id(u_int8_t rtr_version)
+uint16_t
+get_current_session_id(uint8_t rtr_version)
{
/* Semaphore isn't needed since this value is set at initialization */
if (rtr_version == 1)
#define DIFF_AVAILABLE 1
struct vrp {
- u_int32_t asn;
+ uint32_t asn;
union {
struct in_addr ipv4;
struct in6_addr ipv6;
} prefix;
- u_int8_t prefix_length;
- u_int8_t max_prefix_length;
- u_int8_t addr_fam;
- u_int8_t flags;
+ uint8_t prefix_length;
+ uint8_t max_prefix_length;
+ uint8_t addr_fam;
+ uint8_t flags;
};
int deltas_db_init(void);
-struct vrp create_vrp4(u_int32_t, struct in_addr, u_int8_t, u_int8_t);
-struct vrp create_vrp6(u_int32_t, struct in6_addr, u_int8_t, u_int8_t);
+struct vrp create_vrp4(uint32_t, struct in_addr, uint8_t, uint8_t);
+struct vrp create_vrp6(uint32_t, struct in6_addr, uint8_t, uint8_t);
int deltas_db_create_delta(struct vrp *, unsigned int);
-int deltas_db_status(u_int32_t *);
+int deltas_db_status(uint32_t *);
-unsigned int get_vrps_delta(u_int32_t *, u_int32_t *, struct vrp **);
+unsigned int get_vrps_delta(uint32_t *, uint32_t *, struct vrp **);
void deltas_db_destroy(void);
void set_vrps_last_modified_date(time_t);
-u_int32_t get_last_serial_number(void);
-u_int16_t get_current_session_id(u_int8_t);
+uint32_t get_last_serial_number(void);
+uint16_t get_current_session_id(uint8_t);
time_t get_vrps_last_modified_date(void);
#endif /* SRC_VRPS_H_ */
struct thread_param {
int fd;
- u_int32_t msg_size;
+ uint32_t msg_size;
int err;
};
* of the @WRITER_PATTERN pattern repeatedly.
*/
static void
-validate_massive_string(u_int32_t expected_len, rtr_char *str)
+validate_massive_string(uint32_t expected_len, rtr_char *str)
{
size_t actual_len;
rtr_char *pattern;
* contains the first @return_length characters.
*/
static void
-test_massive_string(u_int32_t return_length, u_int32_t full_string_length)
+test_massive_string(uint32_t return_length, uint32_t full_string_length)
{
int fd[2];
pthread_t writer_thread;
projects / thirdparty / FORT-validator.git / commitdiff
