static void esif_ws_http_process_post (const char *buffer)
{
char *begPtr;
char *endPtr;
char *namebox;
char *nameboxVal = NULL;
char *passwordbox;
char *passwordboxVal = NULL;
size_t namebox_size;
size_t passwordbox_size;
printf("buffer from POST: %s\n", buffer);
namebox = strstr(buffer, "namebox");
if (namebox) {
begPtr = strchr((const char*)namebox, '=');
begPtr++;
endPtr = strchr(begPtr, '&');
namebox_size = endPtr - begPtr;
nameboxVal = (char*)esif_ccb_malloc(namebox_size + 1);
if (NULL == nameboxVal) {
exit(1);
}
esif_ccb_memcpy(nameboxVal, namebox + 8, namebox_size + 1);
nameboxVal[namebox_size] = 0;
printf("name: %s ", nameboxVal);
}
passwordbox = strstr(buffer, "passwordbox");
if (passwordbox) {
begPtr = strchr((const char*)passwordbox, '=');
begPtr++;
endPtr = strchr(begPtr, '&');
passwordbox_size = endPtr - begPtr;
passwordboxVal = (char*)esif_ccb_malloc(passwordbox_size + 1);
if (NULL == passwordboxVal) {
exit(1);
}
esif_ccb_memcpy(passwordboxVal, passwordbox + 12, passwordbox_size + 1);
passwordboxVal[passwordbox_size] = 0;
printf("password: %s\n", passwordboxVal);
}
if (nameboxVal) {
esif_ccb_free(nameboxVal);
}
if (passwordboxVal) {
esif_ccb_free(passwordboxVal);
}
}
static enum esif_rc esif_ccb_timer_obj_create(
const esif_ccb_timer_cb function_ptr, /* Callback when timer fires */
void *context_ptr, /* Callback context if any */
struct esif_timer_obj **timer_obj_ptr
)
{
enum esif_rc rc = ESIF_OK;
struct esif_timer_obj *new_timer_obj_ptr = NULL;
ESIF_ASSERT(function_ptr != NULL);
ESIF_ASSERT(timer_obj_ptr != NULL);
new_timer_obj_ptr = (struct esif_timer_obj *)esif_ccb_malloc(sizeof(*new_timer_obj_ptr));
if (NULL == new_timer_obj_ptr) {
rc = ESIF_E_NO_MEMORY;
goto exit;
}
rc = esif_ccb_timer_obj_create_timer(new_timer_obj_ptr);
if (rc != ESIF_OK)
goto exit;
new_timer_obj_ptr->function_ptr = function_ptr;
new_timer_obj_ptr->context_ptr = context_ptr;
*timer_obj_ptr = new_timer_obj_ptr;
exit:
if (rc != ESIF_OK)
esif_ccb_timer_obj_destroy(new_timer_obj_ptr);
return rc;
}
// Resize an IString buffer (if dynamically allocated)
ZString IString_Resize (
IStringPtr self,
u32 buf_len
)
{
ESIF_ASSERT(self);
// Allocate initial buffer if it has never been allocated
if (self->buf_ptr == 0) {
self->buf_ptr = esif_ccb_malloc(buf_len);
if (self->buf_ptr) {
self->buf_len = buf_len;
self->data_len = 1;
return (ZString)self->buf_ptr;
}
}
// Resize buffer if it is not a static string
if (self->buf_len > 0) {
ZString buf_ptr = (ZString)esif_ccb_realloc(self->buf_ptr, buf_len);
if (buf_ptr) {
if (buf_len > self->buf_len) {
esif_ccb_memset(buf_ptr + self->buf_len, 0, buf_len - self->buf_len);
}
self->buf_ptr = buf_ptr;
self->buf_len = buf_len;
return (ZString)self->buf_ptr;
}
}
return 0;
}
/* Data For Interface Marshaling */
static AppDomainDataPtr CreateDomainData(const struct esif_fpc_domain *domainPtr)
{
AppDomainDataPtr dom_data_ptr = (AppDomainDataPtr)esif_ccb_malloc(sizeof(AppDomainData));
ESIF_TRACE_DEBUG("%s\n", domainPtr->descriptor.name);
if (NULL == dom_data_ptr) {
goto exit;
}
dom_data_ptr->fName.buf_ptr = (void *)domainPtr->descriptor.name;
dom_data_ptr->fName.buf_len = ESIF_NAME_LEN;
dom_data_ptr->fName.data_len = (UInt32)esif_ccb_strlen(domainPtr->descriptor.name, ESIF_NAME_LEN);
dom_data_ptr->fName.type = ESIF_DATA_STRING;
dom_data_ptr->fDescription.buf_ptr = (void *)domainPtr->descriptor.description;
dom_data_ptr->fDescription.buf_len = ESIF_DESC_LEN;
dom_data_ptr->fDescription.data_len = (UInt32)esif_ccb_strlen(domainPtr->descriptor.description, ESIF_DESC_LEN);
dom_data_ptr->fDescription.type = ESIF_DATA_STRING;
dom_data_ptr->fGuid.buf_ptr = (void *)domainPtr->descriptor.guid;
dom_data_ptr->fGuid.buf_len = ESIF_GUID_LEN;
dom_data_ptr->fGuid.data_len = ESIF_GUID_LEN;
dom_data_ptr->fGuid.type = ESIF_DATA_GUID;
dom_data_ptr->fVersion = APP_DOMAIN_VERSION;
dom_data_ptr->fType = (enum esif_domain_type)domainPtr->descriptor.domainType;
dom_data_ptr->fCapability = domainPtr->capability_for_domain.capability_flags;
esif_ccb_memcpy(dom_data_ptr->fCapabilityBytes, domainPtr->capability_for_domain.capability_mask, 32);
exit:
return dom_data_ptr;
}
// constructors
IStringPtr IString_CreateAs (u32 buf_len)
{
IStringPtr self = IString_Create();
if (self && buf_len) {
IString_SetInstance(self, esif_ccb_malloc(buf_len), buf_len, 1);
}
return self;
}
DataBankPtr DataBank_Create ()
{
DataBankPtr self = (DataBankPtr)esif_ccb_malloc(sizeof(*self));
if (self) {
esif_ccb_lock_init(&self->lock);
}
return self;
}
// Automatically Load all Static DataVaults and *.dv files in the current folder into the DataBank
eEsifError DataBank_LoadDataVaults (DataBankPtr self)
{
eEsifError rc = ESIF_OK;
esif_ccb_file_find_handle find_handle = INVALID_HANDLE_VALUE;
char file_path[MAX_PATH] = {0};
char file_pattern[MAX_PATH] = {0};
struct esif_ccb_file *ffd_ptr;
UInt32 idx;
ASSERT(self);
// Import all Static DataVaults into ReadOnly DataVaults
for (idx = 0; g_StaticDataVaults[idx].name; idx++) {
DataVaultPtr DB = DataBank_OpenNameSpace(self, g_StaticDataVaults[idx].name);
if (DB) {
IOStream_SetMemory(DB->stream, g_StaticDataVaults[idx].buffer, g_StaticDataVaults[idx].buf_len);
DB->flags |= (ESIF_SERVICE_CONFIG_READONLY | ESIF_SERVICE_CONFIG_NOCACHE);
DataVault_ReadVault(DB);
}
}
// Create DataVault Directory if it doesn't exit
esif_build_path(file_path, sizeof(file_path), ESIF_PATHTYPE_DV, NULL, NULL);
esif_ccb_makepath(file_path);
// Import all matching *.dv files into ReadWrite DataVaults
esif_ccb_sprintf(MAX_PATH, file_pattern, "*%s", ESIFDV_FILEEXT);
ffd_ptr = (struct esif_ccb_file*)esif_ccb_malloc(sizeof(*ffd_ptr));
if (NULL == ffd_ptr) {
rc = ESIF_E_NO_MEMORY;
}
if (rc == ESIF_OK) {
find_handle = esif_ccb_file_enum_first(file_path, file_pattern, ffd_ptr);
}
if (INVALID_HANDLE_VALUE != find_handle) {
do {
struct esif_ccb_file dv_file = {0};
DataVaultPtr DB = 0;
// Read DataVault File, unless it's already been loaded as a Static DataVault
if (esif_ccb_strlen(ffd_ptr->filename, MAX_PATH) > sizeof(ESIFDV_FILEEXT)) {
ffd_ptr->filename[esif_ccb_strlen(ffd_ptr->filename, MAX_PATH) - (sizeof(ESIFDV_FILEEXT) - 1)] = 0; // Truncate ".dv" extension
if (DataBank_GetNameSpace(self, ffd_ptr->filename) == NULL) {
DB = DataBank_OpenNameSpace(self, ffd_ptr->filename);
if (DB) {
esif_build_path(dv_file.filename, sizeof(dv_file.filename), ESIF_PATHTYPE_DV, DB->name, ESIFDV_FILEEXT);
IOStream_SetFile(DB->stream, dv_file.filename, "rb");
DataVault_ReadVault(DB);
}
}
}
} while (esif_ccb_file_enum_next(find_handle, file_pattern, ffd_ptr));
esif_ccb_file_enum_close(find_handle);
}
esif_ccb_free(ffd_ptr);
return rc;
}
static void esif_ws_cgi_parse_query (
char *query,
const char *beg_parms_loc_in_query,
int fd,
char *cgi_dir
)
{
char *cgi_script;
char *cgi_script_buf;
// char *cgi_dir;
char cgiParms[100];
size_t cgi_script_size;
#define MAX_SIZE 100
cgi_script_size = query - beg_parms_loc_in_query;
cgi_script = (char*)esif_ccb_malloc(cgi_script_size + 1);
if (cgi_script == NULL) {
exit(1);
}
// cgi_dir = (char*)esif_ccb_malloc(esif_ccb_strlen(cgi_dir, MAX_SIZE) + cgi_script_size);
// if (cgi_dir == NULL)
// exit(1);
esif_ccb_memcpy(cgi_script, beg_parms_loc_in_query, cgi_script_size);
// esif_ccb_memcpy(cgi_dir, DIRECTORY, esif_ccb_strlen(DIRECTORY, MAX_SIZE));
cgi_script[cgi_script_size] = '\0';
// cgi_dir[esif_ccb_strlen(DIRECTORY, MAX_SIZE)]='\0';
printf("cgi_script 1: %s\n", cgi_script);
query++;
cgi_script_buf = cgi_script;
#ifdef ESIF_ATTR_OS_WINDOWS
cgi_script_buf = (char*)strrchr(cgi_script_buf, '/');
cgi_script_buf++;
cgi_script_buf[esif_ccb_strlen(cgi_script_buf, MAX_SIZE)] = '\0';
#endif
esif_ccb_strcpy(cgiParms, query, esif_ccb_strlen(query, MAX_SIZE));
printf("cgi_dir: %s\n", cgi_dir);
printf("cgiParms 1: %s\n", cgiParms);
esif_ccb_strcat(cgi_dir, cgi_script_buf, sizeof(cgi_dir));
esif_ws_cgi_redirect_output(cgi_dir, fd);
if (cgi_script) {
esif_ccb_free(cgi_script);
}
// if (cgi_dir)
// esif_ccb_free(cgi_dir);
}
static int esif_ws_http_is_authorized (const char *buffer)
{
char *begPtr;
char *endPtr;
char *namebox;
char *nameboxVal;
char *passwordbox;
char *passwordboxVal = NULL;
int result;
printf("esif_ws_http_is_authorized : Buffer received: %s\n", buffer);
namebox = strstr(buffer, "namebox");
if (namebox) {
begPtr = strchr((const char*)namebox, '=');
begPtr++;
endPtr = strchr(begPtr, '&');
nameboxVal = (char*)esif_ccb_malloc(endPtr - begPtr + 1);
esif_ccb_memcpy(nameboxVal, namebox + 8, endPtr - begPtr + 1);
nameboxVal[endPtr - begPtr] = 0;
printf("name: %s ", nameboxVal);
}
passwordbox = strstr(buffer, "passwordbox");
if (passwordbox) {
begPtr = strchr((const char*)passwordbox, '=');
begPtr++;
endPtr = strchr(begPtr, '&');
passwordboxVal = (char*)esif_ccb_malloc(endPtr - begPtr + 1);
esif_ccb_memcpy(passwordboxVal, passwordbox + 12, endPtr - begPtr + 1);
passwordboxVal[endPtr - begPtr] = 0;
printf("esif_ws_http_password: %s\n", passwordboxVal);
}
if (passwordboxVal && !strcmp(passwordboxVal, esif_ws_http_password)) {
result = 1;
} else {
result = 0;
}
return result;
}
// new operator
DataVaultPtr DataVault_Create(char* name)
{
DataVaultPtr self = (DataVaultPtr)esif_ccb_malloc(sizeof(*self));
DataVault_ctor(self);
esif_ccb_strcpy(self->name, name, sizeof(self->name));
esif_ccb_strlwr(self->name, sizeof(self->name));
return self;
}
// Read a Registry Key Value into a specified memory buffer
static eEsifError DataVault_ReadRegistry (
DataVaultPtr self,
esif_string keyname,
void * *buffer,
UInt32 *buf_size
)
{
eEsifError rc = ESIF_E_UNSPECIFIED;
HKEY hKey = 0;
DWORD dwFlags = RRF_RT_ANY;
DWORD dwError = 0;
DWORD dwSize = 0;
char *regkey = 0;
char *valuename = 0;
u32 j;
UNREFERENCED_PARAMETER(self);
// Format: HKLM\Subkey\Path\ValueName
for (j = 0; HKeyList[j].name; j++) {
size_t namelen = esif_ccb_strlen(HKeyList[j].name, 30);
if (esif_ccb_strnicmp(HKeyList[j].name, keyname, namelen) == 0 && keyname[namelen] == '\\') {
hKey = HKeyList[j].hkey;
keyname += esif_ccb_strlen(HKeyList[j].name, 30) + 1;
break;
}
}
if (!hKey) {
return rc;
}
regkey = esif_ccb_strdup(keyname);
if ((valuename = strrchr(regkey, '\\')) == 0) {
esif_ccb_free(regkey);
return rc;
}
*valuename++ = 0;
// Get Data Size from Registry and copy into buffer if found
if ((dwError = RegGetValueA(hKey, regkey, valuename, dwFlags, NULL, 0, &dwSize)) == 0) {
void *reg_buf = esif_ccb_malloc(dwSize);
dwError = RegGetValueA(hKey, regkey, valuename, dwFlags, NULL, reg_buf, &dwSize);
if (dwError == 0) {
*buffer = reg_buf;
*buf_size = dwSize;
rc = ESIF_OK;
} else {
esif_ccb_free(reg_buf);
}
} else {
rc = ESIF_E_NOT_FOUND;
}
esif_ccb_free(regkey);
return rc;
}
static struct esif_ht_node *esif_alloc_ht_node(
u8 *key_ptr,
u32 key_length,
void *item_ptr
)
{
enum esif_rc rc = ESIF_OK;
struct esif_ht_node *ht_node_ptr = NULL;
ESIF_ASSERT(key_ptr != NULL);
ht_node_ptr =
(struct esif_ht_node *)esif_ccb_malloc(sizeof(*ht_node_ptr));
if (ht_node_ptr == NULL) {
ESIF_TRACE_ERROR("Unable to allocate HT node\n");
rc = ESIF_E_NO_MEMORY;
goto exit;
}
ht_node_ptr->key_ptr = esif_ccb_malloc(key_length);
if (ht_node_ptr->key_ptr == NULL) {
ESIF_TRACE_ERROR("Unable to allocate HT node key ptr\n");
rc = ESIF_E_NO_MEMORY;
goto exit;
}
esif_ccb_memcpy(ht_node_ptr->key_ptr, key_ptr, key_length);
ht_node_ptr->key_length = key_length;
ht_node_ptr->item_ptr = item_ptr;
exit:
if (rc != ESIF_OK) {
if (ht_node_ptr) {
if (ht_node_ptr->key_ptr)
esif_ccb_free(ht_node_ptr->key_ptr);
esif_ccb_free(ht_node_ptr);
ht_node_ptr = NULL;
}
}
return ht_node_ptr;
}
IStringPtr IString_CreateFrom (IStringPtr src)
{
IStringPtr self = IString_Create();
if (self && src) {
IString_SetInstance(self, esif_ccb_malloc(src->buf_len), src->buf_len, src->data_len);
if (self->buf_ptr) {
esif_ccb_strcpy((ZString)self->buf_ptr, (ZString)src->buf_ptr, src->data_len);
}
}
return self;
}
/* CPC Unpack */
enum esif_rc esif_cpc_unpack(
struct esif_lp_dsp *dsp_ptr,
const struct esif_data *req_data_ptr
)
{
struct esif_lp_cpc *cpc_ptr = NULL;
struct esif_cpc_header *cpc_header_ptr = NULL;
ESIF_TRACE_DYN_CPC("%s: START\n", ESIF_FUNC);
ESIF_TRACE_DYN_CPC("%s: dsp %p req_data %p cpc %p size %d\n",
ESIF_FUNC,
dsp_ptr,
req_data_ptr,
req_data_ptr->buf_ptr,
req_data_ptr->buf_len);
/* Validate Thourougly Here */
if (req_data_ptr->type != ESIF_DATA_DSP)
return ESIF_E_INVALID_REQUEST_TYPE;
if (req_data_ptr->buf_len < sizeof(struct esif_cpc_header))
return ESIF_E_CPC_SHORT;
cpc_ptr = (struct esif_lp_cpc *)req_data_ptr->buf_ptr;
cpc_header_ptr = (struct esif_cpc_header *)&cpc_ptr->header;
ESIF_TRACE_DYN_CPC(
"%s: code %s ver %x (%x,%x), signature %08x, version %x\n",
ESIF_FUNC,
cpc_header_ptr->code,
cpc_header_ptr->version,
cpc_header_ptr->ver_major,
cpc_header_ptr->ver_minor,
cpc_header_ptr->cpc.signature,
cpc_header_ptr->cpc.version);
if (cpc_header_ptr->cpc.signature != *(unsigned int *)"@CPC")
return ESIF_E_CPC_SIGNATURE;
/* Make a copy for now */
cpc_ptr = (struct esif_lp_cpc *)esif_ccb_malloc(req_data_ptr->buf_len);
if (NULL != cpc_ptr) {
esif_ccb_memcpy(cpc_ptr,
req_data_ptr->buf_ptr,
req_data_ptr->buf_len);
dsp_ptr->cpc_ptr = cpc_ptr;
esif_cpc_to_dsp(dsp_ptr);
}
ESIF_TRACE_DYN_CPC(" %s: STOP\n", ESIF_FUNC);
return ESIF_OK;
}
/* Data For Interface Marshaling */
static AppParticipantDataPtr CreateParticipantData(
const EsifUpPtr upPtr,
const EsifUpDataPtr upDataPtr
)
{
AppParticipantDataPtr app_data_ptr = NULL;
if (upPtr->fDspPtr == NULL) {
goto exit;
}
app_data_ptr = (AppParticipantDataPtr)esif_ccb_malloc(sizeof(AppParticipantData));
if (NULL == app_data_ptr) {
goto exit;
}
/* Common */
app_data_ptr->fVersion = upDataPtr->fVersion;
ASSIGN_DATA_GUID(app_data_ptr->fDriverType, upDataPtr->fDriverType);
ASSIGN_DATA_GUID(app_data_ptr->fDeviceType, upDataPtr->fDriverType);
ASSIGN_DATA_STRING(app_data_ptr->fName, upDataPtr->fName, ESIF_NAME_LEN);
ASSIGN_DATA_STRING(app_data_ptr->fDesc, upDataPtr->fDesc, ESIF_DESC_LEN);
ASSIGN_DATA_STRING(app_data_ptr->fDriverName, upDataPtr->fDriverName, ESIF_NAME_LEN);
ASSIGN_DATA_STRING(app_data_ptr->fDeviceName, upDataPtr->fDeviceName, ESIF_NAME_LEN);
ASSIGN_DATA_STRING(app_data_ptr->fDevicePath, upDataPtr->fDevicePath, ESIF_PATH_LEN);
app_data_ptr->fDomainCount = (u8)upPtr->fDspPtr->get_domain_count(upPtr->fDspPtr);
app_data_ptr->fBusEnumerator = upDataPtr->fEnumerator;
/* ACPI Device */
ASSIGN_DATA_STRING(app_data_ptr->fAcpiDevice, upDataPtr->fAcpiDevice, ESIF_NAME_LEN);
ASSIGN_DATA_STRING(app_data_ptr->fAcpiScope, upDataPtr->fAcpiScope, ESIF_SCOPE_LEN);
app_data_ptr->fAcpiType = upDataPtr->fAcpiType;
ASSIGN_DATA_STRING(app_data_ptr->fAcpiUID, upDataPtr->fAcpiUID, sizeof(app_data_ptr->fAcpiUID));
/* PCI Device */
app_data_ptr->fPciVendor = upDataPtr->fPciVendor;
app_data_ptr->fPciDevice = upDataPtr->fPciDevice;
app_data_ptr->fPciBus = upDataPtr->fPciBus;
app_data_ptr->fPciBusDevice = upDataPtr->fPciBusDevice;
app_data_ptr->fPciFunction = upDataPtr->fPciFunction;
app_data_ptr->fPciRevision = upDataPtr->fPciRevision;
app_data_ptr->fPciClass = upDataPtr->fPciClass;
app_data_ptr->fPciSubClass = upDataPtr->fPciSubClass;
app_data_ptr->fPciProgIf = upDataPtr->fPciProgIf;
exit:
return app_data_ptr;
}
// IPC Connect
eEsifError ipc_connect()
{
eEsifError rc = ESIF_OK;
int check_kernel_version = ESIF_TRUE;
ESIF_TRACE_ENTRY_INFO();
// Exit if IPC already connected
if (g_ipc_handle != ESIF_INVALID_HANDLE) {
return ESIF_OK;
}
// Connect to LF
g_ipc_handle = esif_ipc_connect((char *)SESSION_ID);
if (g_ipc_handle == ESIF_INVALID_HANDLE) {
ESIF_TRACE_WARN("ESIF LF is not available\n");
rc = ESIF_E_NO_LOWER_FRAMEWORK;
}
else {
char *outbuf = esif_ccb_malloc(OUT_BUF_LEN);
char *kern_str = (outbuf != NULL ? esif_cmd_info(outbuf) : NULL);
ESIF_TRACE_DEBUG("ESIF IPC Kernel Device Opened\n");
if (NULL != kern_str) {
// Extract just the Kernel LF Version from the result string
extract_kernel_version(kern_str, OUT_BUF_LEN);
// Bypass Kernel Version check for DEBUG builds
#if defined(ESIF_ATTR_DEBUG)
check_kernel_version = ESIF_FALSE;
#endif
// Validate Kernel LF version is compatible with UF version
if (check_kernel_version == ESIF_FALSE || esif_ccb_strcmp(kern_str, ESIF_VERSION) == 0) {
ESIF_TRACE_INFO("Kernel Version: %s\n", kern_str);
esif_ccb_sprintf(sizeof(g_esif_kernel_version), g_esif_kernel_version, "%s", kern_str);
}
else {
ESIF_TRACE_ERROR("ESIF_LF Version (%s) Incompatible with ESIF_UF Version (%s)\n", kern_str, ESIF_VERSION);
ipc_disconnect();
rc = ESIF_E_NOT_SUPPORTED;
}
}
esif_ccb_free(outbuf);
}
ESIF_TRACE_EXIT_INFO_W_STATUS(rc);
return rc;
}
// Load an External File into a specified memory buffer
static eEsifError ReadFileIntoBuffer(
esif_string filename,
void **buffer,
UInt32 *buf_size
)
{
eEsifError rc = ESIF_OK;
IOStreamPtr file = IOStream_Create();
BytePtr bufPtr = NULL;
size_t size = 0;
size_t bytesRead = 0;
if (IOStream_SetFile(file, filename, "rb") != EOK) {
rc = ESIF_E_IO_ERROR;
goto exit;
}
size = IOStream_GetSize(file);
bufPtr = (BytePtr) esif_ccb_malloc(size + 1);
if (NULL == bufPtr) {
rc = ESIF_E_NO_MEMORY;
goto exit;
}
if (IOStream_Open(file) != 0) {
rc = ESIF_E_IO_ERROR;
goto exit;
}
bytesRead = IOStream_ReadAt(file, bufPtr, size, 0);
if (bytesRead != size) {
rc = ESIF_E_IO_ERROR;
goto exit;
}
bufPtr[size] = 0;
*buffer = bufPtr;
*buf_size = (UInt32)size;
exit:
IOStream_Destroy(file);
if (rc != ESIF_OK) {
esif_ccb_free(bufPtr);
}
return rc;
}
static enum esif_rc esif_ccb_tmrm_create_tmrm_item(
const esif_ccb_timer_cb function_ptr, /* Callback when timer fires */
void *context_ptr, /* Callback context if any */
struct esif_tmrm_item **tmrm_item_ptr
)
{
enum esif_rc rc = ESIF_E_NO_MEMORY;
struct esif_tmrm_item *new_item_ptr = NULL;
struct esif_timer_obj *timer_obj_ptr = NULL;
esif_ccb_timer_handle_t handle = 0;
ESIF_ASSERT(tmrm_item_ptr != NULL);
ESIF_ASSERT(function_ptr != NULL);
new_item_ptr = (struct esif_tmrm_item *)
esif_ccb_malloc(sizeof(*new_item_ptr));
if (NULL == new_item_ptr)
goto exit;
new_item_ptr->destroy_list_ptr = esif_link_list_create();
if (NULL == new_item_ptr->destroy_list_ptr)
goto exit;
rc = esif_ccb_timer_obj_create(function_ptr,
context_ptr,
&timer_obj_ptr);
if (rc != ESIF_OK)
goto exit;
new_item_ptr->timer_obj_ptr = timer_obj_ptr;
rc = esif_ccb_tmrm_get_next_handle(&handle);
if (rc != ESIF_OK)
goto exit;
new_item_ptr->timer_handle = handle;
*tmrm_item_ptr = new_item_ptr;
exit:
if (rc != ESIF_OK)
esif_ccb_tmrm_destroy_tmrm_item(new_item_ptr);
return rc;
}
/* Create Hash Table */
struct esif_ht * esif_ht_create(
u32 size
)
{
u32 index = 0;
struct esif_ht *new_ht_ptr = NULL;
new_ht_ptr = (struct esif_ht *)
esif_ccb_mempool_zalloc(ESIF_MEMPOOL_TYPE_HASH2);
if (NULL == new_ht_ptr) {
ESIF_TRACE_ERROR("Cannot allocate mem for hash table\n");
ESIF_ASSERT(ESIF_FALSE);
goto exit;
}
new_ht_ptr->size = size;
new_ht_ptr->table = (struct esif_link_list **)
esif_ccb_malloc(sizeof(*new_ht_ptr->table) * size);
if (new_ht_ptr->table == NULL) {
esif_ccb_mempool_free(ESIF_MEMPOOL_TYPE_HASH2, new_ht_ptr);
new_ht_ptr = NULL;
goto exit;
}
for (index = 0; index < size; ++index) {
ESIF_TRACE_DYN_VERB("Create linked list %d\n", index);
new_ht_ptr->table[index] = esif_link_list_create();
if (new_ht_ptr->table[index] == NULL) {
ESIF_TRACE_DYN_VERB("Creation failed\n");
esif_ht_destroy(new_ht_ptr, NULL);
new_ht_ptr = NULL;
goto exit;
}
}
ESIF_TRACE_DYN_VERB("Have hash table %p\n", new_ht_ptr);
exit:
return new_ht_ptr;
}
static eEsifError EsifActMgr_CreatePossActList_Locked()
{
eEsifError rc = ESIF_OK;
struct esif_ccb_file curFile = {0};
esif_ccb_file_enum_t fileIter = {0};
char libPath[ESIF_LIBPATH_LEN];
char *dotPtr = NULL;
EsifActMgrEntryPtr newPossPtr = NULL;
EsifString filePattern = ESIF_UPE_FILE_PREFIX "*" ESIF_LIB_EXT;
g_actMgr.possibleActions = esif_link_list_create();
if (NULL == g_actMgr.possibleActions) {
rc = ESIF_E_NO_MEMORY;
goto exit;
}
/* Get the loadable action directory path */
esif_build_path(libPath, sizeof(libPath), ESIF_PATHTYPE_DLL, NULL, NULL);
fileIter = esif_ccb_file_enum_first(libPath, filePattern, &curFile);
if (INVALID_HANDLE_VALUE == fileIter) {
goto exit;
}
do {
newPossPtr = esif_ccb_malloc(sizeof(*newPossPtr));
if(NULL == newPossPtr) {
break;
}
dotPtr = esif_ccb_strchr(curFile.filename, '.');
if (dotPtr != NULL) {
*dotPtr = '\0';
newPossPtr->libName = (esif_string)esif_ccb_strdup(curFile.filename);
esif_link_list_add_at_back(g_actMgr.possibleActions, (void *)newPossPtr);
}
} while (esif_ccb_file_enum_next(fileIter, filePattern, &curFile));
esif_ccb_file_enum_close(fileIter);
exit:
return rc;
}
static void esif_ws_http_serve_cgi_scripts (
const char *buffer,
int fd
)
{
char *blankCharPtr;
char *endPtr;
char *uri;
size_t uri_size;
printf("CGI script\n");
blankCharPtr = strchr((const char*)buffer, ' ');
blankCharPtr++;
endPtr = strchr(blankCharPtr, ' ');
uri_size = endPtr - blankCharPtr;
uri = (char*)esif_ccb_malloc(uri_size + 1);
if (uri == NULL) {
exit(1);
}
esif_ccb_memcpy(uri, buffer + 4, uri_size + 1);
uri[uri_size] = 0;
printf("uri: %s\n", uri);
if (!strncmp(buffer, "POST ", 5)) {
esif_ws_http_process_post((const char*)buffer);
}
esif_ws_cgi_execute_cgi_script(uri, fd, g_server_root);
if (uri) {
esif_ccb_free(uri);
}
}
/* Translate User Space IPC to Kernel */
static struct esif_ipc *esif_ipc_user_to_kernel(struct esif_ipc *ipc_user_ptr)
{
int ipc_len = 0;
struct esif_ipc ipc_hdr = {0};
struct esif_ipc *ipc_ptr = NULL;
if (NULL == ipc_user_ptr)
return NULL;
/* Copy from user an error indicates how many bytes copied. */
if (copy_from_user(&ipc_hdr, ipc_user_ptr,
sizeof(struct esif_ipc)) > 0) {
return NULL;
}
/* Sanity Check */
if (ESIF_IPC_VERSION != ipc_hdr.version)
return NULL;
ESIF_TRACE_DYN_IPC(
"linux_%s: ipc version=%d, type=%d, data_len=%d, rc=%d\n",
__func__,
ipc_hdr.version,
ipc_hdr.type,
(int)ipc_hdr.data_len,
(int)ipc_hdr.return_code);
ipc_len = ipc_hdr.data_len + sizeof(struct esif_ipc);
ipc_ptr = esif_ccb_malloc(ipc_len);
if (NULL == ipc_ptr)
return NULL;
/* Copy from user an error indicates how many bytes copied. */
if (copy_from_user(ipc_ptr, ipc_user_ptr, ipc_len) > 0) {
esif_ccb_free(ipc_ptr);
return NULL;
}
return ipc_ptr;
}
/* Allocate IPC */
static struct esif_ipc *esif_ipc_alloc(
enum esif_ipc_type type,
u32 data_len
)
{
struct esif_ipc *ipc_ptr = NULL;
u32 ipc_size = sizeof(*ipc_ptr) + data_len;
ipc_ptr = (struct esif_ipc *)esif_ccb_malloc(ipc_size);
if (NULL == ipc_ptr)
return NULL;
ipc_ptr->version = ESIF_IPC_VERSION;
ipc_ptr->type = type;
ipc_ptr->data_len = data_len;
ipc_ptr->return_code = ESIF_OK;
ESIF_TRACE_DEBUG("IPC = %p, type = %d, size = %d data_len = %d\n",
ipc_ptr, type,
(int)ipc_size,
(int)data_len);
return ipc_ptr;
}
/* Allocate IPC */
struct esif_ipc *esif_ipc_alloc(
enum esif_ipc_type type,
u32 data_len
)
{
u32 ipc_size = data_len + sizeof(struct esif_ipc);
struct esif_ipc *ipc_ptr = (struct esif_ipc *)esif_ccb_malloc(ipc_size);
if (NULL == ipc_ptr)
return NULL;
ipc_ptr->version = ESIF_IPC_VERSION;
ipc_ptr->type = type;
ipc_ptr->data_len = data_len;
ipc_ptr->return_code = ESIF_OK;
#ifdef ESIF_ATTR_HMAC
esif_ccb_memcpy(ipc->hmac, x, ESIF_HMAC_LEN);
#endif
ESIF_TRACE_DEBUG("%s: ipc = %p, type = %d, size = %d data_len = %d\n",
ESIF_FUNC, ipc_ptr, type, (int)ipc_size,
(int)data_len);
return ipc_ptr;
}
/* Data For Interface Marshaling */
static AppDataPtr CreateAppData(esif_string pathBuf)
{
AppDataPtr app_data_ptr = NULL;
char policyPath[ESIF_PATH_LEN] = { 0 };
if (NULL == pathBuf) {
ESIF_TRACE_ERROR("Path buffer is NULL\n");
goto exit;
}
/* Build path(s) for DPTF: "HomeDir" or "HomeDir|[#]PolicyDir" */
esif_build_path(pathBuf, ESIF_PATH_LEN, ESIF_PATHTYPE_DPTF, NULL, NULL);
esif_build_path(policyPath, sizeof(policyPath), ESIF_PATHTYPE_DLL, NULL, NULL);
if (esif_ccb_strcmp(pathBuf, policyPath) != 0) {
char policyDummyPath[ESIF_PATH_LEN] = { 0 }; /* empty if path starts with "#" */
esif_build_path(policyDummyPath, sizeof(policyDummyPath), ESIF_PATHTYPE_DLL, "", NULL);
esif_ccb_sprintf_concat(ESIF_PATH_LEN, pathBuf, "|%s%s", (policyDummyPath[0] ? "" : "#"), policyPath);
}
ESIF_TRACE_DEBUG("pathBuf=%s\n\n", (esif_string)pathBuf);
app_data_ptr = (AppDataPtr)esif_ccb_malloc(sizeof(AppData));
if (NULL == app_data_ptr) {
ESIF_TRACE_ERROR("Fail to allocate AppData\n");
goto exit;
}
app_data_ptr->fPathHome.buf_ptr = (void *)pathBuf;
app_data_ptr->fPathHome.buf_len = ESIF_PATH_LEN;
app_data_ptr->fPathHome.data_len = (UInt32)esif_ccb_strlen(pathBuf, ESIF_PATH_LEN);
app_data_ptr->fPathHome.type = ESIF_DATA_STRING;
app_data_ptr->fLogLevel = (eLogType) g_traceLevel;
exit:
return app_data_ptr;
}
static eEsifError EsifActMgr_CreateEntry(
EsifActMgrEntryPtr* entryPtr
)
{
eEsifError rc = ESIF_OK;
EsifActMgrEntryPtr newEntryPtr = NULL;
if (NULL == entryPtr) {
rc = ESIF_E_PARAMETER_IS_NULL;
goto exit;
}
newEntryPtr = esif_ccb_malloc(sizeof(*newEntryPtr));
if (NULL == newEntryPtr) {
rc = ESIF_E_NO_MEMORY;
goto exit;
}
newEntryPtr->upInstance = ACT_MGR_NO_UPINSTANCE;
*entryPtr = newEntryPtr;
exit:
return rc;
}
static eEsifError EsifEventMgr_AddEntry(
EsifFpcEventPtr fpcEventPtr,
UInt8 participantId,
UInt16 domainId,
EVENT_OBSERVER_CALLBACK eventCallback,
void *contextPtr
)
{
eEsifError rc = ESIF_OK;
EsifLinkListPtr listPtr = NULL;
EsifLinkListNodePtr nodePtr = NULL;
EventMgrEntryPtr curEntryPtr = NULL;
EventMgrEntryPtr newEntryPtr = NULL;
atomic_t refCount = 1;
ESIF_ASSERT(eventCallback != NULL);
esif_ccb_write_lock(&g_EsifEventMgr.listLock);
listPtr = g_EsifEventMgr.observerLists[fpcEventPtr->esif_event % NUM_EVENT_LISTS];
if(NULL == listPtr) {
rc = ESIF_E_UNSPECIFIED;
esif_ccb_write_unlock(&g_EsifEventMgr.listLock);
goto exit;
}
/*
* First verify we don't already have the same entry.
* If we do, just increment the reference count.
*/
nodePtr = listPtr->head_ptr;
while (nodePtr != NULL) {
curEntryPtr = (EventMgrEntryPtr) nodePtr->data_ptr;
if ((curEntryPtr->fpcEvent.esif_event == fpcEventPtr->esif_event) &&
(curEntryPtr->participantId == participantId) &&
(curEntryPtr->domainId == domainId) &&
(curEntryPtr->contextPtr == contextPtr) &&
(curEntryPtr->callback == eventCallback)){
break;
}
nodePtr = nodePtr->next_ptr;
}
/* If we found an existing entry, update the reference count */
if (nodePtr != NULL) {
atomic_inc(&curEntryPtr->refCount);
esif_ccb_write_unlock(&g_EsifEventMgr.listLock);
goto exit;
}
esif_ccb_write_unlock(&g_EsifEventMgr.listLock);
/*
* If an matching observer entry was not present; create a new observer entry,
* enable the events, and then place it into the list
*/
newEntryPtr = esif_ccb_malloc(sizeof(*newEntryPtr));
if (NULL == newEntryPtr) {
rc = ESIF_E_NO_MEMORY;
goto exit;
}
newEntryPtr->callback = eventCallback;
newEntryPtr->contextPtr = contextPtr;
newEntryPtr->domainId = domainId;
newEntryPtr->participantId = participantId;
newEntryPtr->refCount = refCount;
esif_ccb_memcpy(&newEntryPtr->fpcEvent, fpcEventPtr, sizeof(newEntryPtr->fpcEvent));
nodePtr = esif_link_list_create_node(newEntryPtr);
if (NULL == nodePtr) {
rc = ESIF_E_NO_MEMORY;
goto exit;
}
esif_ccb_write_lock(&g_EsifEventMgr.listLock);
esif_link_list_add_node_at_back(listPtr, nodePtr);
esif_ccb_write_unlock(&g_EsifEventMgr.listLock);
rc = EsifEventMgr_EnableEvent(newEntryPtr);
if (ESIF_OK != rc)
{
esif_ccb_write_lock(&g_EsifEventMgr.listLock);
esif_link_list_node_remove(listPtr, nodePtr);
esif_ccb_write_unlock(&g_EsifEventMgr.listLock);
goto exit;
}
exit:
ESIF_TRACE_DEBUG(" RefCount: " ATOMIC_FMT "\n", refCount);
if (ESIF_OK != rc) {
esif_ccb_free(newEntryPtr);
}
return rc;
}
eEsifError ESIF_CALLCONV EsifEventMgr_SignalEvent(
UInt8 participantId,
UInt16 domainId,
eEsifEventType eventType,
const EsifDataPtr eventDataPtr
)
{
eEsifError rc = ESIF_OK;
EsifEventQueueItemPtr queueEventPtr = NULL;
EsifDataPtr queueDataPtr = NULL;
if (NULL == g_EsifEventMgr.eventQueuePtr) { /* Should never happen */
rc = ESIF_E_UNSPECIFIED;
goto exit;
}
queueEventPtr = esif_ccb_malloc(sizeof(*queueEventPtr));
if (NULL == queueEventPtr) {
rc = ESIF_E_NO_MEMORY;
goto exit;
}
if ((eventDataPtr != NULL) &&
(eventDataPtr->buf_ptr != NULL) &&
(eventDataPtr->buf_len > 0) &&
(eventDataPtr->data_len > 0) &&
(eventDataPtr->buf_len >= eventDataPtr->data_len)) {
queueDataPtr = esif_ccb_malloc(eventDataPtr->data_len);
if (NULL == queueDataPtr) {
rc = ESIF_E_NO_MEMORY;
goto exit;
}
esif_ccb_memcpy(queueDataPtr, eventDataPtr->buf_ptr, eventDataPtr->data_len);
queueEventPtr->eventData.type = eventDataPtr->type;
queueEventPtr->eventData.buf_ptr = queueDataPtr;
queueEventPtr->eventData.buf_len = eventDataPtr->data_len;
queueEventPtr->eventData.data_len = eventDataPtr->data_len;
}
queueEventPtr->participantId = participantId;
queueEventPtr->domainId = domainId;
queueEventPtr->eventType = eventType;
ESIF_TRACE_INFO("Queuing %s event for Part. %u Dom. 0x%04X\n",
esif_event_type_str(eventType),
participantId,
domainId);
rc = esif_queue_enqueue(g_EsifEventMgr.eventQueuePtr, queueEventPtr);
if (rc != ESIF_OK) {
goto exit;
}
exit:
if (rc != ESIF_OK) {
esif_ccb_free(queueEventPtr);
esif_ccb_free(queueDataPtr);
}
return rc;
}
/* Create participant */
EsifUpPtr EsifUpManagerCreateParticipant(
const eEsifParticipantOrigin origin,
const void *handle,
const void *metadataPtr
)
{
EsifUpPtr up_ptr = NULL;
EsifUpManagerEntryPtr entry_ptr = NULL;
UInt8 i = 0;
UInt8 lpInstance;
/* Lock manager */
esif_ccb_write_lock(&g_uppMgr.fLock);
/* Validate parameters */
if (NULL == handle || NULL == metadataPtr) {
ESIF_TRACE_ERROR("Invalid handle or meta data pointer\n");
goto exit;
}
lpInstance = *(UInt8 *)handle;
/*
* Check if a participant has already been created, but was then removed.
* In that case, just re-enable the participant.
*/
entry_ptr = EsifUpManagerGetParticipantEntryFromMetadata(origin, metadataPtr);
if (NULL != entry_ptr) {
up_ptr = entry_ptr->fUpPtr;
entry_ptr->fState = ESIF_PM_PARTICIPANT_STATE_CREATED;
g_uppMgr.fEntryCount++;
goto exit;
}
/* Allocate a particpant */
up_ptr = (EsifUpPtr)esif_ccb_malloc(sizeof(EsifUp));
if (NULL == up_ptr) {
ESIF_TRACE_ERROR("Fail to allocate EsifUp\n");
ESIF_ASSERT(up_ptr != NULL);
goto exit;
}
/*
** Find available slot in participant manager table. Simple Table Lookup For Now.
** Scan table and find first empty slot. Empty slot indicated by AVAILABLE state.
*/
for (i = 0; i < MAX_PARTICIPANT_ENTRY; i++) {
if (ESIF_PM_PARTICIPANT_STATE_AVAILABLE == g_uppMgr.fEntries[i].fState) {
break;
}
}
/* If no available slots return */
if (i >= MAX_PARTICIPANT_ENTRY) {
ESIF_TRACE_ERROR("No available slot in participant manager\n");
esif_ccb_free(up_ptr);
up_ptr = NULL;
goto exit;
}
/* Take slot */
g_uppMgr.fEntries[i].fState = ESIF_PM_PARTICIPANT_STATE_CREATED;
g_uppMgr.fEntryCount++;
/* Initialize participant */
up_ptr->fInstance = i;
up_ptr->fEnabled = ESIF_TRUE;
/* Initialize based on origin */
switch (origin) {
case eParticipantOriginLF:
UpInitializeOriginLF(up_ptr, lpInstance, metadataPtr);
break;
case eParticipantOriginUF:
UpInitializeOriginUF(up_ptr, metadataPtr);
break;
default:
break;
}
/* Unlock manager */
g_uppMgr.fEntries[i].fUpPtr = up_ptr;
ESIF_TRACE_INFO("The participant data of %s is created in ESIF UF, instance = %d\n", up_ptr->fMetadata.fName, i);
exit:
esif_ccb_write_unlock(&g_uppMgr.fLock);
return up_ptr;
}
static eEsifError ActionCreate(
EsifActPtr actionPtr,
GetIfaceFuncPtr ifaceFuncPtr
)
{
eEsifError rc = ESIF_OK;
EsifActTypePtr action_type_ptr = NULL;
EsifData p1 = {ESIF_DATA_STRING, "action_iD", sizeof("action_id")};
EsifData p2 = {ESIF_DATA_STRING, "domain_qualifier", sizeof("domain_qaulifier")};
EsifData p3 = {ESIF_DATA_UINT32, "kernel_abi_type", sizeof("Kernel_abi_type")};
EsifData p4 = {ESIF_DATA_UINT8, "mode", sizeof("mode")};
char name[ESIF_NAME_LEN] = {0};
ESIF_DATA(data_name, ESIF_DATA_STRING, name, ESIF_NAME_LEN);
char desc[ESIF_DESC_LEN] = {0};
ESIF_DATA(data_desc, ESIF_DATA_STRING, desc, ESIF_DESC_LEN);
char version[ESIF_DESC_LEN] = {0};
ESIF_DATA(data_version, ESIF_DATA_STRING, version, ESIF_DESC_LEN);
UInt32 action_type_id = 0;
EsifData action_type = {ESIF_DATA_UINT32, &action_type_id, sizeof(action_type_id), 0};
esif_guid_t guid = {0};
EsifData data_guid = {ESIF_DATA_GUID, &guid, sizeof(guid), 0};
EsifString act_type_ptr = NULL;
EsifInterface act_service_iface;
ESIF_ASSERT(actionPtr != NULL);
ESIF_ASSERT(ifaceFuncPtr != NULL);
/* Assign the EsifInterface Functions */
act_service_iface.fIfaceType = eIfaceTypeEsifService;
act_service_iface.fIfaceVersion = 1;
act_service_iface.fIfaceSize = (UInt16)sizeof(EsifInterface);
act_service_iface.fGetConfigFuncPtr = EsifSvcConfigGet;
act_service_iface.fSetConfigFuncPtr = EsifSvcConfigSet;
act_service_iface.fPrimitiveFuncPtr = EsifSvcPrimitiveExec;
act_service_iface.fWriteLogFuncPtr = EsifSvcWriteLog;
act_service_iface.fRegisterEventFuncPtr = EsifSvcEventRegister;
act_service_iface.fUnregisterEventFuncPtr = EsifSvcEventUnregister;
/* GetApplicationInterface Handleshake send ESIF receive APP Interface */
rc = ifaceFuncPtr(&actionPtr->fInterface);
if (ESIF_OK != rc) {
goto exit;
}
/* Check EsifAppInterface */
if (actionPtr->fInterface.fIfaceType != eIfaceTypeAction ||
actionPtr->fInterface.fIfaceSize != (UInt16)sizeof(EsifActInterface) ||
actionPtr->fInterface.fIfaceVersion != 1 ||
/* Functions Pointers */
actionPtr->fInterface.fActCreateFuncPtr == NULL ||
actionPtr->fInterface.fActDestroyFuncPtr == NULL ||
actionPtr->fInterface.fActGetAboutFuncPtr == NULL ||
actionPtr->fInterface.fActGetDescriptionFuncPtr == NULL ||
actionPtr->fInterface.fActGetFuncPtr == NULL ||
actionPtr->fInterface.fActGetIDFuncPtr == NULL ||
actionPtr->fInterface.fActGetGuidFuncPtr == NULL ||
actionPtr->fInterface.fActGetNameFuncPtr == NULL ||
actionPtr->fInterface.fActGetStateFuncPtr == NULL ||
actionPtr->fInterface.fActGetStatusFuncPtr == NULL ||
actionPtr->fInterface.fActGetVersionFuncPtr == NULL ||
actionPtr->fInterface.fActSetFuncPtr == NULL ||
actionPtr->fInterface.fActSetStateFuncPtr == NULL) {
ESIF_TRACE_ERROR("The required function pointer in EsifActInterface is NULL\n");
goto exit;
}
/* Callback for application information */
rc = actionPtr->fInterface.fActGetNameFuncPtr(&data_name);
if (ESIF_OK != rc) {
goto exit;
}
rc = actionPtr->fInterface.fActGetDescriptionFuncPtr(&data_desc);
if (ESIF_OK != rc) {
goto exit;
}
rc = actionPtr->fInterface.fActGetVersionFuncPtr(&data_version);
if (ESIF_OK != rc) {
goto exit;
}
rc = actionPtr->fInterface.fActGetIDFuncPtr(&action_type);
if (ESIF_OK != rc) {
goto exit;
}
rc = actionPtr->fInterface.fActGetGuidFuncPtr(&data_guid);
if (ESIF_OK != rc) {
goto exit;
}
act_type_ptr = "plugin";
ESIF_TRACE_DEBUG("%s\n\n"
"Action Name : %s\n"
"Action Desc : %s\n"
"Action Type : %s\n"
"Action Version: %s\n\n",
ESIF_FUNC,
(EsifString)data_name.buf_ptr,
(EsifString)data_desc.buf_ptr,
(EsifString)act_type_ptr,
(EsifString)data_version.buf_ptr);
/* Create The Application */
CMD_OUT("create action\n");
rc = actionPtr->fInterface.fActCreateFuncPtr(
&act_service_iface,
NULL,
&actionPtr->fHandle,
eEsifActStateEnabled,
&p1,
&p2,
&p3,
&p4,
NULL);
if (ESIF_OK != rc) {
goto exit;
}
/* Append New Action To Linked List */
action_type_ptr = (EsifActTypePtr)esif_ccb_malloc(sizeof(EsifActType));
if (NULL == action_type_ptr) {
ESIF_TRACE_ERROR("Fail to allocate EsifActType\n");
rc = ESIF_E_NO_MEMORY;
goto exit;
}
action_type_ptr->fHandle = actionPtr->fHandle;
action_type_ptr->fType = *(UInt8 *)action_type.buf_ptr;
esif_ccb_strcpy(action_type_ptr->fName,
(EsifString)data_name.buf_ptr, ESIF_NAME_LEN);
esif_ccb_strcpy(action_type_ptr->fDesc,
(EsifString)data_desc.buf_ptr, ESIF_DESC_LEN);
esif_ccb_strcpy(action_type_ptr->fOsType, ESIF_ATTR_OS, ESIF_NAME_LEN);
action_type_ptr->fGetFuncPtr = actionPtr->fInterface.fActGetFuncPtr;
action_type_ptr->fSetFuncPtr = actionPtr->fInterface.fActSetFuncPtr;
esif_ccb_memcpy(action_type_ptr->fGuid, data_guid.buf_ptr, ESIF_GUID_LEN);
action_type_ptr->fIsKernel = ESIF_FALSE;
action_type_ptr->fIsPlugin = ESIF_TRUE;
/* Register Action */
if (NULL != g_actMgr.AddActType) {
rc = g_actMgr.AddActType(&g_actMgr, action_type_ptr);
} else {
ESIF_TRACE_ERROR("Fail to add action type since g_actMrg.AddActType is NULL\n");
esif_ccb_free(action_type_ptr);
rc = ESIF_E_NO_CREATE;
}
exit:
return rc;
}
