this->imcs->insert_last(this->imcs, imc);
this->next_imc_id++;
- if (imc->provide_bind_function(imc->get_id(imc), TNC_TNCC_BindFunction)
+ if (imc->provide_bind_function(imc->get_id(imc), TNC_TNCC_BindFunction)
!= TNC_RESULT_SUCCESS)
{
DBG1(DBG_TNC, "IMC \"%s\" failed to obtain bind function",
.receive_message = _receive_message,
.batch_ending = _batch_ending,
.destroy = _destroy,
- },
+ },
.imcs = linked_list_create(),
.next_imc_id = 1,
);
TNC_MessageSubtype msg_subtype, subtype;
int i;
- msg_vid = (message_type >> 8) & TNC_VENDORID_ANY;
+ msg_vid = (message_type >> 8) & TNC_VENDORID_ANY;
msg_subtype = message_type & TNC_SUBTYPE_ANY;
for (i = 0; i < this->type_count; i++)
{
- vid = (this->supported_types[i] >> 8) & TNC_VENDORID_ANY;
- subtype = this->supported_types[i] & TNC_SUBTYPE_ANY;
+ vid = (this->supported_types[i] >> 8) & TNC_VENDORID_ANY;
+ subtype = this->supported_types[i] & TNC_SUBTYPE_ANY;
- if (this->supported_types[i] == message_type
+ if (this->supported_types[i] == message_type
|| (subtype == TNC_SUBTYPE_ANY
&& (msg_vid == vid || vid == TNC_VENDORID_ANY))
- || (vid == TNC_VENDORID_ANY
- && (msg_subtype == subtype || subtype == TNC_SUBTYPE_ANY)))
+ || (vid == TNC_VENDORID_ANY
+ && (msg_subtype == subtype || subtype == TNC_SUBTYPE_ANY)))
{
return TRUE;
}
.set_message_types = _set_message_types,
.type_supported = _type_supported,
.destroy = _destroy,
- },
+ },
.name = name,
.path = path,
);
this->public.initialize = dlsym(this->handle, "TNC_IMV_Initialize");
if (!this->public.initialize)
- {
+ {
DBG1(DBG_TNC, "could not resolve TNC_IMV_Initialize in %s: %s\n",
path, dlerror());
dlclose(this->handle);
}
this->public.notify_connection_change =
dlsym(this->handle, "TNC_IMV_NotifyConnectionChange");
- this->public.solicit_recommendation =
+ this->public.solicit_recommendation =
dlsym(this->handle, "TNC_IMV_SolicitRecommendation");
if (!this->public.solicit_recommendation)
- {
+ {
DBG1(DBG_TNC, "could not resolve TNC_IMV_SolicitRecommendation in %s: %s\n",
path, dlerror());
dlclose(this->handle);
free(this);
return NULL;
}
- this->public.receive_message =
+ this->public.receive_message =
dlsym(this->handle, "TNC_IMV_ReceiveMessage");
- this->public.batch_ending =
+ this->public.batch_ending =
dlsym(this->handle, "TNC_IMV_BatchEnding");
- this->public.terminate =
+ this->public.terminate =
dlsym(this->handle, "TNC_IMV_Terminate");
- this->public.provide_bind_function =
+ this->public.provide_bind_function =
dlsym(this->handle, "TNC_IMV_ProvideBindFunction");
- if (!this->public.provide_bind_function)
+ if (!this->public.provide_bind_function)
{
DBG1(DBG_TNC, "could not resolve TNC_IMV_ProvideBindFunction in %s: %s\n",
path, dlerror());
{
*function_pointer = (void*)TNC_TNCS_ReportMessageTypes;
}
- else if (streq(function_name, "TNC_TNCS_RequestHandshakeRetry"))
+ else if (streq(function_name, "TNC_TNCS_RequestHandshakeRetry"))
{
*function_pointer = (void*)TNC_TNCS_RequestHandshakeRetry;
}
- else if (streq(function_name, "TNC_TNCS_SendMessage"))
+ else if (streq(function_name, "TNC_TNCS_SendMessage"))
{
*function_pointer = (void*)TNC_TNCS_SendMessage;
}
- else if (streq(function_name, "TNC_TNCS_ProvideRecommendation"))
+ else if (streq(function_name, "TNC_TNCS_ProvideRecommendation"))
{
*function_pointer = (void*)TNC_TNCS_ProvideRecommendation;
}
- else if (streq(function_name, "TNC_TNCS_GetAttribute"))
+ else if (streq(function_name, "TNC_TNCS_GetAttribute"))
{
*function_pointer = (void*)TNC_TNCS_GetAttribute;
}
- else if (streq(function_name, "TNC_TNCS_SetAttribute"))
+ else if (streq(function_name, "TNC_TNCS_SetAttribute"))
{
*function_pointer = (void*)TNC_TNCS_SetAttribute;
}
- else
+ else
{
return TNC_RESULT_INVALID_PARAMETER;
}
- return TNC_RESULT_SUCCESS;
+ return TNC_RESULT_SUCCESS;
}
this->imvs->insert_last(this->imvs, imv);
this->next_imv_id++;
- if (imv->provide_bind_function(imv->get_id(imv), TNC_TNCS_BindFunction)
+ if (imv->provide_bind_function(imv->get_id(imv), TNC_TNCS_BindFunction)
!= TNC_RESULT_SUCCESS)
{
DBG1(DBG_TNC, "IMV \"%s\" could failed to obtain bind function",
case TNC_IMV_ACTION_RECOMMENDATION_ALLOW:
DBG1(DBG_TNC, "TNC recommendation is allow");
group = "allow";
- break;
+ break;
case TNC_IMV_ACTION_RECOMMENDATION_ISOLATE:
DBG1(DBG_TNC, "TNC recommendation is isolate");
group = "isolate";
.receive_message = _receive_message,
.batch_ending = _batch_ending,
.destroy = _destroy,
- },
+ },
.imvs = linked_list_create(),
.next_imv_id = 1,
);
/**
* Reason language provided by IMV instance
*/
- chunk_t reason_language;
+ chunk_t reason_language;
};
/**
recommendations_t public;
/**
- * list of recommendations and evaluations provided by IMVs
+ * list of recommendations and evaluations provided by IMVs
*/
linked_list_t *recs;
else
{
return FALSE;
- }
+ }
}
METHOD(recommendations_t, create_reason_enumerator, enumerator_t*,
.set_reason_language = _set_reason_language,
.create_reason_enumerator = _create_reason_enumerator,
.destroy = _destroy,
- },
+ },
.recs = linked_list_create(),
);
entry->eval = TNC_IMV_EVALUATION_RESULT_DONT_KNOW;
entry->reason = chunk_empty;
entry->reason_language = chunk_empty;
- this->recs->insert_last(this->recs, entry);
+ this->recs->insert_last(this->recs, entry);
}
- enumerator->destroy(enumerator);
+ enumerator->destroy(enumerator);
return &this->public;
}
* Batch ID
*/
int batch_id;
-
+
/**
* TNCC if TRUE, TNCS if FALSE
*/
private_tnccs_batch_t *this, tnccs_msg_t* msg)
{
xmlNodePtr root;
-
+
DBG2(DBG_TNC, "adding %N message", tnccs_msg_type_names,
msg->get_type(msg));
this->messages->insert_last(this->messages, msg);
METHOD(tnccs_batch_t, build, void,
private_tnccs_batch_t *this)
{
- xmlChar *xmlbuf;
- int buf_size;
+ xmlChar *xmlbuf;
+ int buf_size;
xmlDocDumpFormatMemory(this->doc, &xmlbuf, &buf_size, 1);
this->encoding = chunk_create((u_char*)xmlbuf, buf_size);
- this->encoding = chunk_clone(this->encoding);
- xmlFree(xmlbuf);
+ this->encoding = chunk_clone(this->encoding);
+ xmlFree(xmlbuf);
}
METHOD(tnccs_batch_t, process, status_t,
tnccs_msg_t *tnccs_msg, *msg;
tnccs_error_type_t error_type = TNCCS_ERROR_OTHER;
char *error_msg, buf[BUF_LEN];
- xmlNodePtr cur;
- xmlNsPtr ns;
- xmlChar *batchid, *recipient;
+ xmlNodePtr cur;
+ xmlNsPtr ns;
+ xmlChar *batchid, *recipient;
int batch_id;
this->doc = xmlParseMemory(this->encoding.ptr, this->encoding.len);
/* check out the XML document */
cur = xmlDocGetRootElement(this->doc);
- if (!cur)
+ if (!cur)
{
error_type = TNCCS_ERROR_MALFORMED_BATCH;
error_msg = "empty XML document";
snprintf(buf, BUF_LEN, "wrong XML document type '%s', expected TNCCS-Batch",
cur->name);
goto fatal;
- }
+ }
/* check presence of BatchID property */
batchid = xmlGetProp(cur, (const xmlChar*)"BatchId");
if (!batchid)
- {
+ {
error_type = TNCCS_ERROR_INVALID_BATCH_ID;
error_msg = "BatchId is missing";
goto fatal;
error_msg = buf;
snprintf(buf, BUF_LEN, "message recipient expected '%s', got '%s'",
this->is_server ? "TNCS" : "TNCC", (char*)recipient);
- xmlFree(recipient);
+ xmlFree(recipient);
goto fatal;
}
xmlFree(recipient);
offsetof(tnccs_msg_t, destroy));
this->errors->destroy_offset(this->errors,
offsetof(tnccs_msg_t, destroy));
- xmlFreeDoc(this->doc);
+ xmlFreeDoc(this->doc);
free(this->encoding.ptr);
free(this);
}
};
/**
- * Encodes message data into multiple base64-encoded lines
+ * Encodes message data into multiple base64-encoded lines
*/
static chunk_t encode_base64(chunk_t data)
{
}
/**
- * Decodes message data from multiple base64-encoded lines
+ * Decodes message data from multiple base64-encoded lines
*/
static chunk_t decode_base64(chunk_t data)
{
if (streq((char*)cur->name, "Type") && cur->ns == ns)
{
content = xmlNodeGetContent(cur);
- this->msg_type = strtoul((char*)content, NULL, 16);
- xmlFree(content);
+ this->msg_type = strtoul((char*)content, NULL, 16);
+ xmlFree(content);
}
else if (streq((char*)cur->name, "Base64") && cur->ns == ns)
{
content = xmlNodeGetContent(cur);
b64_body = chunk_create((char*)content, strlen((char*)content));
this->msg_body = decode_base64(b64_body);
- xmlFree(content);
+ xmlFree(content);
}
cur = cur->next;
}
.get_msg_body = _get_msg_body,
},
.type = IMC_IMV_MSG,
- .node = xmlNewNode(NULL, BAD_CAST "IMC-IMV-Message"),
+ .node = xmlNewNode(NULL, BAD_CAST "IMC-IMV-Message"),
.msg_type = msg_type,
.msg_body = chunk_clone(msg_body),
);
{
if (streq((char*)cur->name, "Type") && cur->ns == ns)
{
- xmlChar *content = xmlNodeGetContent(cur);
+ xmlChar *content = xmlNodeGetContent(cur);
- type = strtol((char*)content, NULL, 16);
- xmlFree(content);
+ type = strtol((char*)content, NULL, 16);
+ xmlFree(content);
found = TRUE;
}
else if (streq((char*)cur->name, "XML") && cur->ns == ns)
}
cur = xml_msg_node;
- /* skip empty and blank nodes */
- while (cur && xmlIsBlankNode(cur))
+ /* skip empty and blank nodes */
+ while (cur && xmlIsBlankNode(cur))
{
cur = cur->next;
}
- if (!cur)
+ if (!cur)
{
error_msg = "XML node is empty";
goto fatal;
}
- /* check if TNCCS message type and node name agree */
+ /* check if TNCCS message type and node name agree */
if (type >= TNCCS_MSG_RECOMMENDATION && type <= TNCCS_MSG_ROOF)
{
DBG2(DBG_TNC, "processing %N message", tnccs_msg_type_names, type);
n2 = xmlNewNode(NULL, BAD_CAST enum_to_name(tnccs_msg_type_names, this->type));
- /* could add multiple reasons here, if we had them */
- n3 = xmlNewNode(NULL, BAD_CAST "ReasonString");
- xmlNewProp(n3, BAD_CAST "xml:lang", BAD_CAST this->language.ptr);
- xmlNodeSetContent(n3, BAD_CAST this->reason.ptr);
- xmlAddChild(n2, n3);
+ /* could add multiple reasons here, if we had them */
+ n3 = xmlNewNode(NULL, BAD_CAST "ReasonString");
+ xmlNewProp(n3, BAD_CAST "xml:lang", BAD_CAST this->language.ptr);
+ xmlNodeSetContent(n3, BAD_CAST this->reason.ptr);
+ xmlAddChild(n2, n3);
return &this->public.tnccs_msg_interface;
}
{
error_msg = "type property in TNCCS-Recommendation is missing";
goto fatal;
- }
+ }
else if (streq((char*)rec_string, "allow"))
{
this->rec = TNC_IMV_ACTION_RECOMMENDATION_ALLOW;
goto fatal;
}
xmlFree(rec_string);
-
+
return &this->public.tnccs_msg_interface;
fatal:
}
n2 = xmlNewNode(NULL, BAD_CAST enum_to_name(tnccs_msg_type_names, this->type));
- xmlNewProp(n2, BAD_CAST "type", BAD_CAST rec_string);
+ xmlNewProp(n2, BAD_CAST "type", BAD_CAST rec_string);
xmlNodeSetContent(n2, "");
xmlAddChild(n, n2);
this->connection_id, TNC_CONNECTION_STATE_HANDSHAKE);
charon->imcs->begin_handshake(charon->imcs, this->connection_id);
}
-
+
/* Do not allow any asynchronous IMCs or IMVs to add additional messages */
this->mutex->lock(this->mutex);
else
{
*buflen = data.len;
- }
+ }
memcpy(buf, data.ptr, *buflen);
this->batch->destroy(this->batch);
this->batch = NULL;
}
this->mutex->unlock(this->mutex);
- return status;
+ return status;
}
METHOD(tls_t, is_server, bool,
*/
struct pb_tnc_msg_info_t {
u_int32_t min_size;
- bool exact_size;
- bool in_result_batch;
- bool has_noskip_flag;
+ bool exact_size;
+ bool in_result_batch;
+ bool has_noskip_flag;
};
#define TRUE_OR_FALSE 2
TNC_UInt32 msg_len,
TNC_MessageType msg_type)
{
- TNC_MessageSubtype msg_sub_type;
- TNC_VendorID msg_vendor_id;
+ TNC_MessageSubtype msg_sub_type;
+ TNC_VendorID msg_vendor_id;
pb_tnc_msg_t *pb_tnc_msg;
pb_tnc_batch_type_t batch_type;
}
/**
- * Build a CRETRY or SRETRY batch
+ * Build a CRETRY or SRETRY batch
*/
static void build_retry_batch(private_tnccs_20_t *this)
{
data = chunk_create(buf, buflen);
DBG1(DBG_TNC, "received TNCCS batch (%u bytes) for Connection ID %u",
data.len, this->connection_id);
- DBG3(DBG_TNC, "%B", &data);
+ DBG3(DBG_TNC, "%B", &data);
batch = pb_tnc_batch_create_from_data(this->is_server, data);
status = batch->process(batch, this->state_machine);
else
{
*buflen = data.len;
- }
+ }
memcpy(buf, data.ptr, *buflen);
status = ALREADY_DONE;
}
typedef TNC_UInt32 TNC_IMV_Evaluation_Result;
typedef TNC_UInt32 TNC_AttributeID;
-
/* Function pointers */
typedef TNC_Result (*TNC_IMV_InitializePointer)(
- TNC_IMVID imvID,
- TNC_Version minVersion,
- TNC_Version maxVersion,
- TNC_Version *pOutActualVersion);
+ TNC_IMVID imvID,
+ TNC_Version minVersion,
+ TNC_Version maxVersion,
+ TNC_Version *pOutActualVersion);
typedef TNC_Result (*TNC_IMV_NotifyConnectionChangePointer)(
- TNC_IMVID imvID,
- TNC_ConnectionID connectionID,
- TNC_ConnectionState newState);
+ TNC_IMVID imvID,
+ TNC_ConnectionID connectionID,
+ TNC_ConnectionState newState);
typedef TNC_Result (*TNC_IMV_ReceiveMessagePointer)(
- TNC_IMVID imvID,
- TNC_ConnectionID connectionID,
- TNC_BufferReference message,
- TNC_UInt32 messageLength,
- TNC_MessageType messageType);
+ TNC_IMVID imvID,
+ TNC_ConnectionID connectionID,
+ TNC_BufferReference message,
+ TNC_UInt32 messageLength,
+ TNC_MessageType messageType);
typedef TNC_Result (*TNC_IMV_SolicitRecommendationPointer)(
- TNC_IMVID imvID,
- TNC_ConnectionID connectionID);
+ TNC_IMVID imvID,
+ TNC_ConnectionID connectionID);
typedef TNC_Result (*TNC_IMV_BatchEndingPointer)(
- TNC_IMVID imvID,
- TNC_ConnectionID connectionID);
+ TNC_IMVID imvID,
+ TNC_ConnectionID connectionID);
typedef TNC_Result (*TNC_IMV_TerminatePointer)(
- TNC_IMVID imvID);
+ TNC_IMVID imvID);
typedef TNC_Result (*TNC_TNCS_ReportMessageTypesPointer)(
- TNC_IMVID imvID,
- TNC_MessageTypeList supportedTypes,
- TNC_UInt32 typeCount);
+ TNC_IMVID imvID,
+ TNC_MessageTypeList supportedTypes,
+ TNC_UInt32 typeCount);
typedef TNC_Result (*TNC_TNCS_SendMessagePointer)(
- TNC_IMVID imvID,
- TNC_ConnectionID connectionID,
- TNC_BufferReference message,
- TNC_UInt32 messageLength,
- TNC_MessageType messageType);
+ TNC_IMVID imvID,
+ TNC_ConnectionID connectionID,
+ TNC_BufferReference message,
+ TNC_UInt32 messageLength,
+ TNC_MessageType messageType);
typedef TNC_Result (*TNC_TNCS_RequestHandshakeRetryPointer)(
- TNC_IMVID imvID,
- TNC_ConnectionID connectionID,
- TNC_RetryReason reason);
+ TNC_IMVID imvID,
+ TNC_ConnectionID connectionID,
+ TNC_RetryReason reason);
typedef TNC_Result (*TNC_TNCS_ProvideRecommendationPointer)(
- TNC_IMVID imvID,
- TNC_ConnectionID connectionID,
- TNC_IMV_Action_Recommendation recommendation,
- TNC_IMV_Evaluation_Result evaluation);
+ TNC_IMVID imvID,
+ TNC_ConnectionID connectionID,
+ TNC_IMV_Action_Recommendation recommendation,
+ TNC_IMV_Evaluation_Result evaluation);
typedef TNC_Result (*TNC_TNCS_GetAttributePointer)(
- TNC_IMVID imvID,
+ TNC_IMVID imvID,
TNC_ConnectionID connectionID,
TNC_AttributeID attributeID,
- TNC_UInt32 bufferLength,
- TNC_BufferReference buffer,
- TNC_UInt32 *pOutValueLength);
+ TNC_UInt32 bufferLength,
+ TNC_BufferReference buffer,
+ TNC_UInt32 *pOutValueLength);
typedef TNC_Result (*TNC_TNCS_SetAttributePointer)(
- TNC_IMVID imvID,
- TNC_ConnectionID connectionID,
+ TNC_IMVID imvID,
+ TNC_ConnectionID connectionID,
TNC_AttributeID attributeID,
- TNC_UInt32 bufferLength,
- TNC_BufferReference buffer);
+ TNC_UInt32 bufferLength,
+ TNC_BufferReference buffer);
typedef TNC_Result (*TNC_TNCS_BindFunctionPointer)(
- TNC_IMVID imvID,
- char *functionName,
- void **pOutfunctionPointer);
+ TNC_IMVID imvID,
+ char *functionName,
+ void **pOutfunctionPointer);
typedef TNC_Result (*TNC_IMV_ProvideBindFunctionPointer)(
- TNC_IMVID imvID,
- TNC_TNCS_BindFunctionPointer bindFunction);
+ TNC_IMVID imvID,
+ TNC_TNCS_BindFunctionPointer bindFunction);
/* Version Numbers */
projects / thirdparty / strongswan.git / commitdiff
