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);
}
}
void DataBank_CloseNameSpace (
DataBankPtr self,
esif_string nameSpace
)
{
UInt32 ns;
esif_ccb_write_lock(&self->lock);
// Find Existing NameSpace
for (ns = 0; ns < self->size; ns++) {
if (esif_ccb_stricmp(nameSpace, self->elements[ns].name) == 0) {
DataVault_dtor(&self->elements[ns]);
// Move Array Items down one and wipe the final item
for ( ; ns + 1 < self->size; ns++)
esif_ccb_memcpy(&self->elements[ns], &self->elements[ns + 1], sizeof(self->elements[ns]));
if (ns < ESIF_MAX_NAME_SPACES) {
WIPEPTR(&self->elements[ns]);
}
self->size--;
}
}
esif_ccb_write_unlock(&self->lock);
}
void SupportedPolicyList::update(void)
{
m_guid.clear();
// TODO: This should be moved to a DPTF Initialization class. For now, ignore empty result buffer
DptfBuffer ignore = m_dptfManager->getEsifServices()->primitiveExecuteGet(
esif_primitive_type::GET_DPTF_CONFIGURATION, ESIF_DATA_BINARY);
DptfBuffer buffer = m_dptfManager->getEsifServices()->primitiveExecuteGet(
esif_primitive_type::GET_SUPPORTED_POLICIES, ESIF_DATA_BINARY);
if ((buffer.size() % sizeof(AcpiEsifGuid)) != 0)
{
std::stringstream message;
message << "Received invalid data length [" << buffer.size() << "] from primitive call: GET_SUPPORTED_POLICIES";
throw dptf_exception(message.str());
}
UInt32 guidCount = buffer.size() / sizeof(AcpiEsifGuid);
AcpiEsifGuid* acpiEsifGuid = reinterpret_cast<AcpiEsifGuid*>(buffer.get());
for (UInt32 i = 0; i < guidCount; i++)
{
UInt8 guidByteArray[GuidSize] = {0};
esif_ccb_memcpy(guidByteArray, &acpiEsifGuid[i].uuid, GuidSize);
Guid guid(guidByteArray);
m_dptfManager->getEsifServices()->writeMessageInfo("Supported GUID: " + guid.toString());
m_guid.push_back(guid);
}
}
/* 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;
}
static void esif_ws_cgi_parse_script (
const char *resourceLoc,
int fd,
char *full_script_name
)
{
char abbr_script_name[100];
u32 i = 0;
esif_ccb_memcpy(abbr_script_name, resourceLoc, esif_ccb_strlen(resourceLoc, MAX_SIZE));
abbr_script_name[esif_ccb_strlen(resourceLoc, MAX_SIZE)] = 0;
printf("cgi script name: %s\n", abbr_script_name);
i = i; // to satisfy compiler
#ifdef ESIF_ATTR_OS_WINDOWS
for (i = 0; i < esif_ccb_strlen(abbr_script_name, MAX_SIZE); i++)
if (abbr_script_name[i] == '/') {
abbr_script_name[i] = '\\';
}
#endif
esif_ccb_strcat(full_script_name, abbr_script_name, sizeof(full_script_name));
printf("full_cgi_script_name: %s\n", full_script_name);
esif_ws_cgi_redirect_output(full_script_name, fd);
}
/* Get Debug Module Level */
static void esif_execute_ipc_command_get_debug_module_level(
struct esif_ipc_command *command_ptr
)
{
/* Sanity Check */
if (ESIF_DATA_STRUCTURE == command_ptr->rsp_data_type &&
0 == command_ptr->rsp_data_offset &&
sizeof(struct esif_command_get_debug_module_level) ==
command_ptr->rsp_data_len) {
struct esif_command_get_debug_module_level *data_ptr =
(struct esif_command_get_debug_module_level *)
(command_ptr + 1);
data_ptr->modules = g_esif_module_mask;
esif_ccb_memcpy(&data_ptr->levels,
&g_esif_module_category_mask,
sizeof(g_esif_module_category_mask));
data_ptr->tracelevel = g_esif_trace_level;
ESIF_TRACE_DYN_COMMAND(
"%s: ESIF_COMMAND_TYPE_GET_DEBUG_MODULE_LEVEL "
"modules 0x%08X\n",
ESIF_FUNC,
data_ptr->modules);
command_ptr->return_code = ESIF_OK;
}
}
/*
Map upper participant metadata to upper particpant instance. A participant
that is created from the upperframework will never have a lower framework
component. These participants are to cover the case were we either have no
Kernel corresponding participant or in some cases we may not even have a
lower frame work present.
*/
static void UpInitializeOriginUF(
const EsifUpPtr upPtr,
const void *upMetadataPtr
)
{
/* Upper Participant Metadata Format */
EsifParticipantIfacePtr metadata_ptr =
(EsifParticipantIfacePtr)upMetadataPtr;
ESIF_ASSERT(upPtr != NULL);
ESIF_ASSERT(metadata_ptr != NULL);
/* Store Lower Framework Instance */
upPtr->fLpInstance = 255; /* Not Used */
/* Common */
upPtr->fMetadata.fVersion = metadata_ptr->version;
upPtr->fMetadata.fEnumerator = (enum esif_participant_enum)metadata_ptr->enumerator;
upPtr->fMetadata.fFlags = metadata_ptr->flags;
esif_ccb_memcpy(&upPtr->fMetadata.fDriverType, &metadata_ptr->class_guid, ESIF_GUID_LEN);
esif_ccb_strcpy(upPtr->fMetadata.fName, metadata_ptr->name, ESIF_NAME_LEN);
esif_ccb_strcpy(upPtr->fMetadata.fDesc, metadata_ptr->desc, ESIF_DESC_LEN);
esif_ccb_strcpy(upPtr->fMetadata.fDriverName, metadata_ptr->driver_name, ESIF_NAME_LEN);
esif_ccb_strcpy(upPtr->fMetadata.fDeviceName, metadata_ptr->device_name, ESIF_NAME_LEN);
esif_ccb_strcpy(upPtr->fMetadata.fDevicePath, metadata_ptr->device_path, ESIF_PATH_LEN);
esif_ccb_strcpy(upPtr->fMetadata.fAcpiScope, metadata_ptr->object_id, ESIF_SCOPE_LEN);
}
void EsifDataGuid::initialize(const UInt8 guid[GuidSize])
{
esif_ccb_memcpy(m_guid, guid, GuidSize);
m_esifData.type = esif_data_type::ESIF_DATA_GUID;
m_esifData.buf_ptr = m_guid;
m_esifData.buf_len = GuidSize;
m_esifData.data_len = GuidSize;
}
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;
}
void PolicyServicesPlatformNotification::executeOsc(const Guid& guid, UInt32 oscCapabilities)
{
Bool successful = false;
struct esif_data_complex_osc osc;
esif_ccb_memcpy(osc.guid, guid, Guid::GuidSize);
osc.revision = 1;
osc.count = 2;
osc.status = 0;
osc.capabilities = oscCapabilities;
std::string failureMessage;
try
{
getEsifServices()->primitiveExecuteSet(
SET_OPERATING_SYSTEM_CAPABILITIES,
ESIF_DATA_STRUCTURE,
&osc,
sizeof(esif_data_complex_osc),
sizeof(esif_data_complex_osc));
successful = true;
}
catch (std::exception& ex)
{
failureMessage = ex.what();
}
catch (...)
{
failureMessage = "Unknown error.";
}
if (osc.status & 0xE)
{
if (osc.status & 0x2)
{
throw dptf_exception("Platform supports _OSC but unable to process _OSC request.");
}
if (osc.status & 0x4)
{
throw dptf_exception("Platform failed _OSC Reason: Unrecognized UUID.");
}
if (osc.status & 0x8)
{
throw dptf_exception("Platform failed _OSC Reason: Unrecognized revision.");
}
}
if (successful == false)
{
throw dptf_exception("Failure during execution of _OSC: " + failureMessage);
}
}
/* 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;
}
std::vector<Guid> SupportedPolicyList::parseBufferForPolicyGuids(const DptfBuffer& buffer)
{
UInt32 guidCount = buffer.size() / sizeof(AcpiEsifGuid);
AcpiEsifGuid* acpiEsifGuid = reinterpret_cast<AcpiEsifGuid*>(buffer.get());
std::vector<Guid> guids;
for (UInt32 i = 0; i < guidCount; i++)
{
UInt8 guidByteArray[GuidSize] = { 0 };
esif_ccb_memcpy(guidByteArray, &acpiEsifGuid[i].uuid, GuidSize);
guids.push_back(Guid(guidByteArray));
}
return guids;
}
/*
** Map lower participant metadata to upper participant instance. Every
** lower participant must have a corresponding upper particpant. Here we
** intialize the data from the upper participant from the lower participant
** registration data.
*/
static void UpInitializeOriginLF(
const EsifUpPtr upPtr,
const UInt8 lpInstance,
const void *lpMetadataPtr
)
{
/* Lower Framework Participant Metadata Format */
struct esif_ipc_event_data_create_participant *metadata_ptr =
(struct esif_ipc_event_data_create_participant *)lpMetadataPtr;
ESIF_ASSERT(upPtr != NULL);
ESIF_ASSERT(metadata_ptr != NULL);
/* Store Lower Framework Instance. */
upPtr->fLpInstance = lpInstance;
/* Common */
upPtr->fMetadata.fVersion = metadata_ptr->version;
upPtr->fMetadata.fEnumerator = (enum esif_participant_enum)metadata_ptr->enumerator;
upPtr->fMetadata.fFlags = metadata_ptr->flags;
esif_ccb_memcpy(&upPtr->fMetadata.fDriverType, &metadata_ptr->class_guid, ESIF_GUID_LEN);
esif_ccb_strcpy(upPtr->fMetadata.fName, metadata_ptr->name, ESIF_NAME_LEN);
esif_ccb_strcpy(upPtr->fMetadata.fDesc, metadata_ptr->desc, ESIF_DESC_LEN);
esif_ccb_strcpy(upPtr->fMetadata.fDriverName, metadata_ptr->driver_name, ESIF_NAME_LEN);
esif_ccb_strcpy(upPtr->fMetadata.fDeviceName, metadata_ptr->device_name, ESIF_NAME_LEN);
esif_ccb_strcpy(upPtr->fMetadata.fDevicePath, metadata_ptr->device_path, ESIF_PATH_LEN);
/* ACPI */
esif_ccb_strcpy(upPtr->fMetadata.fAcpiUID, metadata_ptr->acpi_uid, sizeof(upPtr->fMetadata.fAcpiUID));
upPtr->fMetadata.fAcpiType = metadata_ptr->acpi_type;
esif_ccb_strcpy(upPtr->fMetadata.fAcpiDevice, metadata_ptr->acpi_device, ESIF_NAME_LEN);
esif_ccb_strcpy(upPtr->fMetadata.fAcpiScope, metadata_ptr->acpi_scope, ESIF_SCOPE_LEN);
/* PCI */
upPtr->fMetadata.fPciVendor = (u16)metadata_ptr->pci_vendor;
upPtr->fMetadata.fPciDevice = (u16)metadata_ptr->pci_device;
upPtr->fMetadata.fPciBus = metadata_ptr->pci_bus;
upPtr->fMetadata.fPciBusDevice = metadata_ptr->pci_bus_device;
upPtr->fMetadata.fPciFunction = metadata_ptr->pci_function;
upPtr->fMetadata.fPciRevision = metadata_ptr->pci_revision;
upPtr->fMetadata.fPciClass = metadata_ptr->pci_class;
upPtr->fMetadata.fPciSubClass = metadata_ptr->pci_sub_class;
upPtr->fMetadata.fPciProgIf = metadata_ptr->pci_prog_if;
}
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;
}
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);
}
}
/* 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;
}
/*
*******************************************************************************
** PUBLIC
*******************************************************************************
*/
void esif_ws_http_copy_server_root (char *dir)
{
#define MAX_LENGTH 200
esif_ccb_memcpy(g_server_root, dir, esif_ccb_strlen(dir, MAX_LENGTH));
}
/* Get Participants */
static void esif_execute_ipc_command_get_participants(
struct esif_ipc_command *command_ptr
)
{
/* Sanity Check */
if (ESIF_DATA_STRUCTURE == command_ptr->rsp_data_type &&
0 == command_ptr->rsp_data_offset &&
sizeof(struct esif_command_get_participants) ==
command_ptr->rsp_data_len) {
u8 i = 0;
struct esif_command_get_participants *data_ptr =
(struct esif_command_get_participants *)
(command_ptr + 1);
ESIF_TRACE_DYN_COMMAND(
"%s: ESIF_COMMAND_TYPE_GET_PARTICIPANTS\n",
ESIF_FUNC);
for (i = 0; i < MAX_PARTICIPANT_ENTRY; i++) {
struct esif_lp *lp_ptr =
esif_lf_pm_lp_get_by_instance_id(i);
if (NULL != lp_ptr) {
data_ptr->participant_info[i].id = i;
esif_ccb_strcpy(
data_ptr->participant_info[i].name,
lp_ptr->pi_ptr->name,
ESIF_NAME_LEN);
esif_ccb_strcpy(
data_ptr->participant_info[i].desc,
lp_ptr->pi_ptr->desc,
ESIF_DESC_LEN);
esif_ccb_memcpy(
data_ptr->participant_info[i].class_guid,
lp_ptr->pi_ptr->class_guid,
ESIF_GUID_LEN);
data_ptr->participant_info[i].version =
lp_ptr->pi_ptr->version;
data_ptr->participant_info[i].bus_enum =
lp_ptr->pi_ptr->enumerator;
data_ptr->participant_info[i].state =
esif_lf_pm_lp_get_state(lp_ptr);
if (NULL != lp_ptr->dsp_ptr) {
esif_ccb_strcpy(
data_ptr->participant_info[i].dsp_code,
lp_ptr->dsp_ptr->get_code(
lp_ptr->dsp_ptr),
ESIF_DSP_NAME_LEN);
data_ptr->participant_info[i].dsp_ver_major =
lp_ptr->dsp_ptr->get_ver_major(
lp_ptr->dsp_ptr);
data_ptr->participant_info[i].
dsp_ver_minor =
lp_ptr->dsp_ptr->get_ver_minor(
lp_ptr->dsp_ptr);
}
} else {
data_ptr->participant_info[i].id = i;
if (1 == i) {
esif_ccb_strcpy(
data_ptr->participant_info[i].desc,
"RESERVED",
ESIF_DESC_LEN);
} else {
}
}
}
data_ptr->count = i;
command_ptr->return_code = ESIF_OK;
}
}
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;
}
/* Get Participant */
static void esif_execute_ipc_command_get_participant_detail(
struct esif_ipc_command *command_ptr
)
{
/* Sanity Check */
if (ESIF_DATA_STRUCTURE == command_ptr->rsp_data_type &&
0 == command_ptr->rsp_data_offset &&
sizeof(struct esif_command_get_participant_detail) ==
command_ptr->rsp_data_len) {
struct esif_command_get_participant_detail *data_ptr =
(struct esif_command_get_participant_detail *)(
command_ptr + 1);
/* ID Will Be In Buffer ON Arrival */
u32 participant_id = *(u32 *) data_ptr;
ESIF_TRACE_DYN_COMMAND(
"%s: ESIF_COMMAND_TYPE_PARTICIPANT_DETAIL id %d\n",
ESIF_FUNC,
participant_id);
{
struct esif_lp *lp_ptr =
esif_lf_pm_lp_get_by_instance_id((u8)participant_id);
if (NULL != lp_ptr) {
/* Participant Info */
data_ptr->id = participant_id;
data_ptr->version = lp_ptr->pi_ptr->version;
data_ptr->enumerator =
lp_ptr->pi_ptr->enumerator;
esif_ccb_strcpy(data_ptr->name,
lp_ptr->pi_ptr->name,
ESIF_NAME_LEN);
esif_ccb_strcpy(data_ptr->desc,
lp_ptr->pi_ptr->desc,
ESIF_DESC_LEN);
esif_ccb_strcpy(data_ptr->driver_name,
lp_ptr->pi_ptr->driver_name,
ESIF_NAME_LEN);
esif_ccb_strcpy(data_ptr->device_name,
lp_ptr->pi_ptr->device_name,
ESIF_NAME_LEN);
esif_ccb_strcpy(data_ptr->device_path,
lp_ptr->pi_ptr->device_path,
ESIF_PATH_LEN);
esif_ccb_memcpy(data_ptr->class_guid,
lp_ptr->pi_ptr->class_guid,
ESIF_GUID_LEN);
data_ptr->flags = lp_ptr->pi_ptr->flags;
/* ACPI */
esif_ccb_strcpy(data_ptr->acpi_device,
lp_ptr->pi_ptr->acpi_device,
ESIF_NAME_LEN);
esif_ccb_strcpy(data_ptr->acpi_scope,
lp_ptr->pi_ptr->acpi_scope,
ESIF_SCOPE_LEN);
esif_ccb_strcpy(data_ptr->acpi_uid,
lp_ptr->pi_ptr->acpi_uid,
sizeof(data_ptr->acpi_uid));
data_ptr->acpi_type = lp_ptr->pi_ptr->acpi_type;
/* PCI */
data_ptr->pci_vendor =
(u16)lp_ptr->pi_ptr->pci_vendor;
data_ptr->pci_device =
(u16)lp_ptr->pi_ptr->pci_device;
data_ptr->pci_bus =
lp_ptr->pi_ptr->pci_bus;
data_ptr->pci_bus_device =
lp_ptr->pi_ptr->pci_bus_device;
data_ptr->pci_function =
lp_ptr->pi_ptr->pci_function;
data_ptr->pci_revision =
lp_ptr->pi_ptr->pci_revision;
data_ptr->pci_class =
lp_ptr->pi_ptr->pci_class;
data_ptr->pci_sub_class =
lp_ptr->pi_ptr->pci_sub_class;
data_ptr->pci_prog_if =
lp_ptr->pi_ptr->pci_prog_if;
/* LP */
data_ptr->state =
esif_lf_pm_lp_get_state(lp_ptr);
data_ptr->timer_period =
lp_ptr->domains[0].timer_period_msec;
if (NULL != lp_ptr->dsp_ptr) {
/* Have DSP */
data_ptr->have_dsp = 1;
esif_ccb_strcpy(data_ptr->dsp_code,
lp_ptr->dsp_ptr->get_code(
lp_ptr->dsp_ptr),
ESIF_DSP_NAME_LEN);
data_ptr->dsp_ver_major =
lp_ptr->dsp_ptr->get_ver_major(
lp_ptr->dsp_ptr);
data_ptr->dsp_ver_minor =
lp_ptr->dsp_ptr->get_ver_minor(
lp_ptr->dsp_ptr);
if (NULL != lp_ptr->dsp_ptr->cpc_ptr) {
/* Have CPC */
data_ptr->have_cpc = 1;
data_ptr->cpc_version =
lp_ptr->dsp_ptr->cpc_ptr->header.version;
data_ptr->cpc_signature =
lp_ptr->dsp_ptr->cpc_ptr->header.cpc.signature;
data_ptr->cpc_size =
lp_ptr->dsp_ptr->cpc_ptr->size;
data_ptr->cpc_primitive_count =
lp_ptr->dsp_ptr->cpc_ptr->number_of_basic_primitives;
} /* cpc */
} /* dsp */
} /* lp */
} /* block */
command_ptr->return_code = ESIF_OK;
} /* if */
}
static eEsifError EsifSetActionDelegateRset(
const EsifUpDomainPtr domainPtr,
const EsifDataPtr requestPtr)
{
eEsifError rc = ESIF_E_PRIMITIVE_ACTION_FAILURE;
EsifPrimitiveTupleParameter parameters = { 0 };
EsifPrimitiveTuple tuple = { 0 };
Bool signal_event = ESIF_FALSE;
char domain_str[8] = { 0 };
int j = 0;
ESIF_ASSERT(domainPtr != NULL);
ESIF_ASSERT(requestPtr != NULL);
if (requestPtr->buf_ptr == NULL) {
rc = ESIF_E_PARAMETER_IS_NULL;
goto exit;
}
if (requestPtr->data_len != sizeof(parameters)) {
rc = ESIF_E_REQUEST_DATA_OUT_OF_BOUNDS;
goto exit;
}
// Convert BINARY Parameters to Primitive Tuple
esif_ccb_memcpy(¶meters, requestPtr->buf_ptr, sizeof(parameters));
ESIF_TRACE_DEBUG("CONFIG RESET: { %s (%hd), %s, %hd }\n",
esif_primitive_str(parameters.id.integer.value),
(u16)parameters.id.integer.value,
esif_primitive_domain_str((u16)parameters.domain.integer.value, domain_str, sizeof(domain_str)),
(u16)parameters.instance.integer.value
);
// Look up Primitive Tuple in the DSP and verify it is a valid SET primtive
EsifDspPtr dspPtr = EsifUp_GetDsp(domainPtr->upPtr);
if (dspPtr == NULL) {
rc = ESIF_E_NEED_DSP;
goto exit;
}
tuple.id = (u16) parameters.id.integer.value;
tuple.domain = (u16) parameters.domain.integer.value;
tuple.instance = (u16) parameters.instance.integer.value;
EsifFpcPrimitivePtr primitivePtr = dspPtr->get_primitive(dspPtr, &tuple);
if (primitivePtr == NULL) {
rc = ESIF_E_PRIMITIVE_NOT_FOUND_IN_DSP;
goto exit;
}
if (primitivePtr->operation != ESIF_PRIMITIVE_OP_SET) {
rc = ESIF_E_INVALID_REQUEST_TYPE;
goto exit;
}
// Find first CONFIG Action and Delete its Key from its DataVault
for (j = 0; j < (int)primitivePtr->num_actions; j++) {
EsifFpcActionPtr fpcActionPtr = dspPtr->get_action(dspPtr, primitivePtr, (u8)j);
DataItemPtr paramDataVault = EsifFpcAction_GetParam(fpcActionPtr, (const UInt8)0);
DataItemPtr paramKeyName = EsifFpcAction_GetParam(fpcActionPtr, (const UInt8)1);
EsifString expandedKeyName = NULL;
if (fpcActionPtr->type != ESIF_ACTION_CONFIG) {
continue;
}
if (paramDataVault == NULL || paramKeyName == NULL || paramDataVault->data_type != ESIF_DSP_PARAMETER_TYPE_STRING || paramKeyName->data_type != ESIF_DSP_PARAMETER_TYPE_STRING) {
rc = ESIF_E_PARAMETER_IS_OUT_OF_BOUNDS;
goto exit;
}
// Replace "%nm%" tokens in the key name or make a copy of the key name for static keys
expandedKeyName = EsifUp_CreateTokenReplacedParamString(domainPtr->upPtr, primitivePtr, (StringPtr)paramKeyName->data);
if (expandedKeyName == NULL) {
expandedKeyName = esif_ccb_strdup((StringPtr)paramKeyName->data);
if (expandedKeyName == NULL) {
rc = ESIF_E_NO_MEMORY;
goto exit;
}
}
// Valid SET CONFIG Primitive found with valid DV/Key Name; Delete the associated Key from the DataVault
EsifDataPtr data_nspace = EsifData_CreateAs(ESIF_DATA_STRING, (StringPtr)paramDataVault->data, 0, ESIFAUTOLEN);
EsifDataPtr data_key = EsifData_CreateAs(ESIF_DATA_STRING, expandedKeyName, 0, ESIFAUTOLEN);
// Do not signal an Event if Key does not exist in DataVault
if (DataBank_KeyExists(g_DataBankMgr, (StringPtr)paramDataVault->data, expandedKeyName) == ESIF_FALSE) {
rc = ESIF_OK;
}
else if (data_nspace == NULL || data_key == NULL) {
rc = ESIF_E_NO_MEMORY;
}
else {
// Delete Existing Key from DataVault
rc = EsifConfigDelete(data_nspace, data_key);
if (rc == ESIF_OK) {
signal_event = ESIF_TRUE;
}
ESIF_TRACE_DEBUG("CONFIG RESET: config delete @%s %s [rc=%s (%d)]\n",
(StringPtr)data_nspace->buf_ptr,
(StringPtr)data_key->buf_ptr,
esif_rc_str(rc),
rc
);
}
// Signal any Event(s) associated with this SET Primitive
if (signal_event) {
EsifActConfigSignalChangeEvents(domainPtr->upPtr, tuple, NULL);
}
EsifData_Destroy(data_nspace);
EsifData_Destroy(data_key);
esif_ccb_free(expandedKeyName);
break;
}
if (j >= (int)primitivePtr->num_actions) {
rc = ESIF_E_UNSUPPORTED_ACTION_TYPE;
}
exit:
return rc;
}
static eEsifError EsifGetActionDelegateCnfg(
const EsifUpDomainPtr domainPtr,
const EsifDataPtr requestPtr,
EsifDataPtr responsePtr
)
{
extern int g_shell_enabled; // ESIF Shell Enabled Flag
extern Bool g_ws_restricted;// Web Server Restricted Mode Flag
eEsifError rc = ESIF_OK;
EsifPrimitiveTuple dcfgTuple = { GET_CONFIG_ACCESS_CONTROL_SUR, 0, 255 };
EsifPrimitiveTuple gddvTuple = { GET_CONFIG_DATAVAULT_SUR, 0, 255 };
EsifData dcfgData = { ESIF_DATA_UINT32, NULL, ESIF_DATA_ALLOCATE, 0 };
EsifData gddvData = { ESIF_DATA_AUTO, NULL, ESIF_DATA_ALLOCATE, 0 };
ESIF_ASSERT(NULL != domainPtr);
ESIF_ASSERT(NULL != requestPtr);
UNREFERENCED_PARAMETER(responsePtr); // Not currently used by DPTF
dcfgTuple.domain = domainPtr->domain;
gddvTuple.domain = domainPtr->domain;
// Execute DCFG to read Access Control List Bitmask from BIOS, if it exists
rc = EsifUp_ExecutePrimitive(domainPtr->upPtr, &dcfgTuple, requestPtr, &dcfgData);
if (rc == ESIF_OK && dcfgData.buf_ptr != NULL && dcfgData.buf_len >= sizeof(UInt32)) {
DCfgOptions newmask = { .asU32 = *(UInt32 *)dcfgData.buf_ptr };
DCfg_Set(newmask);
ESIF_TRACE_INFO("DCFG Loaded: 0x%08X\n", newmask.asU32);
// Disable ESIF Shell if Access Control forbids it
if (DCfg_Get().opt.ShellAccessControl) {
g_shell_enabled = 0;
}
// Stop Web Server (if Started) if Restricted or Generic Access Control forbids it
if (EsifWebIsStarted() &&
((!g_ws_restricted && DCfg_Get().opt.GenericUIAccessControl)||
(g_ws_restricted && DCfg_Get().opt.RestrictedUIAccessControl)) ) {
EsifWebStop();
}
}
// Execute GDDV to read DataVault from BIOS, if it exists
rc = EsifUp_ExecutePrimitive(domainPtr->upPtr, &gddvTuple, requestPtr, &gddvData);
if (rc != ESIF_OK) {
// Always Return OK if no ESIF_LF or GDDV object in BIOS
if (rc == ESIF_E_NO_LOWER_FRAMEWORK || rc == ESIF_E_ACPI_OBJECT_NOT_FOUND) {
rc = ESIF_OK;
}
}
else {
char *dv_name = "__merge"; // Temporary DV Name
DataVaultPtr DB = DataBank_GetNameSpace(g_DataBankMgr, dv_name);
if (DB != NULL) {
DataBank_CloseNameSpace(g_DataBankMgr, dv_name);
}
DB = DataBank_OpenNameSpace(g_DataBankMgr, dv_name);
// Load Datavault into temporary namespace. DV may or may not be preceded by a variant
if (DB) {
u32 skipbytes = 0;
void *buffer = NULL;
//
// This is in place to resolve a static code analysis issue.
// This should never happen if EsifUp_ExecutePrimitive is successful above.
//
if (NULL == gddvData.buf_ptr) {
DataBank_CloseNameSpace(g_DataBankMgr, dv_name);
ESIF_TRACE_DEBUG("No data returned for BIOS datavault.\n");
goto exit;
}
skipbytes = (memcmp(gddvData.buf_ptr, "\xE5\x1F", 2) == 0 ? 0 : sizeof(union esif_data_variant));
buffer = esif_ccb_malloc(gddvData.data_len);
if (NULL == buffer) {
DataBank_CloseNameSpace(g_DataBankMgr, dv_name);
ESIF_TRACE_DEBUG("Unable to allocate memory\n");
rc = ESIF_E_NO_MEMORY;
goto exit;
}
esif_ccb_memcpy(buffer, (u8*)gddvData.buf_ptr + skipbytes, gddvData.data_len - skipbytes);
IOStream_SetMemory(DB->stream, buffer, gddvData.data_len - skipbytes);
if ((rc = DataVault_ReadVault(DB)) != ESIF_OK) {
DataBank_CloseNameSpace(g_DataBankMgr, dv_name);
ESIF_TRACE_DEBUG("Unable to Open DataVault: %s\n", esif_rc_str(rc));
rc = ESIF_OK;
}
else {
EsifDataPtr data_nspace = NULL;
EsifDataPtr data_key = NULL;
EsifDataPtr data_targetdv = NULL;
esif_flags_t options = 0; // NOPERSIST
esif_string keyspec = "*"; // Merge All Keys
esif_string targetdv = g_DataVaultDefault;
DB->flags |= (ESIF_SERVICE_CONFIG_READONLY);
// Merge Contents into Default DataVault
data_nspace = EsifData_CreateAs(ESIF_DATA_STRING, dv_name, 0, ESIFAUTOLEN);
data_targetdv = EsifData_CreateAs(ESIF_DATA_STRING, targetdv, 0, ESIFAUTOLEN);
data_key = EsifData_CreateAs(ESIF_DATA_STRING, keyspec, 0, ESIFAUTOLEN);
if (data_nspace == NULL || data_key == NULL || data_targetdv == NULL) {
rc = ESIF_E_NO_MEMORY;
}
else {
rc = EsifConfigCopy(data_nspace, data_targetdv, data_key, options, ESIF_FALSE, NULL);
}
ESIF_TRACE_INFO("GDDV Loaded: %d bytes, %d keys => %s.dv [%s]\n",
(int)IOStream_GetSize(DB->stream),
DataCache_GetCount(DB->cache),
targetdv,
esif_rc_str(rc));
EsifData_Destroy(data_nspace);
EsifData_Destroy(data_key);
EsifData_Destroy(data_targetdv);
DataBank_CloseNameSpace(g_DataBankMgr, dv_name);
}
esif_ccb_free(buffer);
}
}
exit:
esif_ccb_free(dcfgData.buf_ptr);
esif_ccb_free(gddvData.buf_ptr);
return rc;
}
Guid::Guid(const UInt8 guid[GuidSize])
: m_valid(true)
{
esif_ccb_memcpy(m_guid, guid, GuidSize);
}
/* Work Around */
static enum esif_rc get_participant_data(
struct esif_ipc_event_data_create_participant *pi_ptr,
UInt8 participantId
)
{
eEsifError rc = ESIF_OK;
struct esif_command_get_part_detail *data_ptr = NULL;
struct esif_ipc_command *command_ptr = NULL;
struct esif_ipc *ipc_ptr = NULL;
const u32 data_len = sizeof(struct esif_command_get_part_detail);
ipc_ptr = esif_ipc_alloc_command(&command_ptr, data_len);
if (NULL == ipc_ptr || NULL == command_ptr) {
ESIF_TRACE_ERROR("Fail to allocate esif_ipc/esif_ipc_command\n");
rc = ESIF_E_NO_MEMORY;
goto exit;
}
command_ptr->type = ESIF_COMMAND_TYPE_GET_PARTICIPANT_DETAIL;
command_ptr->req_data_type = ESIF_DATA_UINT32;
command_ptr->req_data_offset = 0;
command_ptr->req_data_len = 4;
command_ptr->rsp_data_type = ESIF_DATA_STRUCTURE;
command_ptr->rsp_data_offset = 0;
command_ptr->rsp_data_len = data_len;
// ID For Command
*(u32 *)(command_ptr + 1) = participantId;
rc = ipc_execute(ipc_ptr);
if (ESIF_OK != rc) {
goto exit;
}
if (ESIF_OK != ipc_ptr->return_code) {
rc = ipc_ptr->return_code;
ESIF_TRACE_WARN("ipc_ptr return_code failure - %s\n", esif_rc_str(rc));
goto exit;
}
if (ESIF_OK != command_ptr->return_code) {
rc = command_ptr->return_code;
ESIF_TRACE_WARN("command_ptr return_code failure - %s\n", esif_rc_str(rc));
goto exit;
}
// our data
data_ptr = (struct esif_command_get_part_detail *)(command_ptr + 1);
if (0 == data_ptr->version) {
ESIF_TRACE_ERROR("Participant version is 0\n");
goto exit;
}
pi_ptr->id = (u8)data_ptr->id;
pi_ptr->version = data_ptr->version;
esif_ccb_memcpy(pi_ptr->class_guid, data_ptr->class_guid, ESIF_GUID_LEN);
pi_ptr->enumerator = data_ptr->enumerator;
pi_ptr->flags = data_ptr->flags;
esif_ccb_strcpy(pi_ptr->name, data_ptr->name, ESIF_NAME_LEN);
esif_ccb_strcpy(pi_ptr->desc, data_ptr->desc, ESIF_DESC_LEN);
esif_ccb_strcpy(pi_ptr->driver_name, data_ptr->driver_name, ESIF_NAME_LEN);
esif_ccb_strcpy(pi_ptr->device_name, data_ptr->device_name, ESIF_NAME_LEN);
esif_ccb_strcpy(pi_ptr->device_path, data_ptr->device_path, ESIF_NAME_LEN);
/* ACPI */
esif_ccb_strcpy(pi_ptr->acpi_device, data_ptr->acpi_device, ESIF_NAME_LEN);
esif_ccb_strcpy(pi_ptr->acpi_scope, data_ptr->acpi_scope, ESIF_SCOPE_LEN);
esif_ccb_strcpy(pi_ptr->acpi_uid, data_ptr->acpi_uid, sizeof(pi_ptr->acpi_uid));
pi_ptr->acpi_type = data_ptr->acpi_type;
/* PCI */
pi_ptr->pci_vendor = data_ptr->pci_vendor;
pi_ptr->pci_device = data_ptr->pci_device;
pi_ptr->pci_bus = data_ptr->pci_bus;
pi_ptr->pci_bus_device = data_ptr->pci_bus_device;
pi_ptr->pci_function = data_ptr->pci_function;
pi_ptr->pci_revision = data_ptr->pci_revision;
pi_ptr->pci_class = data_ptr->pci_class;
pi_ptr->pci_sub_class = data_ptr->pci_sub_class;
pi_ptr->pci_prog_if = data_ptr->pci_prog_if;
exit:
if (NULL != ipc_ptr) {
esif_ipc_free(ipc_ptr);
}
return rc;
}
// Search and Replace
ZString IString_ReplaceIString (
IStringPtr self,
IStringPtr what,
IStringPtr with,
int IgnoreCase
)
{
ZString from, to, find;
u32 count, oldsize, newsize;
// Sanity checks. Cannot replace an empty string
ESIF_ASSERT(self && what && with);
if (self->data_len <= 1 || what->data_len <= 1) {
return 0;
}
// Count occurances of replacment string in original string
for (count = 0, find = (ZString)self->buf_ptr; (find = (ZString)strfind(find, (ZString)what->buf_ptr, IgnoreCase)) != NULL; count++)
find += what->data_len - 1;
// Compute new string size and Resize if necessary
oldsize = self->data_len;
newsize = self->data_len + (count * (int)(esif_ccb_max(with->data_len, 1) - what->data_len));
if (newsize > self->buf_len) {
#ifdef ISTRING_AUTOGROW
if (IString_Resize(self, newsize + ISTRING_AUTOGROW) == NULL)
#endif
return 0;
}
// Do an in-string replacement so that another copy of the string does not need to be allocated
// a) newsize <= oldsize: Do a left-to-right copy replacment
// b) newsize > oldsize: Move string to end of newsize buffer, then do a left-to-right copy replacement
from = to = (ZString)self->buf_ptr;
self->data_len = newsize;
if (newsize > oldsize) {
// Move string to end of reallocated (data_len) buffer
esif_ccb_memmove(((ZString)self->buf_ptr) + (newsize - oldsize), (ZString)self->buf_ptr, oldsize);
from += newsize - oldsize;
}
// Do a left-to-right copy (from -> to), replacing each occurance of old string (what) with new string (with)
while ((find = (ZString)strfind(from, (ZString)what->buf_ptr, IgnoreCase)) != NULL) {
if (from > to) {
esif_ccb_memcpy(to, from, (size_t)(find - from));
}
to += (size_t)(find - from);
if (with->data_len > 0) {
esif_ccb_memcpy(to, (ZString)with->buf_ptr, with->data_len - 1);
to += with->data_len - 1;
}
from = find + (what->data_len > 0 ? what->data_len - 1 : 0);
}
// Copy remainder of string, if any
if (to < from) {
esif_ccb_memcpy(to, from, newsize - (size_t)(to - (ZString)self->buf_ptr));
}
to += newsize - (size_t)(to - (ZString)self->buf_ptr);
// zero out remainder of old string, if any
if (oldsize > newsize) {
esif_ccb_memset(to, 0, oldsize - newsize);
}
return (ZString)self->buf_ptr;
}
static int esif_ws_http_server_static_pages (
char *buffer,
char *resource,
int fd,
ssize_t ret,
char *fileType
)
{
struct stat st;
char tmpbuffer[128];
char file_to_open[1000];
FILE *file_fp = NULL;
#define MAX_SIZE 200
esif_ccb_memcpy(file_to_open, g_server_root, esif_ccb_strlen(g_server_root, MAX_SIZE));
file_to_open[esif_ccb_strlen(g_server_root, MAX_SIZE)] = '\0';
// printf("file to open after esif_ccb_memcpy: %s\n", file_to_open);
// printf("resource : %s\n", resource);
#ifdef ESIF_ATTR_OS_WINDOWS
strcat_s((esif_string)file_to_open, 1000, resource);
esif_ccb_fopen(&file_fp, (esif_string)file_to_open, (esif_string)"rb");
#else
strcat((esif_string)file_to_open, resource);
esif_ccb_fopen(&file_fp, (esif_string)file_to_open, (esif_string)"r");
#endif
printf("file to open: %s\n", file_to_open);
printf("file type: %s\n", fileType);
if (NULL == file_fp) {
printf("failed to open file: %s\n", file_to_open);
return 404;
}
if (esif_ccb_stat(file_to_open, &st) != 0) {
printf("Could not stat file descriptor \n");
fclose(file_fp);
return 404;
}
(long)fseek(file_fp, (off_t)0, SEEK_END);
(void)fseek(file_fp, (off_t)0, SEEK_SET);
if (!strcmp(fileType, "text/xml")) {
(void)esif_ccb_sprintf(BUFFER_LENGTH, buffer, (char*)"HTTP/1.1 200 OK\n<?xml version==\"1.0\" encoding=\"utf-8\"?>\n"
"Server: server/%d.0\n"
"Content-Type: %s\nContent-Length: %ld\nConnection: close\n\n",
VERSION, fileType, (long)st.st_size);
} else {
(void)esif_ccb_sprintf(BUFFER_LENGTH, buffer, (char*)"HTTP/1.1 200 OK\n"
"Server: server/%d.0\nLast-Modified: %s\nDate: %s\n"
"Content-Type: %s\nContent-Length: %ld\nConnection: close\n\n",
VERSION,
esif_ws_http_time_stamp(st.st_mtime, tmpbuffer), esif_ws_http_time_stamp(time(0), tmpbuffer), fileType, (long)st.st_size);
}
(void)send(fd, buffer, (int)esif_ccb_strlen(buffer, MAX_SIZE), 0);
while ((ret = (int)fread(buffer, 1, BUFFER_LENGTH, file_fp)) > 0)
(void)send(fd, buffer, ret, 0);
fclose(file_fp);
return 0;
}
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;
}
static void esif_ws_http_process_get_or_post (
char *buffer,
int fd,
ssize_t ret
)
{
char *blankCharPtr0 = NULL;
char *blankCharPtr1 = NULL;
char *questMarkCharPtr = NULL;
char resource[100];
char *fileName;
char *method;
char *fileType = NULL;
int result = 0;
#ifdef ESIF_ATTR_OS_WINDOWS
char *str;
#endif
if (!strncmp(buffer, "GET ", 4)) {
method = "GET";
} else {
method = "POST";
}
blankCharPtr0 = strchr(buffer, ' ');
blankCharPtr0++;
blankCharPtr1 = strchr(blankCharPtr0, ' ');
questMarkCharPtr = strchr(blankCharPtr0, '?');
/* special case */
if (questMarkCharPtr && questMarkCharPtr < blankCharPtr1) {
// resource = (char *)esif_ccb_malloc(questMarkCharPtr - blankCharPtr0 );
if (!strcmp(method, "GET")) {
esif_ccb_memcpy(resource, buffer + 4, questMarkCharPtr - blankCharPtr0);
} else {
esif_ccb_memcpy(resource, buffer + 5, questMarkCharPtr - blankCharPtr0);
}
resource[questMarkCharPtr - blankCharPtr0] = 0;
} else {
// resource = (char *)esif_ccb_malloc(blankCharPtr1 - blankCharPtr0);
if (!strcmp(method, "GET")) {
esif_ccb_memcpy(resource, buffer + 4, blankCharPtr1 - blankCharPtr0);
} else {
esif_ccb_memcpy(resource, buffer + 5, blankCharPtr1 - blankCharPtr0);
}
resource[blankCharPtr1 - blankCharPtr0] = 0;
}
printf("resource b4: %s\n", resource);
if (resource[1] == '\0') {
printf("empty resource: %s\n", resource);
result = esif_ws_http_server_static_pages(buffer, "index.html", fd, ret, "text/html");
if (result > 0)
{
esif_ws_http_send_error_code(fd, result);
}
return;
}
fileName = &resource[1];
// resource++;
#ifdef ESIF_ATTR_OS_WINDOWS
do {
str = strchr(resource, '/');
if (str) {
str[0] = '\\';
}
} while (str != NULL);
// printf("str: %s\n", str);
#endif
fileType = esif_ws_http_get_file_type(fileName);
if (NULL != fileType) {
result = esif_ws_http_server_static_pages(buffer, fileName, fd, ret, fileType);
if (result > 0)
{
esif_ws_http_send_error_code(fd, result);
}
} else {
printf("File type is not valid\n");
}
esif_ws_http_send_error_code(fd, result);
result = result;
}
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;
}
