1 /* 2 * Copyright (C) 2010 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef _INIT_PARSER_H_ 18 #define _INIT_PARSER_H_ 19 20 #include <map> 21 #include <memory> 22 #include <string> 23 #include <vector> 24 25 #include "result.h" 26 27 // SectionParser is an interface that can parse a given 'section' in init. 28 // 29 // You can implement up to 4 functions below, with ParseSection being mandatory. The first two 30 // functions return Result<void> indicating if they have an error. It will be reported along 31 // with the filename and line number of where the error occurred. 32 // 33 // 1) ParseSection 34 // This function is called when a section is first encountered. 35 // 36 // 2) ParseLineSection 37 // This function is called on each subsequent line until the next section is encountered. 38 // 39 // 3) EndSection 40 // This function is called either when a new section is found or at the end of the file. 41 // It indicates that parsing of the current section is complete and any relevant objects should 42 // be committed. 43 // 44 // 4) EndFile 45 // This function is called at the end of the file. 46 // It indicates that the parsing has completed and any relevant objects should be committed. 47 48 namespace android { 49 namespace init { 50 51 class SectionParser { 52 public: ~SectionParser()53 virtual ~SectionParser() {} 54 virtual Result<void> ParseSection(std::vector<std::string>&& args, const std::string& filename, 55 int line) = 0; ParseLineSection(std::vector<std::string> &&,int)56 virtual Result<void> ParseLineSection(std::vector<std::string>&&, int) { return {}; }; EndSection()57 virtual Result<void> EndSection() { return {}; }; EndFile()58 virtual void EndFile(){}; 59 }; 60 61 class Parser { 62 public: 63 // LineCallback is the type for callbacks that can parse a line starting with a given prefix. 64 // 65 // They take the form of bool Callback(std::vector<std::string>&& args, std::string* err) 66 // 67 // Similar to ParseSection() and ParseLineSection(), this function returns bool with false 68 // indicating a failure and has an std::string* err parameter into which an error string can 69 // be written. 70 using LineCallback = std::function<Result<void>(std::vector<std::string>&&)>; 71 72 Parser(); 73 74 bool ParseConfig(const std::string& path); 75 bool ParseConfigFile(const std::string& path); 76 void AddSectionParser(const std::string& name, std::unique_ptr<SectionParser> parser); 77 void AddSingleLineParser(const std::string& prefix, LineCallback callback); 78 79 // Host init verifier check file permissions. 80 bool ParseConfigFileInsecure(const std::string& path); 81 parse_error_count()82 size_t parse_error_count() const { return parse_error_count_; } 83 84 private: 85 void ParseData(const std::string& filename, std::string* data); 86 bool ParseConfigDir(const std::string& path); 87 88 std::map<std::string, std::unique_ptr<SectionParser>> section_parsers_; 89 std::vector<std::pair<std::string, LineCallback>> line_callbacks_; 90 size_t parse_error_count_ = 0; 91 }; 92 93 } // namespace init 94 } // namespace android 95 96 #endif 97