typedef enum ike_cfg_match_t {
MATCH_NONE = 0x00,
MATCH_ANY = 0x01,
- MATCH_ME = 0x04,
+ MATCH_ME = 0x04,
MATCH_OTHER = 0x08,
} ike_cfg_match_t;
*/
enum cert_policy_t {
/** always send certificates, even when not requested */
- CERT_ALWAYS_SEND = 0,
+ CERT_ALWAYS_SEND = 0,
/** send certificate upon cert request */
- CERT_SEND_IF_ASKED = 1,
+ CERT_SEND_IF_ASKED = 1,
/** never send a certificate, even when requested */
- CERT_NEVER_SEND = 2,
+ CERT_NEVER_SEND = 2,
};
/**
*
* The string is in the same form as a in the ipsec.conf file.
* E.g.: aes128-sha2_256-modp2048
- * 3des-md5
+ * 3des-md5
* An additional '!' at the end of the string forces this proposal,
* without it the peer may choose another algorithm we support.
*
* printf hook function for proposal_t.
*
* Arguments are:
- * proposal_t *proposal
+ * proposal_t *proposal
* With the #-specifier, arguments are:
- * linked_list_t *list containing proposal_t*
+ * linked_list_t *list containing proposal_t*
*/
int proposal_printf_hook(char *dst, size_t len, printf_hook_spec_t *spec,
const void *const *args);
/**
* A range of IPv4 addresses, represented by two four (4) octet
- * values. The first value is the beginning IPv4 address
- * (inclusive) and the second value is the ending IPv4 address
- * (inclusive). All addresses falling between the two specified
- * addresses are considered to be within the list.
- */
+ * values. The first value is the beginning IPv4 address
+ * (inclusive) and the second value is the ending IPv4 address
+ * (inclusive). All addresses falling between the two specified
+ * addresses are considered to be within the list.
+ */
TS_IPV4_ADDR_RANGE = 7,
/**
* A range of IPv6 addresses, represented by two sixteen (16)
- * octet values. The first value is the beginning IPv6 address
- * (inclusive) and the second value is the ending IPv6 address
- * (inclusive). All addresses falling between the two specified
- * addresses are considered to be within the list.
+ * octet values. The first value is the beginning IPv6 address
+ * (inclusive) and the second value is the ending IPv6 address
+ * (inclusive). All addresses falling between the two specified
+ * addresses are considered to be within the list.
*/
TS_IPV6_ADDR_RANGE = 8
};
* printf hook function for traffic_selector_t.
*
* Arguments are:
- * traffic_selector_t *ts
+ * traffic_selector_t *ts
* With the #-specifier, arguments are:
- * linked_list_t *list containing traffic_selector_t*
+ * linked_list_t *list containing traffic_selector_t*
*/
int traffic_selector_printf_hook(char *dst, size_t len, printf_hook_spec_t *spec,
const void *const *args);
*/
static enumerator_t* create_private_enumerator(
private_credential_manager_t *this,
- key_type_t key, identification_t *keyid)
+ key_type_t key, identification_t *keyid)
{
private_data_t *data;
if (this->cache->issued_by(this->cache, subject, issuer))
{
DBG1(DBG_CFG, " ocsp response correctly signed by \"%Y\"",
- issuer->get_subject(issuer));
+ issuer->get_subject(issuer));
verified = TRUE;
break;
}
* validate a x509 certificate using OCSP
*/
static cert_validation_t check_ocsp(private_credential_manager_t *this,
- x509_t *subject, x509_t *issuer,
- auth_cfg_t *auth)
+ x509_t *subject, x509_t *issuer,
+ auth_cfg_t *auth)
{
enumerator_t *enumerator;
cert_validation_t valid = VALIDATION_SKIPPED;
void (*remove_set)(credential_manager_t *this, credential_set_t *set);
/**
- * Destroy a credential_manager instance.
- */
- void (*destroy)(credential_manager_t *this);
+ * Destroy a credential_manager instance.
+ */
+ void (*destroy)(credential_manager_t *this);
};
/**
credential_set_t set;
/**
- * Destroy a auth_cfg_wrapper instance.
- */
- void (*destroy)(auth_cfg_wrapper_t *this);
+ * Destroy a auth_cfg_wrapper instance.
+ */
+ void (*destroy)(auth_cfg_wrapper_t *this);
};
/**
credential_set_t set;
/**
- * Destroy a ocsp_response_wrapper instance.
- */
- void (*destroy)(ocsp_response_wrapper_t *this);
+ * Destroy a ocsp_response_wrapper instance.
+ */
+ void (*destroy)(ocsp_response_wrapper_t *this);
};
/**
switch (c)
{
case EOF:
- break;
+ break;
case 'h':
usage(NULL);
break;
switch (this->attribute_type)
{
- case INTERNAL_IP4_ADDRESS:
- case INTERNAL_IP4_NETMASK:
+ case INTERNAL_IP4_ADDRESS:
+ case INTERNAL_IP4_NETMASK:
case INTERNAL_IP4_DNS:
case INTERNAL_IP4_NBNS:
case INTERNAL_ADDRESS_EXPIRY:
NO_NATS_ALLOWED = 16402,
/* repeated authentication extension, RFC4478 */
AUTH_LIFETIME = 16403,
- /* multiple authentication exchanges, RFC 4739 */
+ /* multiple authentication exchanges, RFC 4739 */
MULTIPLE_AUTH_SUPPORTED = 16404,
ANOTHER_AUTH_FOLLOWS = 16405,
/* draft-eronen-ipsec-ikev2-eap-auth, not assigned by IANA yet */
* @param encap current use of UDP encapsulation
* @param new_encap new use of UDP encapsulation
* @return SUCCESS if operation completed, NOT_SUPPORTED if
- * the kernel interface can't update the SA
+ * the kernel interface can't update the SA
*/
status_t (*update_sa)(kernel_interface_t *this,
u_int32_t spi, protocol_id_t protocol, u_int16_t cpi,
* @param encap current use of UDP encapsulation
* @param new_encap new use of UDP encapsulation
* @return SUCCESS if operation completed, NOT_SUPPORTED if
- * the kernel interface can't update the SA
+ * the kernel interface can't update the SA
*/
status_t (*update_sa)(kernel_ipsec_t *this,
u_int32_t spi, protocol_id_t protocol, u_int16_t cpi,
* find out wich key was used for cookie creation. Further, we can set a
* lifetime for the cookie, which allows us to reuse the secret for a longer
* time.
- * COOKIE = time | sha1( IPi | SPIi | time | secret )
+ * COOKIE = time | sha1( IPi | SPIi | time | secret )
*
* The secret is changed after a certain amount of cookies sent. The old
* secret is stored to allow a clean migration between secret changes.
* PAM conv callback function
*/
static int auth_conv(int num_msg, const struct pam_message **msg,
- struct pam_response **resp, char *password)
+ struct pam_response **resp, char *password)
{
struct pam_response *response;
*/
static bool authenticate(char *service, char *user, char *password)
{
- pam_handle_t *pamh = NULL;
+ pam_handle_t *pamh = NULL;
static struct pam_conv conv;
- int ret;
+ int ret;
conv.conv = (void*)auth_conv;
conv.appdata_ptr = password;
* process an EAP-SIM/Response/Challenge message
*/
static status_t server_process_challenge(private_eap_sim_t *this,
- eap_payload_t *in, eap_payload_t **out)
+ eap_payload_t *in, eap_payload_t **out)
{
chunk_t message, data;
sim_attribute_t attribute;
chunk = ip->get_address(ip);
- hdr = (struct nlmsghdr*)request;
+ hdr = (struct nlmsghdr*)request;
hdr->nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK | flags;
hdr->nlmsg_type = nlmsg_type;
hdr->nlmsg_len = NLMSG_LENGTH(sizeof(struct ifaddrmsg));
msg = (struct ifaddrmsg*)NLMSG_DATA(hdr);
- msg->ifa_family = ip->get_family(ip);
- msg->ifa_flags = 0;
- msg->ifa_prefixlen = 8 * chunk.len;
- msg->ifa_scope = RT_SCOPE_UNIVERSE;
- msg->ifa_index = if_index;
+ msg->ifa_family = ip->get_family(ip);
+ msg->ifa_flags = 0;
+ msg->ifa_prefixlen = 8 * chunk.len;
+ msg->ifa_scope = RT_SCOPE_UNIVERSE;
+ msg->ifa_index = if_index;
netlink_add_attribute(hdr, IFA_LOCAL, chunk, sizeof(request));
host_t *host;
/* The Linux 2.6 kernel does not set the protocol and port information
- * in the src and dst sadb_address extensions of the SADB_ACQUIRE message.
- */
+ * in the src and dst sadb_address extensions of the SADB_ACQUIRE message.
+ */
host = host_create_from_sockaddr((sockaddr_t*)&address[1]) ;
ts = traffic_selector_create_from_subnet(host, address->sadb_address_prefixlen,
address->sadb_address_proto, host->get_port(host));
*/
static void destroy(private_medcli_creds_t *this)
{
- free(this);
+ free(this);
}
/**
*/
static void destroy(private_medsrv_creds_t *this)
{
- free(this);
+ free(this);
}
/**
if (found)
{
key = g_strdup_printf ("%s/%s/%s", found,
- NM_SETTING_VPN_SETTING_NAME, "method");
+ NM_SETTING_VPN_SETTING_NAME, "method");
method = gconf_client_get_string(client, key, NULL);
g_free(found);
g_free(key);
str = (char *) gtk_entry_get_text (GTK_ENTRY (widget));
if (!str || !strlen (str)) {
g_set_error (error,
- STRONGSWAN_PLUGIN_UI_ERROR,
- STRONGSWAN_PLUGIN_UI_ERROR_INVALID_PROPERTY,
- "address");
+ STRONGSWAN_PLUGIN_UI_ERROR,
+ STRONGSWAN_PLUGIN_UI_ERROR_INVALID_PROPERTY,
+ "address");
return FALSE;
}
return TRUE;
static gboolean
update_connection (NMVpnPluginUiWidgetInterface *iface,
- NMConnection *connection,
- GError **error)
+ NMConnection *connection,
+ GError **error)
{
StrongswanPluginUiWidget *self = STRONGSWAN_PLUGIN_UI_WIDGET (iface);
StrongswanPluginUiWidgetPrivate *priv = STRONGSWAN_PLUGIN_UI_WIDGET_GET_PRIVATE (self);
static gboolean
save_secrets (NMVpnPluginUiWidgetInterface *iface,
- NMConnection *connection, GError **error)
+ NMConnection *connection, GError **error)
{
/* no secrets to save */
return TRUE;
priv->xml = glade_xml_new (glade_file, "strongswan-vbox", GETTEXT_PACKAGE);
if (priv->xml == NULL) {
g_set_error (error, STRONGSWAN_PLUGIN_UI_ERROR, 0,
- "could not load required resources at %s", glade_file);
+ "could not load required resources at %s", glade_file);
g_free (glade_file);
g_object_unref (object);
return NULL;
if (!address || !*address)
{
g_set_error(err, NM_VPN_PLUGIN_ERROR, NM_VPN_PLUGIN_ERROR_BAD_ARGUMENTS,
- "Gateway address missing.");
+ "Gateway address missing.");
return FALSE;
}
str = nm_setting_vpn_get_data_item(vpn, "virtual");
if (!cert)
{
g_set_error(err, NM_VPN_PLUGIN_ERROR, NM_VPN_PLUGIN_ERROR_BAD_ARGUMENTS,
- "Loading gateway certificate failed.");
+ "Loading gateway certificate failed.");
return FALSE;
}
x509 = (x509_t*)cert;
charon->ike_sa_manager->checkin_and_destroy(charon->ike_sa_manager, ike_sa);
g_set_error(err, NM_VPN_PLUGIN_ERROR, NM_VPN_PLUGIN_ERROR_LAUNCH_FAILED,
- "Initiating failed.");
+ "Initiating failed.");
return FALSE;
}
charon->ike_sa_manager->checkin(charon->ike_sa_manager, ike_sa);
{
/* <query> */
xmlTextWriterStartElement(writer, "query");
- while (xmlTextReaderRead(reader))
- {
+ while (xmlTextReaderRead(reader))
+ {
if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT)
{
if (streq(xmlTextReaderConstName(reader), "ikesalist"))
{
/* <control> */
xmlTextWriterStartElement(writer, "control");
- while (xmlTextReaderRead(reader))
- {
+ while (xmlTextReaderRead(reader))
+ {
if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT)
{
if (streq(xmlTextReaderConstName(reader), "ikesaterminate"))
}
/* read message type and id */
- while (xmlTextReaderRead(reader))
- {
+ while (xmlTextReaderRead(reader))
+ {
if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT &&
streq(xmlTextReaderConstName(reader), "message"))
{
type = xmlTextReaderGetAttribute(reader, "type");
break;
}
- }
+ }
- /* process message */
- if (id && type)
+ /* process message */
+ if (id && type)
{
- if (streq(type, "request"))
- {
- request(reader, id, fd);
- }
- else
- {
- /* response(reader, id) */
- }
- }
+ if (streq(type, "request"))
+ {
+ request(reader, id, fd);
+ }
+ else
+ {
+ /* response(reader, id) */
+ }
+ }
xmlFreeTextReader(reader);
return JOB_REQUEUE_FAIR;;
}
attribute_provider_t provider;
/**
- * Destroy a sql_attribute instance.
- */
- void (*destroy)(sql_attribute_t *this);
+ * Destroy a sql_attribute instance.
+ */
+ void (*destroy)(sql_attribute_t *this);
};
/**
void (*check_for_hash_and_url)(stroke_ca_t *this, certificate_t* cert);
/**
- * Destroy a stroke_ca instance.
- */
- void (*destroy)(stroke_ca_t *this);
+ * Destroy a stroke_ca instance.
+ */
+ void (*destroy)(stroke_ca_t *this);
};
/**
void (*del)(stroke_config_t *this, stroke_msg_t *msg);
/**
- * Destroy a stroke_config instance.
- */
- void (*destroy)(stroke_config_t *this);
+ * Destroy a stroke_config instance.
+ */
+ void (*destroy)(stroke_config_t *this);
};
/**
struct stroke_socket_t {
/**
- * Destroy a stroke_socket instance.
- */
- void (*destroy)(stroke_socket_t *this);
+ * Destroy a stroke_socket instance.
+ */
+ void (*destroy)(stroke_socket_t *this);
};
/**
* @param reqid reqid of the CHILD_SA to acquire
* @param src_ts source traffic selector to be used in the policy
* @param dst_ts destination traffic selector to be used in the policy
- * @param dir direction of the policy (in|out)
- * @param local local host address to be used in the IKE_SA
- * @param remote remote host address to be used in the IKE_SA
+ * @param dir direction of the policy (in|out)
+ * @param local local host address to be used in the IKE_SA
+ * @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,
- traffic_selector_t *src_ts,
- traffic_selector_t *dst_ts,
- policy_dir_t dir,
- host_t *local, host_t *remote);
+ traffic_selector_t *src_ts, traffic_selector_t *dst_ts,
+ policy_dir_t dir, host_t *local, host_t *remote);
#endif /** MIGRATE_JOB_H_ @}*/
identification_t *peer);
/**
- * Destroy a eap_manager instance.
- */
- void (*destroy)(eap_manager_t *this);
+ * Destroy a eap_manager instance.
+ */
+ void (*destroy)(eap_manager_t *this);
};
/**
/* MIPv6 proxy transport mode sets SA endpoints to TS hosts */
if (config->get_mode(config) == MODE_TRANSPORT &&
- config->use_proxy_mode(config))
+ config->use_proxy_mode(config))
{
ts_type_t type;
int family;
u_int64_t priority;
/** local endpoint */
- host_t *local;
+ host_t *local;
- /** remote endpoint */
- host_t *remote;
+ /** remote endpoint */
+ host_t *remote;
- /** state */
- check_state_t state;
+ /** state */
+ check_state_t state;
- /** number of retransmissions */
- u_int32_t retransmitted;
+ /** number of retransmissions */
+ u_int32_t retransmitted;
- /** the generated packet */
- packet_t *packet;
+ /** the generated packet */
+ packet_t *packet;
};
/**
static void endpoint_pair_destroy(endpoint_pair_t *this)
{
DESTROY_IF(this->local);
- DESTROY_IF(this->remote);
- DESTROY_IF(this->packet);
+ DESTROY_IF(this->remote);
+ DESTROY_IF(this->packet);
free(this);
}
/** connect id */
chunk_t connect_id;
- /** list of endpoint pairs */
- linked_list_t *pairs;
+ /** list of endpoint pairs */
+ linked_list_t *pairs;
- /** pairs queued for triggered checks */
- linked_list_t *triggered;
+ /** pairs queued for triggered checks */
+ linked_list_t *triggered;
- /** state */
- check_state_t state;
+ /** state */
+ check_state_t state;
- /** TRUE if this is the initiator */
+ /** TRUE if this is the initiator */
bool is_initiator;
/** TRUE if the initiator is finishing the checks */
this->responder.id = responder->clone(responder);
this->responder.key = chunk_empty;
- this->responder.endpoints = NULL;
+ this->responder.endpoints = NULL;
- this->pairs = linked_list_create();
- this->triggered = linked_list_create();
- this->state = CHECK_NONE;
- this->is_initiator = is_initiator;
- this->is_finishing = FALSE;
+ this->pairs = linked_list_create();
+ this->triggered = linked_list_create();
+ this->state = CHECK_NONE;
+ this->is_initiator = is_initiator;
+ this->is_finishing = FALSE;
return this;
}
/** raw endpoint payload (to verify the signature) */
chunk_t endpoint_raw;
- /** connect auth */
- chunk_t auth;
+ /** connect auth */
+ chunk_t auth;
};
/**
*/
struct peer_t {
/** id of the peer */
- identification_t *id;
+ identification_t *id;
/** sa id of the peer, NULL if offline */
- ike_sa_id_t *ike_sa_id;
+ ike_sa_id_t *ike_sa_id;
- /** list of peer ids that reuested this peer */
- linked_list_t *requested_by;
+ /** list of peer ids that reuested this peer */
+ linked_list_t *requested_by;
};
/**
static void peer_destroy(peer_t *this)
{
DESTROY_IF(this->id);
- DESTROY_IF(this->ike_sa_id);
- this->requested_by->destroy_offset(this->requested_by, offsetof(identification_t, destroy));
+ DESTROY_IF(this->ike_sa_id);
+ this->requested_by->destroy_offset(this->requested_by, offsetof(identification_t, destroy));
free(this);
}
/* clone everything */
this->id = id->clone(id);
- this->ike_sa_id = ike_sa_id ? ike_sa_id->clone(ike_sa_id) : NULL;
- this->requested_by = linked_list_create();
+ this->ike_sa_id = ike_sa_id ? ike_sa_id->clone(ike_sa_id) : NULL;
+ this->requested_by = linked_list_create();
return this;
}
if (ioctl(tap, TUNSETIFF, &ifr) < 0 ||
ioctl(tap, TUNSETPERSIST, 1) < 0 ||
ioctl(tap, TUNSETOWNER, 0))
- {
+ {
DBG1("creating new tap device failed: %m");
close(tap);
return NULL;
- }
+ }
close(tap);
return strdup(ifr.ifr_name);
}
}
}
enumerator->destroy(enumerator);
- gtk_main_quit();
+ gtk_main_quit();
}
static void error_dialog(char *msg)
notebook = gtk_notebook_new();
g_object_set(G_OBJECT(notebook), "homogeneous", TRUE, NULL);
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook), GTK_POS_BOTTOM);
- gtk_container_add(GTK_CONTAINER(vbox), notebook);
+ gtk_container_add(GTK_CONTAINER(vbox), notebook);
/* Dumm menu */
menu = gtk_menu_new();
typedef struct mconsole_notify mconsole_notify;
/** mconsole notify message */
struct mconsole_notify {
- u_int32_t magic;
- u_int32_t version;
- enum {
+ u_int32_t magic;
+ u_int32_t version;
+ enum {
MCONSOLE_SOCKET,
MCONSOLE_PANIC,
MCONSOLE_HANG,
MCONSOLE_USER_NOTIFY,
- } type;
- u_int32_t len;
- char data[MCONSOLE_MAX_DATA];
+ } type;
+ u_int32_t len;
+ char data[MCONSOLE_MAX_DATA];
};
/**
this->context_constructor = constructor;
pthread_mutex_init(&this->mutex, NULL);
this->param = param;
- this->fd = 0;
- this->timeout = timeout;
- this->debug = debug;
- this->threads = NULL;
+ this->fd = 0;
+ this->timeout = timeout;
+ this->debug = debug;
+ this->threads = NULL;
- FCGX_Init();
+ FCGX_Init();
- if (socket)
- {
+ if (socket)
+ {
unlink(socket);
this->fd = FCGX_OpenSocket(socket, 10);
}
static void init(void)
{
cgiwrap_init_emu(NULL, read_cb, writef_cb, write_cb,
- getenv_cb, putenv_cb, iterenv_cb);
+ getenv_cb, putenv_cb, iterenv_cb);
pthread_key_create(&this_key, NULL);
}
param[i] = strdupa(start);
if (run_filter(this, request, param[0], param[1], param[2], param[3],
- param[4], param[5]))
+ param[4], param[5]))
{
enumerator = this->controllers->create_enumerator(this->controllers);
while (enumerator->enumerate(enumerator, ¤t))
{
if (--object.len == 0 || oid_names[oid].down == 0)
{
- return oid; /* found terminal symbol */
+ return oid; /* found terminal symbol */
}
else
{
* ASN.1 definition of an algorithmIdentifier
*/
static const asn1Object_t algorithmIdentifierObjects[] = {
- { 0, "algorithmIdentifier", ASN1_SEQUENCE, ASN1_NONE }, /* 0 */
- { 1, "algorithm", ASN1_OID, ASN1_BODY }, /* 1 */
+ { 0, "algorithmIdentifier", ASN1_SEQUENCE, ASN1_NONE }, /* 0 */
+ { 1, "algorithm", ASN1_OID, ASN1_BODY }, /* 1 */
{ 1, "parameters", ASN1_EOC, ASN1_RAW|ASN1_OPT }, /* 2 */
- { 1, "end opt", ASN1_EOC, ASN1_END }, /* 3 */
- { 0, "exit", ASN1_EOC, ASN1_EXIT }
+ { 1, "end opt", ASN1_EOC, ASN1_END }, /* 3 */
+ { 0, "exit", ASN1_EOC, ASN1_EXIT }
};
#define ALGORITHM_ID_ALG 1
#define ALGORITHM_ID_PARAMETERS 2
* Definition of some primitive ASN1 types
*/
typedef enum {
- ASN1_EOC = 0x00,
- ASN1_BOOLEAN = 0x01,
- ASN1_INTEGER = 0x02,
- ASN1_BIT_STRING = 0x03,
- ASN1_OCTET_STRING = 0x04,
- ASN1_NULL = 0x05,
- ASN1_OID = 0x06,
- ASN1_ENUMERATED = 0x0A,
- ASN1_UTF8STRING = 0x0C,
- ASN1_NUMERICSTRING = 0x12,
- ASN1_PRINTABLESTRING = 0x13,
- ASN1_T61STRING = 0x14,
- ASN1_VIDEOTEXSTRING = 0x15,
- ASN1_IA5STRING = 0x16,
- ASN1_UTCTIME = 0x17,
- ASN1_GENERALIZEDTIME = 0x18,
- ASN1_GRAPHICSTRING = 0x19,
- ASN1_VISIBLESTRING = 0x1A,
- ASN1_GENERALSTRING = 0x1B,
- ASN1_UNIVERSALSTRING = 0x1C,
- ASN1_BMPSTRING = 0x1E,
-
- ASN1_CONSTRUCTED = 0x20,
-
- ASN1_SEQUENCE = 0x30,
- ASN1_SET = 0x31,
-
- ASN1_CONTEXT_S_0 = 0x80,
- ASN1_CONTEXT_S_1 = 0x81,
- ASN1_CONTEXT_S_2 = 0x82,
- ASN1_CONTEXT_S_3 = 0x83,
- ASN1_CONTEXT_S_4 = 0x84,
- ASN1_CONTEXT_S_5 = 0x85,
- ASN1_CONTEXT_S_6 = 0x86,
- ASN1_CONTEXT_S_7 = 0x87,
- ASN1_CONTEXT_S_8 = 0x88,
-
- ASN1_CONTEXT_C_0 = 0xA0,
- ASN1_CONTEXT_C_1 = 0xA1,
- ASN1_CONTEXT_C_2 = 0xA2,
- ASN1_CONTEXT_C_3 = 0xA3,
- ASN1_CONTEXT_C_4 = 0xA4,
- ASN1_CONTEXT_C_5 = 0xA5,
-
- ASN1_INVALID = 0x100,
+ ASN1_EOC = 0x00,
+ ASN1_BOOLEAN = 0x01,
+ ASN1_INTEGER = 0x02,
+ ASN1_BIT_STRING = 0x03,
+ ASN1_OCTET_STRING = 0x04,
+ ASN1_NULL = 0x05,
+ ASN1_OID = 0x06,
+ ASN1_ENUMERATED = 0x0A,
+ ASN1_UTF8STRING = 0x0C,
+ ASN1_NUMERICSTRING = 0x12,
+ ASN1_PRINTABLESTRING = 0x13,
+ ASN1_T61STRING = 0x14,
+ ASN1_VIDEOTEXSTRING = 0x15,
+ ASN1_IA5STRING = 0x16,
+ ASN1_UTCTIME = 0x17,
+ ASN1_GENERALIZEDTIME = 0x18,
+ ASN1_GRAPHICSTRING = 0x19,
+ ASN1_VISIBLESTRING = 0x1A,
+ ASN1_GENERALSTRING = 0x1B,
+ ASN1_UNIVERSALSTRING = 0x1C,
+ ASN1_BMPSTRING = 0x1E,
+
+ ASN1_CONSTRUCTED = 0x20,
+
+ ASN1_SEQUENCE = 0x30,
+ ASN1_SET = 0x31,
+
+ ASN1_CONTEXT_S_0 = 0x80,
+ ASN1_CONTEXT_S_1 = 0x81,
+ ASN1_CONTEXT_S_2 = 0x82,
+ ASN1_CONTEXT_S_3 = 0x83,
+ ASN1_CONTEXT_S_4 = 0x84,
+ ASN1_CONTEXT_S_5 = 0x85,
+ ASN1_CONTEXT_S_6 = 0x86,
+ ASN1_CONTEXT_S_7 = 0x87,
+ ASN1_CONTEXT_S_8 = 0x88,
+
+ ASN1_CONTEXT_C_0 = 0xA0,
+ ASN1_CONTEXT_C_1 = 0xA1,
+ ASN1_CONTEXT_C_2 = 0xA2,
+ ASN1_CONTEXT_C_3 = 0xA3,
+ ASN1_CONTEXT_C_4 = 0xA4,
+ ASN1_CONTEXT_C_5 = 0xA5,
+
+ ASN1_INVALID = 0x100,
} asn1_t;
#define ASN1_INVALID_LENGTH 0xffffffff
}
else
{
- this->loopAddr[obj.level] = 0; /* exit loop or option*/
+ this->loopAddr[obj.level] = 0; /* exit loop or option*/
goto end;
}
}
* @return - FALSE if end of object syntax definition was reached
* or a parsing error occurred
* - TRUE otherwise
- */
+ */
bool (*iterate)(asn1_parser_t *this, int *objectID, chunk_t *object);
/**
- * Get the current parsing level
+ * Get the current parsing level
*
* @return current level
*/
u_int (*get_level)(asn1_parser_t *this);
/**
- * Set the top-most level
+ * Set the top-most level
*
* @param level top-most level
*/
void (*set_top_level)(asn1_parser_t *this, u_int level0);
/**
- * Set implicit and private flags
+ * Set implicit and private flags
*
* @param implicit top-most type of object is implicit
* @param private object data is private (use debug level 4)
void (*set_flags)(asn1_parser_t *this, bool implicit, bool private);
/**
- * Show final parsing status
+ * Show final parsing status
*
* @return TRUE if parsing was successful, FALSE otherwise
*/
* printf hook function for chunk_t.
*
* Arguments are:
- * chunk_t *chunk
+ * chunk_t *chunk
* Use #-modifier to print a compact version
*/
int chunk_printf_hook(char *dst, size_t len, printf_hook_spec_t *spec,
certificate_t* (*get_ref)(certificate_t *this);
/**
- * Destroy a certificate.
- */
- void (*destroy)(certificate_t *this);
+ * Destroy a certificate.
+ */
+ void (*destroy)(certificate_t *this);
};
#endif /** CERTIFICATE_H_ @}*/
* RFC 2459 CRL reason codes
*/
enum crl_reason_t {
- CRL_REASON_UNSPECIFIED = 0,
- CRL_REASON_KEY_COMPROMISE = 1,
- CRL_REASON_CA_COMPROMISE = 2,
- CRL_REASON_AFFILIATION_CHANGED = 3,
- CRL_REASON_SUPERSEDED = 4,
- CRL_REASON_CESSATION_OF_OPERATON = 5,
- CRL_REASON_CERTIFICATE_HOLD = 6,
- CRL_REASON_REMOVE_FROM_CRL = 8,
+ CRL_REASON_UNSPECIFIED = 0,
+ CRL_REASON_KEY_COMPROMISE = 1,
+ CRL_REASON_CA_COMPROMISE = 2,
+ CRL_REASON_AFFILIATION_CHANGED = 3,
+ CRL_REASON_SUPERSEDED = 4,
+ CRL_REASON_CESSATION_OF_OPERATON = 5,
+ CRL_REASON_CERTIFICATE_HOLD = 6,
+ CRL_REASON_REMOVE_FROM_CRL = 8,
};
/**
shared_key_t* (*get_ref)(shared_key_t *this);
/**
- * Destroy a shared_key instance if all references are gone.
- */
- void (*destroy)(shared_key_t *this);
+ * Destroy a shared_key instance if all references are gone.
+ */
+ void (*destroy)(shared_key_t *this);
};
/**
ENCR_CAMELLIA_CCM_ICV12 = 26,
ENCR_CAMELLIA_CCM_ICV16 = 27,
ENCR_UNDEFINED = 1024,
- ENCR_DES_ECB = 1025,
+ ENCR_DES_ECB = 1025,
ENCR_SERPENT_CBC = 1026,
- ENCR_TWOFISH_CBC = 1027
+ ENCR_TWOFISH_CBC = 1027
};
#define DES_BLOCK_SIZE 8
{
if (this->test_on_create &&
!this->tester->test_crypter(this->tester, algo, key_size,
- entry->create_crypter))
+ entry->create_crypter))
{
continue;
}
{
identification_t *issuer = cert->get_issuer(cert);
- return asn1_wrap(ASN1_SEQUENCE, "cm",
+ return asn1_wrap(ASN1_SEQUENCE, "cm",
issuer->get_encoding(issuer),
asn1_simple_object(ASN1_INTEGER, cert->get_serialNumber(cert)));
}
crypter->encrypt(crypter, in, iv, &out);
crypter->destroy(crypter);
chunk_clear(&in);
- DBG3(" encrypted data: %B", &out);
+ DBG3(" encrypted data: %B", &out);
/* build pkcs7 enveloped data object */
{
asn1_wrap(ASN1_SET, "m", recipientInfo),
encryptedContentInfo);
this->type = OID_PKCS7_ENVELOPED_DATA;
- }
+ }
return TRUE;
}
while (iterator->iterate(iterator, (void**)&attribute))
{
memcpy(pos, attribute->encoding.ptr, attribute->encoding.len);
- pos += attribute->encoding.len;
+ pos += attribute->encoding.len;
}
iterator->destroy(iterator);
}
if (type != ASN1_EOC)
{
- if (!asn1_parse_simple_object(&object, type,
+ if (!asn1_parse_simple_object(&object, type,
parser->get_level(parser)+1,
oid_names[oid].name))
{
typedef struct proposal_token proposal_token_t;
struct proposal_token {
- char *name;
- transform_type_t type;
+ char *name;
+ transform_type_t type;
u_int16_t algorithm;
- u_int16_t keysize;
+ u_int16_t keysize;
};
extern const proposal_token_t* proposal_get_token(register const char *str,
* Interface for a database implementation.
*
* @code
- int affected, rowid, aint;
- char *atext;
- database_t *db;
- enumerator_t *enumerator;
+ int affected, rowid, aint;
+ char *atext;
+ database_t *db;
+ enumerator_t *enumerator;
- db = lib->database->create("mysql://user:pass@host/database");
- affected = db->execute(db, &rowid, "INSERT INTO table VALUES (?, ?)",
- DB_INT, 77, DB_TEXT, "a text");
- printf("inserted %d row, new row ID: %d\n", affected, rowid);
+ db = lib->database->create("mysql://user:pass@host/database");
+ affected = db->execute(db, &rowid, "INSERT INTO table VALUES (?, ?)",
+ DB_INT, 77, DB_TEXT, "a text");
+ printf("inserted %d row, new row ID: %d\n", affected, rowid);
- enumerator = db->query(db, "SELECT aint, atext FROM table WHERE aint > ?",
- DB_INT, 10, // 1 argument to SQL string
- DB_INT, DB_TEXT); // 2 enumerated types in query
- if (enumerator)
- {
- while (enumerator->enumerate(enumerator, &aint, &atext))
- {
- printf("%d: %s\n", aint, atext);
- }
- enumerator->destroy(enumerator);
- }
+ enumerator = db->query(db, "SELECT aint, atext FROM table WHERE aint > ?",
+ DB_INT, 10, // 1 argument to SQL string
+ DB_INT, DB_TEXT); // 2 enumerated types in query
+ if (enumerator)
+ {
+ while (enumerator->enumerate(enumerator, &aint, &atext))
+ {
+ printf("%d: %s\n", aint, atext);
+ }
+ enumerator->destroy(enumerator);
+ }
@endcode
*/
struct database_t {
*
* @param sql sql query string, containing '?' placeholders
* @param ... list of sql placeholder db_type_t followed by its value,
- * followed by enumerators arguments as db_type_t's
+ * followed by enumerators arguments as db_type_t's
* @return enumerator as defined with arguments, NULL on failure
*/
enumerator_t* (*query)(database_t *this, char *sql, ...);
db_driver_t (*get_driver)(database_t *this);
/**
- * Destroy a database connection.
- */
- void (*destroy)(database_t *this);
+ * Destroy a database connection.
+ */
+ void (*destroy)(database_t *this);
};
#endif /** DATABASE_H_ @}*/
void (*remove_database)(database_factory_t *this, database_constructor_t create);
/**
- * Destroy a database_factory instance.
- */
- void (*destroy)(database_factory_t *this);
+ * Destroy a database_factory instance.
+ */
+ void (*destroy)(database_factory_t *this);
};
/**
* printf hook function for enum_names_t.
*
* Arguments are:
- * enum_names_t *names, int value
+ * enum_names_t *names, int value
*/
int enum_printf_hook(char *dst, size_t len, printf_hook_spec_t *spec,
const void *const *args);
fetcher_constructor_t constructor);
/**
- * Destroy a fetcher_manager instance.
- */
- void (*destroy)(fetcher_manager_t *this);
+ * Destroy a fetcher_manager instance.
+ */
+ void (*destroy)(fetcher_manager_t *this);
};
/**
CURL* curl;
/**
- * Optional HTTP headers
+ * Optional HTTP headers
*/
struct curl_slist *headers;
};
fetcher_t interface;
/**
- * Destroy a curl_fetcher instance.
- */
- void (*destroy)(curl_fetcher_t *this);
+ * Destroy a curl_fetcher instance.
+ */
+ void (*destroy)(curl_fetcher_t *this);
};
/**
(fetcher_constructor_t)curl_fetcher_create, "https://");
lib->fetcher->add_fetcher(lib->fetcher,
(fetcher_constructor_t)curl_fetcher_create, "ftp://");
- }
- else
- {
- DBG1("global libcurl initializing failed: %s, curl disabled",
+ }
+ else
+ {
+ DBG1("global libcurl initializing failed: %s, curl disabled",
curl_easy_strerror(res));
- }
+ }
return &this->public.plugin;
}
static void get_my_public_value(private_gmp_diffie_hellman_t *this,chunk_t *value)
{
value->len = this->p_len;
- value->ptr = mpz_export(NULL, NULL, 1, value->len, 1, 0, this->ya);
- if (value->ptr == NULL)
- {
- value->len = 0;
- }
+ value->ptr = mpz_export(NULL, NULL, 1, value->len, 1, 0, this->ya);
+ if (value->ptr == NULL)
+ {
+ value->len = 0;
+ }
}
/**
* State of the hasher.
*/
u_int32_t state[5];
- u_int32_t count[2];
- u_int8_t buffer[64];
+ u_int32_t count[2];
+ u_int8_t buffer[64];
};
for (i = partLen; i + 63 < inputLen; i += 64)
{
- MD5Transform (this->state, &input[i]);
+ MD5Transform (this->state, &input[i]);
}
index = 0;
}
mutex_t *mutex;
/**
- * hostname to connect to
- */
+ * hostname to connect to
+ */
char *host;
/**
stmt = mysql_stmt_init(mysql);
if (stmt == NULL)
{
- DBG1("creating MySQL statement failed: %s", mysql_error(mysql));
+ DBG1("creating MySQL statement failed: %s", mysql_error(mysql));
return NULL;
}
if (mysql_stmt_prepare(stmt, sql, strlen(sql)))
{
- DBG1("preparing MySQL statement failed: %s", mysql_stmt_error(stmt));
- mysql_stmt_close(stmt);
- return NULL;
+ DBG1("preparing MySQL statement failed: %s", mysql_stmt_error(stmt));
+ mysql_stmt_close(stmt);
+ return NULL;
}
params = mysql_stmt_param_count(stmt);
if (params > 0)
bind[i].buffer_length = sizeof(double);
break;
}
- case DB_NULL:
+ case DB_NULL:
{
bind[i].buffer_type = MYSQL_TYPE_NULL;
break;
}
default:
- DBG1("invalid data type supplied");
- mysql_stmt_close(stmt);
- return NULL;
+ DBG1("invalid data type supplied");
+ mysql_stmt_close(stmt);
+ return NULL;
}
}
if (mysql_stmt_bind_param(stmt, bind))
{
- DBG1("binding MySQL param failed: %s", mysql_stmt_error(stmt));
- mysql_stmt_close(stmt);
+ DBG1("binding MySQL param failed: %s", mysql_stmt_error(stmt));
+ mysql_stmt_close(stmt);
return NULL;
}
}
if (mysql_stmt_execute(stmt))
{
- DBG1("executing MySQL statement failed: %s", mysql_stmt_error(stmt));
- mysql_stmt_close(stmt);
+ DBG1("executing MySQL statement failed: %s", mysql_stmt_error(stmt));
+ mysql_stmt_close(stmt);
return NULL;
}
return stmt;
this->bind[i].buffer = malloc(this->length[i]+1);
this->bind[i].buffer_length = this->length[i];
*value = this->bind[i].buffer;
- mysql_stmt_fetch_column(this->stmt, &this->bind[i], i, 0);
- ((char*)this->bind[i].buffer)[this->length[i]] = '\0';
- break;
+ mysql_stmt_fetch_column(this->stmt, &this->bind[i], i, 0);
+ ((char*)this->bind[i].buffer)[this->length[i]] = '\0';
+ break;
}
case MYSQL_TYPE_BLOB:
{
this->bind[i].buffer_length = this->length[i];
value->ptr = this->bind[i].buffer;
value->len = this->length[i];
- mysql_stmt_fetch_column(this->stmt, &this->bind[i], i, 0);
- break;
+ mysql_stmt_fetch_column(this->stmt, &this->bind[i], i, 0);
+ break;
}
case MYSQL_TYPE_DOUBLE:
{
break;
}
default:
- DBG1("invalid result data type supplied");
- mysql_enumerator_destroy(enumerator);
- va_end(args);
- return NULL;
+ DBG1("invalid result data type supplied");
+ mysql_enumerator_destroy(enumerator);
+ va_end(args);
+ return NULL;
}
}
if (mysql_stmt_bind_result(stmt, enumerator->bind))
{
DBG1("binding MySQL result failed: %s", mysql_stmt_error(stmt));
- mysql_enumerator_destroy(enumerator);
- enumerator = NULL;
+ mysql_enumerator_destroy(enumerator);
+ enumerator = NULL;
}
}
else
conn = conn_get(this);
if (!conn)
{
- destroy(this);
- return NULL;
+ destroy(this);
+ return NULL;
}
conn_release(conn);
return &this->public;
static void padlock_sha1(int len, u_char *in, u_char *out)
{
/* rep xsha1 */
- asm volatile (
+ asm volatile (
".byte 0xf3, 0x0f, 0xa6, 0xc8"
: "+S"(in), "+D"(out)
: "c"(len), "a"(0));
struct plugin_t {
/**
- * Destroy a plugin instance.
- */
- void (*destroy)(plugin_t *this);
+ * Destroy a plugin instance.
+ */
+ void (*destroy)(plugin_t *this);
};
* 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];
+ u_int32_t count[2];
+ u_int8_t buffer[64];
};
/*
{
u_int32_t a, b, c, d, e;
typedef union {
- u_int8_t c[64];
- u_int32_t l[16];
+ u_int8_t c[64];
+ u_int32_t l[16];
} CHAR64LONG16;
CHAR64LONG16 block[1]; /* use array to appear as a pointer */
- memcpy(block, buffer, 64);
+ memcpy(block, buffer, 64);
- /* Copy context->state[] to working vars */
- a = state[0];
- b = state[1];
- c = state[2];
- d = state[3];
- e = state[4];
- /* 4 rounds of 20 operations each. Loop unrolled. */
- R0(a,b,c,d,e, 0); R0(e,a,b,c,d, 1); R0(d,e,a,b,c, 2); R0(c,d,e,a,b, 3);
- R0(b,c,d,e,a, 4); R0(a,b,c,d,e, 5); R0(e,a,b,c,d, 6); R0(d,e,a,b,c, 7);
- R0(c,d,e,a,b, 8); R0(b,c,d,e,a, 9); R0(a,b,c,d,e,10); R0(e,a,b,c,d,11);
- R0(d,e,a,b,c,12); R0(c,d,e,a,b,13); R0(b,c,d,e,a,14); R0(a,b,c,d,e,15);
- R1(e,a,b,c,d,16); R1(d,e,a,b,c,17); R1(c,d,e,a,b,18); R1(b,c,d,e,a,19);
- R2(a,b,c,d,e,20); R2(e,a,b,c,d,21); R2(d,e,a,b,c,22); R2(c,d,e,a,b,23);
- R2(b,c,d,e,a,24); R2(a,b,c,d,e,25); R2(e,a,b,c,d,26); R2(d,e,a,b,c,27);
- R2(c,d,e,a,b,28); R2(b,c,d,e,a,29); R2(a,b,c,d,e,30); R2(e,a,b,c,d,31);
- R2(d,e,a,b,c,32); R2(c,d,e,a,b,33); R2(b,c,d,e,a,34); R2(a,b,c,d,e,35);
- R2(e,a,b,c,d,36); R2(d,e,a,b,c,37); R2(c,d,e,a,b,38); R2(b,c,d,e,a,39);
- R3(a,b,c,d,e,40); R3(e,a,b,c,d,41); R3(d,e,a,b,c,42); R3(c,d,e,a,b,43);
- R3(b,c,d,e,a,44); R3(a,b,c,d,e,45); R3(e,a,b,c,d,46); R3(d,e,a,b,c,47);
- R3(c,d,e,a,b,48); R3(b,c,d,e,a,49); R3(a,b,c,d,e,50); R3(e,a,b,c,d,51);
- R3(d,e,a,b,c,52); R3(c,d,e,a,b,53); R3(b,c,d,e,a,54); R3(a,b,c,d,e,55);
- R3(e,a,b,c,d,56); R3(d,e,a,b,c,57); R3(c,d,e,a,b,58); R3(b,c,d,e,a,59);
- R4(a,b,c,d,e,60); R4(e,a,b,c,d,61); R4(d,e,a,b,c,62); R4(c,d,e,a,b,63);
- R4(b,c,d,e,a,64); R4(a,b,c,d,e,65); R4(e,a,b,c,d,66); R4(d,e,a,b,c,67);
- R4(c,d,e,a,b,68); R4(b,c,d,e,a,69); R4(a,b,c,d,e,70); R4(e,a,b,c,d,71);
- R4(d,e,a,b,c,72); R4(c,d,e,a,b,73); R4(b,c,d,e,a,74); R4(a,b,c,d,e,75);
- R4(e,a,b,c,d,76); R4(d,e,a,b,c,77); R4(c,d,e,a,b,78); R4(b,c,d,e,a,79);
- /* Add the working vars back into context.state[] */
- state[0] += a;
- state[1] += b;
- state[2] += c;
- state[3] += d;
- state[4] += e;
- /* Wipe variables */
- a = b = c = d = e = 0;
- memset(block, '\0', sizeof(block));
+ /* Copy context->state[] to working vars */
+ a = state[0];
+ b = state[1];
+ c = state[2];
+ d = state[3];
+ e = state[4];
+ /* 4 rounds of 20 operations each. Loop unrolled. */
+ R0(a,b,c,d,e, 0); R0(e,a,b,c,d, 1); R0(d,e,a,b,c, 2); R0(c,d,e,a,b, 3);
+ R0(b,c,d,e,a, 4); R0(a,b,c,d,e, 5); R0(e,a,b,c,d, 6); R0(d,e,a,b,c, 7);
+ R0(c,d,e,a,b, 8); R0(b,c,d,e,a, 9); R0(a,b,c,d,e,10); R0(e,a,b,c,d,11);
+ R0(d,e,a,b,c,12); R0(c,d,e,a,b,13); R0(b,c,d,e,a,14); R0(a,b,c,d,e,15);
+ R1(e,a,b,c,d,16); R1(d,e,a,b,c,17); R1(c,d,e,a,b,18); R1(b,c,d,e,a,19);
+ R2(a,b,c,d,e,20); R2(e,a,b,c,d,21); R2(d,e,a,b,c,22); R2(c,d,e,a,b,23);
+ R2(b,c,d,e,a,24); R2(a,b,c,d,e,25); R2(e,a,b,c,d,26); R2(d,e,a,b,c,27);
+ R2(c,d,e,a,b,28); R2(b,c,d,e,a,29); R2(a,b,c,d,e,30); R2(e,a,b,c,d,31);
+ R2(d,e,a,b,c,32); R2(c,d,e,a,b,33); R2(b,c,d,e,a,34); R2(a,b,c,d,e,35);
+ R2(e,a,b,c,d,36); R2(d,e,a,b,c,37); R2(c,d,e,a,b,38); R2(b,c,d,e,a,39);
+ R3(a,b,c,d,e,40); R3(e,a,b,c,d,41); R3(d,e,a,b,c,42); R3(c,d,e,a,b,43);
+ R3(b,c,d,e,a,44); R3(a,b,c,d,e,45); R3(e,a,b,c,d,46); R3(d,e,a,b,c,47);
+ R3(c,d,e,a,b,48); R3(b,c,d,e,a,49); R3(a,b,c,d,e,50); R3(e,a,b,c,d,51);
+ R3(d,e,a,b,c,52); R3(c,d,e,a,b,53); R3(b,c,d,e,a,54); R3(a,b,c,d,e,55);
+ R3(e,a,b,c,d,56); R3(d,e,a,b,c,57); R3(c,d,e,a,b,58); R3(b,c,d,e,a,59);
+ R4(a,b,c,d,e,60); R4(e,a,b,c,d,61); R4(d,e,a,b,c,62); R4(c,d,e,a,b,63);
+ R4(b,c,d,e,a,64); R4(a,b,c,d,e,65); R4(e,a,b,c,d,66); R4(d,e,a,b,c,67);
+ R4(c,d,e,a,b,68); R4(b,c,d,e,a,69); R4(a,b,c,d,e,70); R4(e,a,b,c,d,71);
+ R4(d,e,a,b,c,72); R4(c,d,e,a,b,73); R4(b,c,d,e,a,74); R4(a,b,c,d,e,75);
+ R4(e,a,b,c,d,76); R4(d,e,a,b,c,77); R4(c,d,e,a,b,78); R4(b,c,d,e,a,79);
+ /* Add the working vars back into context.state[] */
+ state[0] += a;
+ state[1] += b;
+ state[2] += c;
+ state[3] += d;
+ state[4] += e;
+ /* Wipe variables */
+ a = b = c = d = e = 0;
+ memset(block, '\0', sizeof(block));
}
/**
u_int32_t i;
u_int32_t j;
- j = this->count[0];
- if ((this->count[0] += len << 3) < j)
- {
+ j = this->count[0];
+ if ((this->count[0] += len << 3) < j)
+ {
this->count[1]++;
- }
- this->count[1] += (len>>29);
- j = (j >> 3) & 63;
- if ((j + len) > 63)
- {
- memcpy(&this->buffer[j], data, (i = 64-j));
- SHA1Transform(this->state, this->buffer);
- for ( ; i + 63 < len; i += 64)
- {
- SHA1Transform(this->state, &data[i]);
- }
- j = 0;
- }
- else
- {
- i = 0;
- }
- memcpy(&this->buffer[j], &data[i], len - i);
+ }
+ this->count[1] += (len>>29);
+ j = (j >> 3) & 63;
+ if ((j + len) > 63)
+ {
+ memcpy(&this->buffer[j], data, (i = 64-j));
+ SHA1Transform(this->state, this->buffer);
+ for ( ; i + 63 < len; i += 64)
+ {
+ SHA1Transform(this->state, &data[i]);
+ }
+ j = 0;
+ }
+ else
+ {
+ i = 0;
+ }
+ memcpy(&this->buffer[j], &data[i], len - i);
}
u_int8_t finalcount[8];
u_int8_t c;
- for (i = 0; i < 8; i++)
- {
- finalcount[i] = (u_int8_t)((this->count[(i >= 4 ? 0 : 1)]
- >> ((3-(i & 3)) * 8) ) & 255); /* Endian independent */
- }
- c = 0200;
- SHA1Update(this, &c, 1);
- while ((this->count[0] & 504) != 448)
- {
+ for (i = 0; i < 8; i++)
+ {
+ finalcount[i] = (u_int8_t)((this->count[(i >= 4 ? 0 : 1)]
+ >> ((3-(i & 3)) * 8) ) & 255); /* Endian independent */
+ }
+ c = 0200;
+ SHA1Update(this, &c, 1);
+ while ((this->count[0] & 504) != 448)
+ {
c = 0000;
- SHA1Update(this, &c, 1);
- }
- 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);
- }
+ SHA1Update(this, &c, 1);
+ }
+ 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);
+ }
}
/**
static void reset(private_sha1_hasher_t *this)
{
this->state[0] = 0x67452301;
- this->state[1] = 0xEFCDAB89;
- this->state[2] = 0x98BADCFE;
- this->state[3] = 0x10325476;
- this->state[4] = 0xC3D2E1F0;
- this->count[0] = 0;
- this->count[1] = 0;
+ this->state[1] = 0xEFCDAB89;
+ this->state[2] = 0x98BADCFE;
+ this->state[3] = 0x10325476;
+ this->state[4] = 0xC3D2E1F0;
+ this->count[0] = 0;
+ this->count[1] = 0;
}
/**
* 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];
+ u_int32_t count[2];
+ u_int8_t buffer[64];
};
/**
return 1;
}
- cmp_len = this->value.len - other->value.len;
- len = (cmp_len < 0)? this->value.len : other->value.len;
- cmp_value = memcmp(this->value.ptr, other->value.ptr, len);
+ cmp_len = this->value.len - other->value.len;
+ len = (cmp_len < 0)? this->value.len : other->value.len;
+ cmp_value = memcmp(this->value.ptr, other->value.ptr, len);
- return (cmp_value == 0)? cmp_len : cmp_value;
+ return (cmp_value == 0)? cmp_len : cmp_value;
}
/**
fprintf(out, "%s", oid_names[oid]);
}
}
- break;
+ break;
default:
- break;
+ break;
}
}
iterator->destroy(iterator);
static chunk_t build_ac(private_x509_ac_t *this)
{
chunk_t signatureValue;
- chunk_t attributeCertificateInfo;
+ chunk_t attributeCertificateInfo;
attributeCertificateInfo = build_attr_cert_info(this);
*/
static chunk_t build_requestExtensions(private_x509_ocsp_request_t *this)
{
- return asn1_wrap(ASN1_CONTEXT_C_2, "m",
+ return asn1_wrap(ASN1_CONTEXT_C_2, "m",
asn1_wrap(ASN1_SEQUENCE, "mm",
build_nonce(this),
build_acceptableResponses(this)));
{
response->revocationReason = *object.ptr;
}
- break;
+ break;
case SINGLE_RESPONSE_CERT_STATUS_UNKNOWN:
response->status = VALIDATION_FAILED;
break;
{
this->usableUntil = response->nextUpdate;
}
- break;
+ break;
}
}
success = parser->success(parser);
case OCSP_RESPONSE_STATUS:
status = (ocsp_status_t)*object.ptr;
switch (status)
- {
- case OCSP_SUCCESSFUL:
+ {
+ case OCSP_SUCCESSFUL:
break;
default:
DBG1(" ocsp response status: %N",
ocsp_status_names, status);
goto end;
}
- break;
+ break;
case OCSP_RESPONSE_TYPE:
responseType = asn1_known_oid(object);
break;
printf_hook_function_t hook, ...);
/**
- * Destroy a printf_hook instance.
- */
- void (*destroy)(printf_hook_t *this);
+ * Destroy a printf_hook instance.
+ */
+ void (*destroy)(printf_hook_t *this);
};
/**
ascii_buffer[i] = '\0';
written += print_in_hook(dst, dstlen, "\n%4d: %s %s",
- line_start, buffer, ascii_buffer);
+ line_start, buffer, ascii_buffer);
buffer_pos = buffer;
line_start += BYTES_PER_LINE;
* printf hook for time_t.
*
* Arguments are:
- * time_t* time, bool utc
+ * time_t* time, bool utc
*/
int time_printf_hook(char *dst, size_t len, printf_hook_spec_t *spec,
const void *const *args);
* printf hook for time_t deltas.
*
* Arguments are:
- * time_t* begin, time_t* end
+ * time_t* begin, time_t* end
*/
int time_delta_printf_hook(char *dst, size_t len, printf_hook_spec_t *spec,
const void *const *args);
* printf hook for memory areas.
*
* Arguments are:
- * u_char *ptr, int len
+ * u_char *ptr, int len
*/
int mem_printf_hook(char *dst, size_t len, printf_hook_spec_t *spec,
const void *const *args);
bool (*enumerate)(enumerator_t *this, ...);
/**
- * Destroy a enumerator instance.
- */
- void (*destroy)(enumerator_t *this);
+ * Destroy a enumerator instance.
+ */
+ void (*destroy)(enumerator_t *this);
};
/**
* printf hook function for host_t.
*
* Arguments are:
- * host_t *host
+ * host_t *host
* Use #-modifier to include port number
*/
int host_printf_hook(char *dst, size_t len, printf_hook_spec_t *spec,
* An example of an ID_RFC822_ADDR is "jsmith@example.com".
* The string MUST NOT contain any terminators.
*/
- ID_USER_FQDN = 3, /* IKEv1 only */
- ID_RFC822_ADDR = 3, /* IKEv2 only */
+ ID_USER_FQDN = 3, /* IKEv1 only */
+ ID_RFC822_ADDR = 3, /* IKEv2 only */
/**
* ID data is an IPv4 subnet (IKEv1 only)
* printf hook function for identification_t.
*
* Arguments are:
- * identification_t *identification
+ * identification_t *identification
*/
int identification_printf_hook(char *dst, size_t len, printf_hook_spec_t *spec,
const void *const *args);
memory_header_t *hdr;
memory_tail_t *tail;
pthread_t thread_id = pthread_self();
- int oldpolicy;
- struct sched_param oldparams, params;
+ int oldpolicy;
+ struct sched_param oldparams, params;
- pthread_getschedparam(thread_id, &oldpolicy, &oldparams);
+ pthread_getschedparam(thread_id, &oldpolicy, &oldparams);
- params.__sched_priority = sched_get_priority_max(SCHED_FIFO);
+ params.__sched_priority = sched_get_priority_max(SCHED_FIFO);
pthread_setschedparam(thread_id, SCHED_FIFO, ¶ms);
count_malloc++;
{
memory_header_t *hdr;
memory_tail_t *tail;
- backtrace_t *backtrace;
+ backtrace_t *backtrace;
pthread_t thread_id = pthread_self();
- int oldpolicy;
- struct sched_param oldparams, params;
+ int oldpolicy;
+ struct sched_param oldparams, params;
/* allow freeing of NULL */
if (ptr == NULL)
pthread_getschedparam(thread_id, &oldpolicy, &oldparams);
- params.__sched_priority = sched_get_priority_max(SCHED_FIFO);
+ params.__sched_priority = sched_get_priority_max(SCHED_FIFO);
pthread_setschedparam(thread_id, SCHED_FIFO, ¶ms);
count_free++;
memory_tail_t *tail;
backtrace_t *backtrace;
pthread_t thread_id = pthread_self();
- int oldpolicy;
- struct sched_param oldparams, params;
+ int oldpolicy;
+ struct sched_param oldparams, params;
/* allow reallocation of NULL */
if (old == NULL)
struct leak_detective_t {
/**
- * Destroy a leak_detective instance.
- */
- void (*destroy)(leak_detective_t *this);
+ * Destroy a leak_detective instance.
+ */
+ void (*destroy)(leak_detective_t *this);
};
/**
library_deinit();
- return 0;
+ return 0;
}
enumerator_t* (*create_gateway_enumerator)(storage_t *this, int user);
/**
- * Destroy a storage instance.
- */
- void (*destroy)(storage_t *this);
+ * Destroy a storage instance.
+ */
+ void (*destroy)(storage_t *this);
};
/**
if (*optarg == '/') /* absolute pathname */
{
- strncpy(path, optarg, BUF_LEN);
+ strncpy(path, optarg, BUF_LEN);
}
else /* relative pathname */
{
- snprintf(path, BUF_LEN, "%s/%s", OPENAC_PATH, optarg);
+ snprintf(path, BUF_LEN, "%s/%s", OPENAC_PATH, optarg);
}
if (!options->from(options, path, &argc, &argv, optind))
{
projects / thirdparty / strongswan.git / commitdiff
