1 #ifndef PATTERN_SCANNER_H
2 #define PATTERN_SCANNER_H
3 
4 // if liblightgrep isn't present, compiles to nothing
5 #ifdef HAVE_LIBLIGHTGREP
6 
7 #include <vector>
8 #include <string>
9 #include <utility>
10 
11 #include <lightgrep/api.h>
12 
13 #include "findopts.h"
14 #include "be13/plugin.h"
15 
16 using namespace std;
17 
18 class PatternScanner;
19 
20 /**
21  * the function prototype for a handler callback
22  * LG_SearchHit            - LightGrep Search Hit.
23  * scanner_params          - the parameters available to the scanner.
24  * recursion_control_clock - information about where we are in the recursive analysis.
25  */
26 
27 typedef void (PatternScanner::*CallbackFnType)(const LG_SearchHit&,
28                                                const scanner_params& sp,
29                                                const recursion_control_block& rcb);
30 
31 /*********************************************************/
32 
33 struct Handler;
34 
35 // Inherit from this to create your own Lightgrep-based scanners
36 // clone(), startup(), init(), and initScan() must be overridden
37 class PatternScanner {
38 public:
PatternScanner(const string & n)39   PatternScanner(const string& n): Name(n), Handlers(), PatternRange(0, 0) {}
~PatternScanner()40   virtual ~PatternScanner() {}
41 
42   virtual PatternScanner* clone() const = 0;
43 
name()44   const string& name() const { return Name; }
45 
46   virtual void startup(const scanner_params& sp) = 0;
47 
48   virtual void init(const scanner_params& sp) = 0; // register handlers
49 
50   virtual void initScan(const scanner_params& sp) = 0; // get feature_recorders
finishScan(const scanner_params & sp)51   virtual void finishScan(const scanner_params& sp) {} // done searching a region
52 
53   virtual void shutdown(const scanner_params& sp); // perform any shutdown, if necessary
54 
55   // return bool indicates whether scanner addition should be continued
56   // default is to print message to stderr and quit parsing scanner patterns
57   virtual bool handleParseError(const Handler& h, LG_Error* err) const;
58 
addHandler(const Handler * h)59   virtual void addHandler(const Handler* h) {
60     Handlers.push_back(h);
61   }
62 
handlers()63   virtual const vector<const Handler*>& handlers() const { return Handlers; }
64 
patternRange()65   pair<unsigned int, unsigned int>& patternRange() { return PatternRange; }
patternRange()66   const pair<unsigned int, unsigned int>& patternRange() const { return PatternRange; }
67 
68 protected:
PatternScanner(const PatternScanner & s)69   PatternScanner(const PatternScanner& s):
70     Name(s.Name), Handlers(s.Handlers), PatternRange(s.PatternRange) {}
71 
72   string                 Name;
73   vector<const Handler*> Handlers;
74 
75   pair<unsigned int, unsigned int> PatternRange; // knows the label range of its associated patterns
76 };
77 
78 /*********************************************************/
79 
80 struct Handler {
81   // Agglomeration of the scanner, pattern, encodings, parse options, and callback
82   template <typename Fn>
HandlerHandler83   Handler(
84     PatternScanner& scanner,
85     const string& re,
86     const vector<string>& encs,
87     const LG_KeyOptions& opts,
88     Fn fn
89   ):
90     RE(re),
91     Encodings(encs),
92     Options(opts),
93     Callback(static_cast<CallbackFnType>(fn))
94   {
95     scanner.addHandler(this);
96   }
97 
98   string RE;
99 
100   vector<string> Encodings;
101 
102   LG_KeyOptions Options;
103 
104   CallbackFnType Callback;
105 };
106 
107 /*********************************************************/
108 
109 class LightgrepController { // Centralized search facility amongst PatternScanners
110 public:
111 
112   static LightgrepController& Get(); // singleton instance
113 
114   bool addScanner(PatternScanner& scanner);
115   bool addUserPatterns(PatternScanner& scanner, CallbackFnType* callbackPtr, const FindOpts& userPatterns);
116 
117   void regcomp();
118   void scan(const scanner_params& sp, const recursion_control_block& rcb);
119   void processHit(const vector<PatternScanner*>& sTbl, const LG_SearchHit& hit, const scanner_params& sp, const recursion_control_block& rcb);
120 
121   unsigned int numPatterns() const;
122 
123 private:
124   LightgrepController();
125   LightgrepController(const LightgrepController&);
126   ~LightgrepController();
127 
128   LightgrepController& operator=(const LightgrepController&);
129 
130   LG_HPATTERN     ParsedPattern;
131   LG_HFSM         Fsm;
132   LG_HPATTERNMAP  PatternInfo;
133   LG_HPROGRAM     Prog;
134 
135   vector<PatternScanner*> Scanners;
136 };
137 
138 /*********************************************************/
139 
140 // Utility function. Makes your scan function a one-liner, given a PatternScanner instance
141 void scan_lg(PatternScanner& scanner, struct scanner_params &sp;
142 
143 #endif
144 #endif /* PATTERN_SCANNER_H */
145