| /* |
| * Copyright (C) 2017 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #define LOG_TAG "incident_helper" |
| |
| #include "ih_util.h" |
| |
| #include <algorithm> |
| #include <sstream> |
| #include <unistd.h> |
| |
| bool isValidChar(char c) { |
| uint8_t v = (uint8_t)c; |
| return (v >= (uint8_t)'a' && v <= (uint8_t)'z') |
| || (v >= (uint8_t)'A' && v <= (uint8_t)'Z') |
| || (v >= (uint8_t)'0' && v <= (uint8_t)'9') |
| || (v == (uint8_t)'_'); |
| } |
| |
| std::string trim(const std::string& s, const std::string& charset) { |
| const auto head = s.find_first_not_of(charset); |
| if (head == std::string::npos) return ""; |
| |
| const auto tail = s.find_last_not_of(charset); |
| return s.substr(head, tail - head + 1); |
| } |
| |
| static inline std::string toLowerStr(const std::string& s) { |
| std::string res(s); |
| std::transform(res.begin(), res.end(), res.begin(), ::tolower); |
| return res; |
| } |
| |
| static inline std::string trimDefault(const std::string& s) { |
| return trim(s, DEFAULT_WHITESPACE); |
| } |
| |
| static inline std::string trimHeader(const std::string& s) { |
| return toLowerStr(trimDefault(s)); |
| } |
| |
| static inline bool isNumber(const std::string& s) { |
| std::string::const_iterator it = s.begin(); |
| while (it != s.end() && std::isdigit(*it)) ++it; |
| return !s.empty() && it == s.end(); |
| } |
| |
| // This is similiar to Split in android-base/file.h, but it won't add empty string |
| static void split(const std::string& line, std::vector<std::string>& words, |
| const trans_func& func, const std::string& delimiters) { |
| words.clear(); // clear the buffer before split |
| |
| size_t base = 0; |
| size_t found; |
| while (true) { |
| found = line.find_first_of(delimiters, base); |
| if (found != base) { |
| std::string word = (*func) (line.substr(base, found - base)); |
| if (!word.empty()) { |
| words.push_back(word); |
| } |
| } |
| if (found == line.npos) break; |
| base = found + 1; |
| } |
| } |
| |
| header_t parseHeader(const std::string& line, const std::string& delimiters) { |
| header_t header; |
| trans_func f = &trimHeader; |
| split(line, header, f, delimiters); |
| return header; |
| } |
| |
| record_t parseRecord(const std::string& line, const std::string& delimiters) { |
| record_t record; |
| trans_func f = &trimDefault; |
| split(line, record, f, delimiters); |
| return record; |
| } |
| |
| bool getColumnIndices(std::vector<int>& indices, const char** headerNames, const std::string& line) { |
| indices.clear(); |
| |
| size_t lastIndex = 0; |
| int i = 0; |
| while (headerNames[i] != nullptr) { |
| std::string s = headerNames[i]; |
| lastIndex = line.find(s, lastIndex); |
| if (lastIndex == std::string::npos) { |
| fprintf(stderr, "Bad Task Header: %s\n", line.c_str()); |
| return false; |
| } |
| lastIndex += s.length(); |
| indices.push_back(lastIndex); |
| i++; |
| } |
| |
| return true; |
| } |
| |
| record_t parseRecordByColumns(const std::string& line, const std::vector<int>& indices, const std::string& delimiters) { |
| record_t record; |
| int lastIndex = 0; |
| int lastBeginning = 0; |
| int lineSize = (int)line.size(); |
| for (std::vector<int>::const_iterator it = indices.begin(); it != indices.end(); ++it) { |
| int idx = *it; |
| if (idx <= lastIndex) { |
| // We saved up until lastIndex last time, so we should start at |
| // lastIndex + 1 this time. |
| idx = lastIndex + 1; |
| } |
| if (idx > lineSize) { |
| if (lastIndex < idx && lastIndex < lineSize) { |
| // There's a little bit more for us to save, which we'll do |
| // outside of the loop. |
| break; |
| } |
| // If we're past the end of the line AND we've already saved everything up to the end. |
| fprintf(stderr, "index wrong: lastIndex: %d, idx: %d, lineSize: %d\n", lastIndex, idx, lineSize); |
| record.clear(); // The indices are wrong, return empty. |
| return record; |
| } |
| while (idx < lineSize && delimiters.find(line[idx++]) == std::string::npos); |
| record.push_back(trimDefault(line.substr(lastIndex, idx - lastIndex))); |
| lastBeginning = lastIndex; |
| lastIndex = idx; |
| } |
| if (lineSize - lastIndex > 0) { |
| int beginning = lastIndex; |
| if (record.size() == indices.size() && !record.empty()) { |
| // We've already encountered all of the columns...put whatever is |
| // left in the last column. |
| record.pop_back(); |
| beginning = lastBeginning; |
| } |
| record.push_back(trimDefault(line.substr(beginning, lineSize - beginning))); |
| } |
| return record; |
| } |
| |
| void printRecord(const record_t& record) { |
| fprintf(stderr, "Record: { "); |
| if (record.size() == 0) { |
| fprintf(stderr, "}\n"); |
| return; |
| } |
| for(size_t i = 0; i < record.size(); ++i) { |
| if(i != 0) fprintf(stderr, "\", "); |
| fprintf(stderr, "\"%s", record[i].c_str()); |
| } |
| fprintf(stderr, "\" }\n"); |
| } |
| |
| bool stripPrefix(std::string* line, const char* key, bool endAtDelimiter) { |
| const auto head = line->find_first_not_of(DEFAULT_WHITESPACE); |
| if (head == std::string::npos) return false; |
| int len = (int)line->length(); |
| int i = 0; |
| int j = head; |
| while (key[i] != '\0') { |
| if (j >= len || key[i++] != line->at(j++)) { |
| return false; |
| } |
| } |
| |
| if (endAtDelimiter) { |
| // this means if the line only have prefix or no delimiter, we still return false. |
| if (j == len || isValidChar(line->at(j))) return false; |
| } |
| |
| line->assign(trimDefault(line->substr(j))); |
| return true; |
| } |
| |
| bool stripSuffix(std::string* line, const char* key, bool endAtDelimiter) { |
| const auto tail = line->find_last_not_of(DEFAULT_WHITESPACE); |
| if (tail == std::string::npos) return false; |
| int i = 0; |
| while (key[++i] != '\0'); // compute the size of the key |
| int j = tail; |
| while (i > 0) { |
| if (j < 0 || key[--i] != line->at(j--)) { |
| return false; |
| } |
| } |
| |
| if (endAtDelimiter) { |
| // this means if the line only have suffix or no delimiter, we still return false. |
| if (j < 0 || isValidChar(line->at(j))) return false; |
| } |
| |
| line->assign(trimDefault(line->substr(0, j+1))); |
| return true; |
| } |
| |
| std::string behead(std::string* line, const char cut) { |
| auto found = line->find_first_of(cut); |
| if (found == std::string::npos) { |
| std::string head = line->substr(0); |
| line->assign(""); |
| return head; |
| } |
| std::string head = line->substr(0, found); |
| while(line->at(found) == cut) found++; // trim more cut of the rest |
| line->assign(line->substr(found)); |
| return head; |
| } |
| |
| int toInt(const std::string& s) { |
| return atoi(s.c_str()); |
| } |
| |
| long long toLongLong(const std::string& s) { |
| return atoll(s.c_str()); |
| } |
| |
| double toDouble(const std::string& s) { |
| return atof(s.c_str()); |
| } |
| |
| // ============================================================================== |
| Reader::Reader(const int fd) |
| { |
| mFile = fdopen(fd, "r"); |
| mStatus = mFile == nullptr ? "Invalid fd " + std::to_string(fd) : ""; |
| } |
| |
| Reader::~Reader() |
| { |
| if (mFile != nullptr) fclose(mFile); |
| } |
| |
| bool Reader::readLine(std::string* line) { |
| if (mFile == nullptr) return false; |
| |
| char* buf = nullptr; |
| size_t len = 0; |
| ssize_t read = getline(&buf, &len, mFile); |
| if (read != -1) { |
| std::string s(buf); |
| line->assign(trim(s, DEFAULT_NEWLINE)); |
| } else if (errno == EINVAL) { |
| mStatus = "Bad Argument"; |
| } |
| free(buf); |
| return read != -1; |
| } |
| |
| bool Reader::ok(std::string* error) { |
| error->assign(mStatus); |
| return mStatus.empty(); |
| } |
| |
| // ============================================================================== |
| Table::Table(const char* names[], const uint64_t ids[], const int count) |
| :mEnums(), |
| mEnumValuesByName() |
| { |
| std::map<std::string, uint64_t> fields; |
| for (int i = 0; i < count; i++) { |
| fields[names[i]] = ids[i]; |
| } |
| mFields = fields; |
| } |
| |
| Table::~Table() |
| { |
| } |
| |
| void |
| Table::addEnumTypeMap(const char* field, const char* enumNames[], const int enumValues[], const int enumSize) |
| { |
| if (mFields.find(field) == mFields.end()) { |
| fprintf(stderr, "Field '%s' not found", field); |
| return; |
| } |
| |
| std::map<std::string, int> enu; |
| for (int i = 0; i < enumSize; i++) { |
| enu[enumNames[i]] = enumValues[i]; |
| } |
| mEnums[field] = enu; |
| } |
| |
| void |
| Table::addEnumNameToValue(const char* enumName, const int enumValue) |
| { |
| mEnumValuesByName[enumName] = enumValue; |
| } |
| |
| bool |
| Table::insertField(ProtoOutputStream* proto, const std::string& name, const std::string& value) |
| { |
| if (mFields.find(name) == mFields.end()) return false; |
| |
| uint64_t found = mFields[name]; |
| record_t repeats; // used for repeated fields |
| switch ((found & FIELD_COUNT_MASK) | (found & FIELD_TYPE_MASK)) { |
| case FIELD_COUNT_SINGLE | FIELD_TYPE_DOUBLE: |
| case FIELD_COUNT_SINGLE | FIELD_TYPE_FLOAT: |
| proto->write(found, toDouble(value)); |
| break; |
| case FIELD_COUNT_SINGLE | FIELD_TYPE_STRING: |
| case FIELD_COUNT_SINGLE | FIELD_TYPE_BYTES: |
| proto->write(found, value); |
| break; |
| case FIELD_COUNT_SINGLE | FIELD_TYPE_INT64: |
| case FIELD_COUNT_SINGLE | FIELD_TYPE_SINT64: |
| case FIELD_COUNT_SINGLE | FIELD_TYPE_UINT64: |
| case FIELD_COUNT_SINGLE | FIELD_TYPE_FIXED64: |
| case FIELD_COUNT_SINGLE | FIELD_TYPE_SFIXED64: |
| proto->write(found, toLongLong(value)); |
| break; |
| case FIELD_COUNT_SINGLE | FIELD_TYPE_BOOL: |
| if (strcmp(toLowerStr(value).c_str(), "true") == 0 || strcmp(value.c_str(), "1") == 0) { |
| proto->write(found, true); |
| break; |
| } |
| if (strcmp(toLowerStr(value).c_str(), "false") == 0 || strcmp(value.c_str(), "0") == 0) { |
| proto->write(found, false); |
| break; |
| } |
| return false; |
| case FIELD_COUNT_SINGLE | FIELD_TYPE_ENUM: |
| // if the field has its own enum mapping, use this, otherwise use general name to value mapping. |
| if (mEnums.find(name) != mEnums.end()) { |
| if (mEnums[name].find(value) != mEnums[name].end()) { |
| proto->write(found, mEnums[name][value]); |
| } else { |
| proto->write(found, 0); // TODO: should get the default enum value (Unknown) |
| } |
| } else if (mEnumValuesByName.find(value) != mEnumValuesByName.end()) { |
| proto->write(found, mEnumValuesByName[value]); |
| } else if (isNumber(value)) { |
| proto->write(found, toInt(value)); |
| } else { |
| return false; |
| } |
| break; |
| case FIELD_COUNT_SINGLE | FIELD_TYPE_INT32: |
| case FIELD_COUNT_SINGLE | FIELD_TYPE_SINT32: |
| case FIELD_COUNT_SINGLE | FIELD_TYPE_UINT32: |
| case FIELD_COUNT_SINGLE | FIELD_TYPE_FIXED32: |
| case FIELD_COUNT_SINGLE | FIELD_TYPE_SFIXED32: |
| proto->write(found, toInt(value)); |
| break; |
| // REPEATED TYPE below: |
| case FIELD_COUNT_REPEATED | FIELD_TYPE_INT32: |
| repeats = parseRecord(value, COMMA_DELIMITER); |
| for (size_t i=0; i<repeats.size(); i++) { |
| proto->write(found, toInt(repeats[i])); |
| } |
| break; |
| case FIELD_COUNT_REPEATED | FIELD_TYPE_STRING: |
| repeats = parseRecord(value, COMMA_DELIMITER); |
| for (size_t i=0; i<repeats.size(); i++) { |
| proto->write(found, repeats[i]); |
| } |
| break; |
| default: |
| return false; |
| } |
| return true; |
| } |
| |
| // ================================================================================ |
| Message::Message(Table* table) |
| :mTable(table), |
| mPreviousField(""), |
| mTokens(), |
| mSubMessages() |
| { |
| } |
| |
| Message::~Message() |
| { |
| } |
| |
| void |
| Message::addSubMessage(uint64_t fieldId, Message* fieldMsg) |
| { |
| for (auto iter = mTable->mFields.begin(); iter != mTable->mFields.end(); iter++) { |
| if (iter->second == fieldId) { |
| mSubMessages[iter->first] = fieldMsg; |
| return; |
| } |
| } |
| } |
| |
| bool |
| Message::insertField(ProtoOutputStream* proto, const std::string& name, const std::string& value) |
| { |
| // If the field name can be found, it means the name is a primitive field. |
| if (mTable->mFields.find(name) != mTable->mFields.end()) { |
| endSession(proto); |
| // The only edge case is for example ro.hardware itself is a message, so a field called "value" |
| // would be defined in proto Ro::Hardware and it must be the first field. |
| if (mSubMessages.find(name) != mSubMessages.end()) { |
| startSession(proto, name); |
| return mSubMessages[name]->insertField(proto, "value", value); |
| } else { |
| return mTable->insertField(proto, name, value); |
| } |
| } |
| |
| // Try to find the message field which is the prefix of name, so the value would be inserted |
| // recursively into the submessage. |
| std::string mutableName = name; |
| for (auto iter = mSubMessages.begin(); iter != mSubMessages.end(); iter++) { |
| std::string fieldName = iter->first; |
| std::string prefix = fieldName + "_"; // underscore is the delimiter in the name |
| if (stripPrefix(&mutableName, prefix.c_str())) { |
| if (mPreviousField != fieldName) { |
| endSession(proto); |
| startSession(proto, fieldName); |
| } |
| return mSubMessages[fieldName]->insertField(proto, mutableName, value); |
| } |
| } |
| // Can't find the name in proto definition, handle it separately. |
| return false; |
| } |
| |
| void |
| Message::startSession(ProtoOutputStream* proto, const std::string& name) |
| { |
| uint64_t fieldId = mTable->mFields[name]; |
| uint64_t token = proto->start(fieldId); |
| mPreviousField = name; |
| mTokens.push(token); |
| } |
| |
| void |
| Message::endSession(ProtoOutputStream* proto) |
| { |
| if (mPreviousField == "") return; |
| if (mSubMessages.find(mPreviousField) != mSubMessages.end()) { |
| mSubMessages[mPreviousField]->endSession(proto); |
| } |
| proto->end(mTokens.top()); |
| mTokens.pop(); |
| mPreviousField = ""; |
| } |