/**
* Described in header.
*/
bool libimcv_init(void)
{
/* initialize libstrongswan library only once */
if (lib)
{
/* did main program initialize libstrongswan? */
if (libstrongswan_ref == 0)
{
ref_get(&libstrongswan_ref);
}
}
else
{
/* we are the first to initialize libstrongswan */
if (!library_init(NULL))
{
return FALSE;
}
if (!lib->plugins->load(lib->plugins, NULL,
"sha1 sha2 random gmp pubkey x509"))
{
library_deinit();
return FALSE;
}
/* set the debug level and stderr output */
imcv_debug_level = lib->settings->get_int(lib->settings,
"libimcv.debug_level", IMCV_DEBUG_LEVEL);
imcv_stderr_quiet = lib->settings->get_int(lib->settings,
"libimcv.stderr_quiet", FALSE);
/* activate the imcv debugging hook */
dbg = imcv_dbg;
openlog("imcv", 0, LOG_DAEMON);
}
ref_get(&libstrongswan_ref);
if (libimcv_ref == 0)
{
/* initialize the PA-TNC attribute manager */
imcv_pa_tnc_attributes = pa_tnc_attr_manager_create();
imcv_pa_tnc_attributes->add_vendor(imcv_pa_tnc_attributes, PEN_IETF,
ietf_attr_create_from_data, ietf_attr_names);
imcv_pa_tnc_attributes->add_vendor(imcv_pa_tnc_attributes, PEN_ITA,
ita_attr_create_from_data, ita_attr_names);
DBG1(DBG_LIB, "libimcv initialized");
}
ref_get(&libimcv_ref);
return TRUE;
}
/**
* Described in header.
*/
bool libpts_init(void)
{
if (libpts_ref == 0)
{
if (!imcv_pa_tnc_attributes)
{
return FALSE;
}
imcv_pa_tnc_attributes->add_vendor(imcv_pa_tnc_attributes, PEN_TCG,
tcg_attr_create_from_data, tcg_attr_names);
pts_components = pts_component_manager_create();
pts_components->add_vendor(pts_components, PEN_TCG,
pts_tcg_comp_func_names, PTS_TCG_QUALIFIER_TYPE_SIZE,
pts_tcg_qualifier_flag_names, pts_tcg_qualifier_type_names);
pts_components->add_vendor(pts_components, PEN_ITA,
pts_ita_comp_func_names, PTS_ITA_QUALIFIER_TYPE_SIZE,
pts_ita_qualifier_flag_names, pts_ita_qualifier_type_names);
pts_components->add_component(pts_components, PEN_ITA,
PTS_ITA_COMP_FUNC_NAME_TGRUB,
pts_ita_comp_tgrub_create);
pts_components->add_component(pts_components, PEN_ITA,
PTS_ITA_COMP_FUNC_NAME_TBOOT,
pts_ita_comp_tboot_create);
pts_components->add_component(pts_components, PEN_ITA,
PTS_ITA_COMP_FUNC_NAME_IMA,
pts_ita_comp_ima_create);
DBG1(DBG_LIB, "libpts initialized");
}
ref_get(&libpts_ref);
return TRUE;
}
int
rb_uniform_ref_get(struct rb_uniform* uniform)
{
if(!uniform)
return -1;
ref_get(&uniform->ref);
return 0;
}
int
rb_vertex_array_ref_get(struct rb_vertex_array* array)
{
if(!array)
return -1;
ref_get(&array->ref);
return 0;
}
int
rb_context_ref_get(struct rb_context* ctxt)
{
if(!ctxt)
return -1;
ref_get(&ctxt->ref);
return 0;
}
enum edit_error
edit_picking_ref_get(struct edit_picking* picking)
{
if(UNLIKELY(!picking))
return EDIT_INVALID_ARGUMENT;
ref_get(&picking->ref);
return EDIT_NO_ERROR;
}
/*******************************************************************************
*
* Picking functions
*
******************************************************************************/
enum edit_error
edit_create_picking
(struct app* app,
struct edit_imgui* imgui,
struct edit_model_instance_selection* instance_selection,
struct mem_allocator* allocator,
struct edit_picking** out_picking)
{
struct edit_picking* picking = NULL;
enum edit_error edit_err = EDIT_NO_ERROR;
enum sl_error sl_err = SL_NO_ERROR;
if(UNLIKELY(!app || !instance_selection || !allocator || !out_picking)) {
edit_err = EDIT_INVALID_ARGUMENT;
goto error;
}
picking = MEM_CALLOC(allocator, 1, sizeof(struct edit_picking));
if(!picking) {
edit_err = EDIT_MEMORY_ERROR;
goto error;
}
ref_init(&picking->ref);
APP(ref_get(app));
picking->app = app;
EDIT(imgui_ref_get(imgui));
picking->imgui = imgui;
EDIT(model_instance_selection_ref_get(instance_selection));
picking->instance_selection = instance_selection;
picking->allocator = allocator;
sl_err = sl_create_hash_table
(sizeof(uint32_t),
ALIGNOF(uint32_t),
sizeof(uint32_t),
ALIGNOF(uint32_t),
hash_uint32,
eq_uint32,
allocator,
&picking->picked_instances_htbl);
if(sl_err != SL_NO_ERROR) {
edit_err = sl_to_edit_error(sl_err);
goto error;
}
exit:
if(out_picking)
*out_picking = picking;
return edit_err;
error:
if(picking) {
EDIT(picking_ref_put(picking));
picking = NULL;
}
goto exit;
}
/**
* Start timer
*
* @v timer Retry timer
*
* This starts the timer running with the current timeout value. If
* stop_timer() is not called before the timer expires, the timer will
* be stopped and the timer's callback function will be called.
*/
void start_timer ( struct retry_timer *timer ) {
if ( ! timer->running ) {
list_add ( &timer->list, &timers );
ref_get ( timer->refcnt );
}
timer->start = currticks();
timer->running = 1;
/* 0 means "use default timeout" */
if ( timer->min_timeout == 0 )
timer->min_timeout = DEFAULT_MIN_TIMEOUT;
/* We must never be less than MIN_TIMEOUT under any circumstances */
if ( timer->min_timeout < MIN_TIMEOUT )
timer->min_timeout = MIN_TIMEOUT;
/* Honor user-specified minimum timeout */
if ( timer->timeout < timer->min_timeout )
timer->timeout = timer->min_timeout;
DBG2 ( "Timer %p started at time %ld (expires at %ld)\n",
timer, timer->start, ( timer->start + timer->timeout ) );
}
struct bytes *bytes_get(struct bytes *bytes)
{
ref_get(&bytes->ref);
return bytes;
}
/**
* Increment reference count on an object interface
*
* @v intf Object interface
* @ret intf Object interface
*/
struct interface * intf_get ( struct interface *intf ) {
ref_get ( intf->refcnt );
return intf;
}
/**
* Add ACPI descriptor
*
* @v desc ACPI descriptor
*/
void acpi_add ( struct acpi_descriptor *desc ) {
/* Add to list of descriptors */
ref_get ( desc->refcnt );
list_add_tail ( &desc->list, &desc->model->descs );
}
/**
* Described in header.
*/
bool libimcv_init(bool is_imv)
{
/* initialize libstrongswan library only once */
if (lib)
{
/* did main program initialize libstrongswan? */
if (libstrongswan_ref == 0)
{
ref_get(&libstrongswan_ref);
}
}
else
{
/* we are the first to initialize libstrongswan */
if (!library_init(NULL, "libimcv"))
{
return FALSE;
}
/* set the debug level and stderr output */
imcv_debug_level = lib->settings->get_int(lib->settings,
"libimcv.debug_level", IMCV_DEBUG_LEVEL);
imcv_stderr_quiet = lib->settings->get_int(lib->settings,
"libimcv.stderr_quiet", FALSE);
/* activate the imcv debugging hook */
dbg = imcv_dbg;
#ifdef HAVE_SYSLOG
openlog("imcv", 0, LOG_DAEMON);
#endif
if (!lib->plugins->load(lib->plugins,
lib->settings->get_str(lib->settings, "libimcv.load",
"random nonce gmp pubkey x509")))
{
library_deinit();
return FALSE;
}
}
ref_get(&libstrongswan_ref);
lib->settings->add_fallback(lib->settings, "%s.imcv", "libimcv", lib->ns);
lib->settings->add_fallback(lib->settings, "%s.plugins", "libimcv.plugins",
lib->ns);
if (libimcv_ref == 0)
{
char *uri, *script;
/* initialize the PA-TNC attribute manager */
imcv_pa_tnc_attributes = pa_tnc_attr_manager_create();
imcv_pa_tnc_attributes->add_vendor(imcv_pa_tnc_attributes, PEN_IETF,
ietf_attr_create_from_data, ietf_attr_names);
imcv_pa_tnc_attributes->add_vendor(imcv_pa_tnc_attributes, PEN_ITA,
ita_attr_create_from_data, ita_attr_names);
imcv_pa_tnc_attributes->add_vendor(imcv_pa_tnc_attributes, PEN_TCG,
tcg_attr_create_from_data, tcg_attr_names);
imcv_pts_components = pts_component_manager_create();
imcv_pts_components->add_vendor(imcv_pts_components, PEN_TCG,
pts_tcg_comp_func_names, PTS_TCG_QUALIFIER_TYPE_SIZE,
pts_tcg_qualifier_flag_names, pts_tcg_qualifier_type_names);
imcv_pts_components->add_vendor(imcv_pts_components, PEN_ITA,
pts_ita_comp_func_names, PTS_ITA_QUALIFIER_TYPE_SIZE,
pts_ita_qualifier_flag_names, pts_ita_qualifier_type_names);
imcv_pts_components->add_component(imcv_pts_components, PEN_ITA,
PTS_ITA_COMP_FUNC_NAME_TGRUB,
pts_ita_comp_tgrub_create);
imcv_pts_components->add_component(imcv_pts_components, PEN_ITA,
PTS_ITA_COMP_FUNC_NAME_TBOOT,
pts_ita_comp_tboot_create);
imcv_pts_components->add_component(imcv_pts_components, PEN_ITA,
PTS_ITA_COMP_FUNC_NAME_IMA,
pts_ita_comp_ima_create);
if (is_imv)
{
/* instantiate global IMV session manager */
imcv_sessions = imv_session_manager_create();
/* instantiate and attach global IMV database if URI is valid */
uri = lib->settings->get_str(lib->settings,
"%s.imcv.database", NULL, lib->ns);
script = lib->settings->get_str(lib->settings,
"%s.imcv.policy_script", IMCV_DEFAULT_POLICY_SCRIPT,
lib->ns);
if (uri)
{
imcv_db = imv_database_create(uri, script);
}
}
DBG1(DBG_LIB, "libimcv initialized");
}
ref_get(&libimcv_ref);
return TRUE;
}
/*******************************************************************************
*
* Buffer functions.
*
******************************************************************************/
int
rb_create_buffer
(struct rb_context* ctxt,
const struct rb_buffer_desc* public_desc,
const void* init_data,
struct rb_buffer** out_buffer)
{
const struct rb_ogl3_buffer_desc private_desc = {
.size = public_desc->size,
.target = public_to_private_rb_target(public_desc->target),
.usage = public_desc->usage
};
return rb_ogl3_create_buffer(ctxt, &private_desc,init_data, out_buffer);
}
int
rb_buffer_ref_get(struct rb_buffer* buffer)
{
if(!buffer)
return -1;
ref_get(&buffer->ref);
return 0;
}
int
rb_buffer_ref_put(struct rb_buffer* buffer)
{
if(!buffer)
return -1;
ref_put(&buffer->ref, release_buffer);
return 0;
}
int
rb_bind_buffer
(struct rb_context* ctxt,
struct rb_buffer* buffer,
enum rb_buffer_target target)
{
return rb_ogl3_bind_buffer(ctxt, buffer, public_to_private_rb_target(target));
}
int
rb_buffer_data
(struct rb_buffer* buffer,
int offset,
int size,
const void* data)
{
void* mapped_mem = NULL;
GLboolean unmap = GL_FALSE;
if(!buffer
|| (offset < 0)
|| (size < 0)
|| (size != 0 && !data)
|| (buffer->size < offset + size))
return -1;
if(size == 0)
return 0;
OGL(BindBuffer(buffer->target, buffer->name));
if(offset == 0 && size == buffer->size) {
mapped_mem = OGL(MapBuffer(buffer->target, GL_WRITE_ONLY));
} else {
const GLbitfield access = GL_MAP_WRITE_BIT;
mapped_mem = OGL(MapBufferRange(buffer->target, offset, size, access));
}
ASSERT(mapped_mem != NULL);
memcpy(mapped_mem, data, (size_t)size);
unmap = OGL(UnmapBuffer(buffer->target));
OGL(BindBuffer
(buffer->target,
buffer->ctxt->state_cache.buffer_binding[buffer->binding]));
/* unmap == GL_FALSE must be handled by the application. TODO return a real
* error code to differentiate this case from the error. */
return unmap == GL_TRUE ? 0 : -1;
}
