/** Process variable with EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS/EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS set. @param[in] VariableName Name of the variable. @param[in] VendorGuid Variable vendor GUID. @param[in] Data Data pointer. @param[in] DataSize Size of Data. @param[in] Attributes Attribute value of the variable. @retval EFI_SUCCESS The firmware has successfully stored the variable and its data as defined by the Attributes. @retval EFI_INVALID_PARAMETER Invalid parameter. @retval EFI_WRITE_PROTECTED Variable is write-protected. @retval EFI_OUT_OF_RESOURCES There is not enough resource. @retval EFI_SECURITY_VIOLATION The variable is with EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS or EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACESS set, but the AuthInfo does NOT pass the validation check carried out by the firmware. @retval EFI_UNSUPPORTED Unsupported to process authenticated variable. **/ EFI_STATUS EFIAPI AuthVariableLibProcessVariable ( IN CHAR16 *VariableName, IN EFI_GUID *VendorGuid, IN VOID *Data, IN UINTN DataSize, IN UINT32 Attributes ) { EFI_STATUS Status; if (CompareGuid (VendorGuid, &gEfiGlobalVariableGuid) && (StrCmp (VariableName, EFI_PLATFORM_KEY_NAME) == 0)){ Status = ProcessVarWithPk (VariableName, VendorGuid, Data, DataSize, Attributes, TRUE); } else if (CompareGuid (VendorGuid, &gEfiGlobalVariableGuid) && (StrCmp (VariableName, EFI_KEY_EXCHANGE_KEY_NAME) == 0)) { Status = ProcessVarWithPk (VariableName, VendorGuid, Data, DataSize, Attributes, FALSE); } else if (CompareGuid (VendorGuid, &gEfiImageSecurityDatabaseGuid) && ((StrCmp (VariableName, EFI_IMAGE_SECURITY_DATABASE) == 0) || (StrCmp (VariableName, EFI_IMAGE_SECURITY_DATABASE1) == 0) || (StrCmp (VariableName, EFI_IMAGE_SECURITY_DATABASE2) == 0) )) { Status = ProcessVarWithPk (VariableName, VendorGuid, Data, DataSize, Attributes, FALSE); if (EFI_ERROR (Status)) { Status = ProcessVarWithKek (VariableName, VendorGuid, Data, DataSize, Attributes); } } else { Status = ProcessVariable (VariableName, VendorGuid, Data, DataSize, Attributes); } return Status; }
void SettingsFile::ProcessLine(const std::string& line, const std::string& file_name, const unsigned int& line_number) { // Is the line empty? if(line.empty() == true) { return; } // If the line is only 1 character long, then that one character must be whitespace. Otherwise // the line is malformed. if(line.length() == 1) { if(isspace(line[0]) == 0) { throw SettingsFile::SyntaxError(SettingsFile::SyntaxError::BAD_VARIABLE_NAME, file_name, line_number); } } // Otherwise there are at least 2 characters. else { // Is this line a comment? if(line[0] == '/' && line[1] == '/') { return; } // Otherwise this line isn't a comment. else { ProcessVariable(line, file_name, line_number); } } }
/** Process variable with EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS/EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS set. @param[in] VariableName Name of the variable. @param[in] VendorGuid Variable vendor GUID. @param[in] Data Data pointer. @param[in] DataSize Size of Data. @param[in] Attributes Attribute value of the variable. @retval EFI_SUCCESS The firmware has successfully stored the variable and its data as defined by the Attributes. @retval EFI_INVALID_PARAMETER Invalid parameter. @retval EFI_WRITE_PROTECTED Variable is write-protected. @retval EFI_OUT_OF_RESOURCES There is not enough resource. @retval EFI_SECURITY_VIOLATION The variable is with EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS or EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACESS set, but the AuthInfo does NOT pass the validation check carried out by the firmware. @retval EFI_UNSUPPORTED Unsupported to process authenticated variable. **/ EFI_STATUS EFIAPI AuthVariableLibProcessVariable ( IN CHAR16 *VariableName, IN EFI_GUID *VendorGuid, IN VOID *Data, IN UINTN DataSize, IN UINT32 Attributes ) { EFI_STATUS Status; // // Process PK, KEK, Sigdb, AuditMode, DeployedMode separately. // if (CompareGuid (VendorGuid, &gEfiGlobalVariableGuid) && (StrCmp (VariableName, EFI_PLATFORM_KEY_NAME) == 0)){ Status = ProcessVarWithPk (VariableName, VendorGuid, Data, DataSize, Attributes, TRUE); } else if (CompareGuid (VendorGuid, &gEfiGlobalVariableGuid) && (StrCmp (VariableName, EFI_KEY_EXCHANGE_KEY_NAME) == 0)) { Status = ProcessVarWithPk (VariableName, VendorGuid, Data, DataSize, Attributes, FALSE); } else if (CompareGuid (VendorGuid, &gEfiGlobalVariableGuid) && (StrCmp (VariableName, EFI_AUDIT_MODE_NAME) == 0 || StrCmp (VariableName, EFI_DEPLOYED_MODE_NAME) == 0)) { Status = ProcessSecureBootModeVar(VariableName, VendorGuid, Data, DataSize, Attributes); } else if (CompareGuid (VendorGuid, &gEfiImageSecurityDatabaseGuid) && ((StrCmp (VariableName, EFI_IMAGE_SECURITY_DATABASE) == 0) || (StrCmp (VariableName, EFI_IMAGE_SECURITY_DATABASE1) == 0) || (StrCmp (VariableName, EFI_IMAGE_SECURITY_DATABASE2) == 0) )) { Status = ProcessVarWithPk (VariableName, VendorGuid, Data, DataSize, Attributes, FALSE); if (EFI_ERROR (Status)) { Status = ProcessVarWithKek (VariableName, VendorGuid, Data, DataSize, Attributes); } } else { Status = ProcessVariable (VariableName, VendorGuid, Data, DataSize, Attributes); } return Status; }
// This is where the program first starts void main(int argc, char *argv[]) { // the pipe name to use ... default is rrpipe but can be changed in RR interface LPTSTR lpszPipename = TEXT("\\\\.\\pipe\\rrpipe"); // holds the variable name being sent by RR char varName[MAX_VARNAME_SIZE]; // holds the received and prehaps processed image data char varData[DATA_BUFFER]; // used to hold return value of number of bytes read from pipe unsigned long bytes; // variables data length int varLen; struct ImageDataType imageData; memset(&imageData, 0, sizeof(imageData)); HANDLE hPipe; if (argc>1) { printf("Started with \""); int i; for (i=1; i<argc; i++) { if (i>1) printf(" "); printf("%s", argv[i]); } printf("\"\n"); } else printf("Started.\n"); // Create the pipe used to communicate with RR hPipe = CreateNamedPipe( lpszPipename, // pipe name PIPE_ACCESS_DUPLEX, // read/write access PIPE_TYPE_MESSAGE | // message type pipe PIPE_READMODE_MESSAGE | // message-read mode PIPE_WAIT, // blocking mode PIPE_UNLIMITED_INSTANCES, // max. instances PIPE_BUFFER_SIZE, // output buffer size PIPE_BUFFER_SIZE, // input buffer size NMPWAIT_USE_DEFAULT_WAIT, // client time-out NULL); // default security attribute if (hPipe == INVALID_HANDLE_VALUE) { printf("CreatePipe failed"); exit(0); } while (true) { printf("Waiting ...\n"); if (!ConnectNamedPipe(hPipe, NULL)? TRUE:(GetLastError() == ERROR_PIPE_CONNECTED)) { printf("ConnectNamedPipe failed"); continue; } printf("Connected.\n"); imageData.count=0; int len=0; while (true) { imageData.count++; printf("Processing %d\r", imageData.count); while (true) { // read in variable length ReadFile(hPipe, &len, sizeof(len), &bytes, NULL); // if length <=0 on the variable name then we're done if (len<=0) break; // read in variable name but if the name is longer than 64 characters // then grab the first 64 chars only if (len<MAX_VARNAME_SIZE) { ReadFile(hPipe, varName, len, &bytes, NULL); } else { // read in first 64 chars ReadFile(hPipe, varName, MAX_VARNAME_SIZE-1, &bytes, NULL); // skip over remaining chars SetFilePointer(hPipe, len-MAX_VARNAME_SIZE+1, 0, FILE_CURRENT); } // don't forget to terminate this string with a zero varName[bytes]=0; // read in the variable's data length ReadFile(hPipe, &varLen, sizeof(varLen), &bytes, NULL); // if the data is less than 1024 read it in now .. if (varLen<sizeof(varData)) { ReadFile(hPipe, varData, varLen, &bytes, NULL); } // handle this variable ProcessVariable(hPipe, &imageData, varName, varData, varLen); } // termination signal -1 on attribute length if (len==-1) break; // process image ProcessImage(&imageData); // Write out the processed image back to RoboRealm using stdout. // You can also write back any other variables to use in // other parts of the program. // The format is the same as the input. ReturnBytesVariable(hPipe, "image", imageData.pixels, imageData.width*imageData.height*3); // Send back the count as an example of how to feed back variables into RoboRealm ReturnIntVariable(hPipe, "count", imageData.count); // write out end of message len = 0; WriteFile(hPipe, &len, sizeof(int), &bytes, NULL); if (bytes==0) break; // continue by waiting for next image request } printf("\nDisconnected.\n"); DisconnectNamedPipe(hPipe); if (len==-1) break; } printf("Exiting\n"); // free alloced array now that we're done free(imageData.pixels); CloseHandle(hPipe); }
static HRESULT ProcessInterface(__in FILE *fp, __in TYPEINFO_ITEM *lpTypeInfoItem, __in SIZE_T nPass) { ITYPEINFO_LIST cTypeInfoList; CAutoTypeAttr cTypeAttr, cTypeAttr2; CNktStringW cStrTempW; WORD i; HRESULT hRes; SIZE_T k1; BOOL b; if (nPass == 1) { WRITEANSI_AND_CHECK(fp, "\r\n"); WRITEANSI_AND_CHECK(fp, "typedef struct "); WRITEWIDE_AND_CHECK(fp, (LPWSTR)(lpTypeInfoItem->szNameW)); WRITEANSI_AND_CHECK(fp, " "); WRITEWIDE_AND_CHECK(fp, (LPWSTR)(lpTypeInfoItem->szNameW)); WRITEANSI_AND_CHECK(fp, ";\r\n"); return S_OK; } //second pass hRes = cTypeAttr.Set(lpTypeInfoItem->cTypeInfo); EXIT_ON_ERROR(hRes); //typedef struct IUnknown IUnknown; WRITEANSI_AND_CHECK(fp, "\r\n"); WRITEANSI_AND_CHECK(fp, "typedef struct "); WRITEWIDE_AND_CHECK(fp, (LPWSTR)(lpTypeInfoItem->szNameW)); WRITEANSI_AND_CHECK(fp, "Vtbl {\r\n"); //build parents hRes = BuildInterfaceBaseList(cTypeInfoList, lpTypeInfoItem->cTypeInfo); EXIT_ON_ERROR(hRes); for (k1=0; k1<cTypeInfoList.GetCount(); k1++) { hRes = cTypeAttr2.Set(cTypeInfoList[k1]); EXIT_ON_ERROR(hRes); for (i=0; i<cTypeAttr2->cFuncs; i++) { hRes = ProcessFunction(fp, i, cTypeAttr2.Get(), cTypeInfoList[k1], 1, lpTypeInfoItem->szNameW); EXIT_ON_ERROR(hRes); b = TRUE; } } for (k1=0; k1<cTypeInfoList.GetCount(); k1++) { hRes = cTypeAttr2.Set(cTypeInfoList[k1]); EXIT_ON_ERROR(hRes); for (i=0; i<cTypeAttr2->cVars; i++) { if (b != FALSE) { WRITEANSI_AND_CHECK(fp, "\r\n"); b = FALSE; } hRes = ProcessVariable(fp, i, cTypeAttr2.Get(), cTypeInfoList[k1], 1); EXIT_ON_ERROR(hRes); } } WRITEANSI_AND_CHECK(fp, "};\r\n\r\n"); //---- WRITEANSI_AND_CHECK(fp, "struct "); WRITEWIDE_AND_CHECK(fp, (LPWSTR)(lpTypeInfoItem->szNameW)); WRITEANSI_AND_CHECK(fp, " {\r\n"); WRITEINDENT_AND_CHECK(fp, 1); WRITEANSI_AND_CHECK(fp, "struct "); WRITEWIDE_AND_CHECK(fp, (LPWSTR)(lpTypeInfoItem->szNameW)); WRITEANSI_AND_CHECK(fp, "Vtbl *lpVtbl;\r\n"); WRITEANSI_AND_CHECK(fp, "};\r\n"); return S_OK; }
static HRESULT ProcessTypedef(__in FILE *fp, __in TYPEINFO_ITEM *lpTypeInfoItem) { CAutoTypeAttr cTypeAttr; CNktStringW cStrTempW; WORD i; HRESULT hRes; hRes = cTypeAttr.Set(lpTypeInfoItem->cTypeInfo); EXIT_ON_ERROR(hRes); //write file WRITEANSI_AND_CHECK(fp, "\r\n"); WRITEANSI_AND_CHECK(fp, "typedef "); switch (cTypeAttr->typekind) { case TKIND_RECORD: WRITEANSI_AND_CHECK(fp, "struct {\r\n"); break; case TKIND_UNION: WRITEANSI_AND_CHECK(fp, "union {\r\n"); break; case TKIND_ALIAS: //typedef cStrTempW.Empty(); hRes = TypeDescToString(cStrTempW, &(cTypeAttr->tdescAlias), lpTypeInfoItem->cTypeInfo, FALSE); EXIT_ON_ERROR(hRes); WRITEWIDE_AND_CHECK(fp, (LPWSTR)cStrTempW); WRITEANSI_AND_CHECK(fp, " "); break; case TKIND_ENUM: WRITEANSI_AND_CHECK(fp, "enum {\r\n"); break; } switch (cTypeAttr->typekind) { case TKIND_RECORD: case TKIND_UNION: for (i=0; i<cTypeAttr->cVars; i++) { hRes = ProcessVariable(fp, i, cTypeAttr.Get(), lpTypeInfoItem->cTypeInfo, 1); EXIT_ON_ERROR(hRes); } WRITEANSI_AND_CHECK(fp, "} "); break; case TKIND_ENUM: for (i=0; i<cTypeAttr->cVars; i++) { hRes = ProcessConst(fp, i, cTypeAttr.Get(), lpTypeInfoItem->cTypeInfo, 1, FALSE); EXIT_ON_ERROR(hRes); if (i < cTypeAttr->cVars-1) { WRITEANSI_AND_CHECK(fp, ","); } WRITEANSI_AND_CHECK(fp, "\r\n"); } WRITEANSI_AND_CHECK(fp, "} "); break; } WRITEWIDE_AND_CHECK(fp, (LPWSTR)(lpTypeInfoItem->szNameW)); WRITEANSI_AND_CHECK(fp, ";\r\n"); return S_OK; }
static int GetVariables( void *theEnv, struct lhsParseNode *thePattern, int patternHeadType, struct nandFrame *theNandFrames) { struct lhsParseNode *patternHead = thePattern; struct lhsParseNode *multifieldHeader = NULL; /*======================================================*/ /* Loop through all the fields/slots found in a pattern */ /* looking for binding instances of variables. */ /*======================================================*/ while (thePattern != NULL) { /*================================================*/ /* A multifield slot contains a sublist of fields */ /* that must be traversed and checked. */ /*================================================*/ if (thePattern->multifieldSlot) { multifieldHeader = thePattern; thePattern = thePattern->bottom; } /*==================================================*/ /* Propagate the binding occurences of single field */ /* variables, multifield variables, and fact */ /* addresses to other occurences of the variable. */ /* If an error is encountered, return TRUE. */ /*==================================================*/ if (thePattern != NULL) { if ((thePattern->type == SF_VARIABLE) || (thePattern->type == MF_VARIABLE) || ((thePattern->type == PATTERN_CE) && (thePattern->value != NULL))) { if (ProcessVariable(theEnv,thePattern,multifieldHeader,patternHead,patternHeadType,theNandFrames)) { return(TRUE); } } else { if (ProcessField(theEnv,thePattern,multifieldHeader,patternHead,patternHeadType,theNandFrames)) { return(TRUE); } } } /*===============================================*/ /* Move on to the next field/slot in the pattern */ /* or to the next field in a multifield slot. */ /*===============================================*/ if (thePattern == NULL) { thePattern = multifieldHeader; } else if ((thePattern->right == NULL) && (multifieldHeader != NULL)) { thePattern = multifieldHeader; multifieldHeader = NULL; } thePattern = thePattern->right; } /*===============================*/ /* Return FALSE to indicate that */ /* no errors were detected. */ /*===============================*/ return(FALSE); }