Introduce message parser for SSH related notifications.
[people/stevee/guardian.git] / guardian
CommitLineData
88d9af2c
SS
1#!/usr/bin/perl
2###############################################################################
3# #
4# IPFire.org - A linux based firewall #
5# Copyright (C) 2015 IPFire Development Team #
6# #
7# This program is free software: you can redistribute it and/or modify #
8# it under the terms of the GNU General Public License as published by #
9# the Free Software Foundation, either version 3 of the License, or #
10# (at your option) any later version. #
11# #
12# This program is distributed in the hope that it will be useful, #
13# but WITHOUT ANY WARRANTY; without even the implied warranty of #
14# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the #
15# GNU General Public License for more details. #
16# #
17# You should have received a copy of the GNU General Public License #
18# along with this program. If not, see <http://www.gnu.org/licenses/>. #
19# #
20###############################################################################
21
22use strict;
23use threads;
24use threads::shared;
45bf2a03 25use Getopt::Long;
88d9af2c
SS
26use Thread::Queue;
27use Linux::Inotify2;
01147a7e 28use Time::HiRes qw[ time sleep ];
88d9af2c 29
3111df62 30require Guardian::Base;
45bf2a03 31require Guardian::Config;
ccf4f8e1 32require Guardian::Daemon;
e8528a98 33require Guardian::Events;
c95dfa5b 34require Guardian::Logger;
88d9af2c 35require Guardian::Parser;
6abac3d4 36require Guardian::Socket;
88d9af2c 37
5c694317
SS
38use warnings;
39
e02ed027
SS
40# Disable warnings of unjoinded threads when stopping guardian.
41no warnings 'threads';
42
45bf2a03
SS
43# Define version.
44my $version ="2.0";
45
45bf2a03
SS
46# Get and store the given command line arguments in a hash.
47my %cmdargs = ();
48
49&GetOptions (\%cmdargs,
50 'foreground|f',
51 'config|c=s',
52 'help|h',
53 'version|v',
54);
55
56# Show help / version information.
57if (defined($cmdargs{"help"})) {
58 print "Guardian $version \n";
59 print "Usage: guardian <optional arguments>\n";
60 print " -c, --config\t\tspecifiy a configuration file other than the default (/etc/guardian/guardian.conf)\n";
61 print " -f, --foreground\trun in the foreground (doesn't fork, any output goes to STDOUT)\n";
62 print " -h, --help\t\tshows this help\n";
63 print " -v, --version\t\tdisplay programm version and exit.\n";
64 exit;
65} elsif (defined($cmdargs{"version"})) {
66 print "Guardian $version \n";
67 exit;
68}
69
624876cf
SS
70# Check if another instance of guardian is allready running.
71if (&Guardian::Daemon::IsRunning()) {
72 die "Another instance of Guardian is allready running...\n";
73}
74
45bf2a03
SS
75# Read-in the configuration file and store the settings.
76# Push the may be given config file argument.
77my %mainsettings = &Guardian::Config::UseConfig($cmdargs{"config"});
78
c95dfa5b 79# Initialize Logger.
aab61123 80my $logger = Guardian::Logger->Init(%mainsettings);
c95dfa5b
SS
81$logger->Log("debug", "Logger successfully initialized...");
82
fc555263
SS
83# Add the logger object to the mainsettings for passing
84# it to the modules.
85$mainsettings{Logger} = $logger;
86
0815025a
SS
87# Redirect perls "die" messages to the logger before exiting.
88$SIG{__DIE__} = sub { $logger->Log("err", "@_"); };
89
e8528a98
SS
90# Initialize the event handler.
91my $events = Guardian::Events->Init(%mainsettings);
92
cfe5a220
SS
93# Hash to store the currently monitored files and their configured
94# parsers.
95my %monitored_files = ();
96
97# Shared hash between the main process and all threads. It will store the
3111df62 98# monitored files and their current file position.
cfe5a220 99my %file_positions :shared = ();
3111df62 100
88d9af2c
SS
101# Create the main queue. It is used to store and process all events which are
102# reported and enqueued by the worker threads.
c0a59a63 103my $queue :shared = new Thread::Queue or die "Could not create new, empty queue. $!";;
88d9af2c 104
9c74e9bb
SS
105# Array to store all currently running worker objects.
106# (Does not include the socket thread)
107my @running_workers;
108
ccf4f8e1
SS
109# Check if guardian should be daemonized or keep in the foreground.
110unless (defined($cmdargs{"foreground"})) {
111 # Fork into background.
112 &Guardian::Daemon::Daemonize();
113} else {
114 # Write PID (process-id).
115 &Guardian::Daemon::WritePID();
116}
117
88d9af2c
SS
118# Call Init function to initzialize guardian.
119&Init();
120
121# Infinite main loop, which processes all queued events.
122while(1) {
123 # Get the amount of elements in our queue.
124 # "undef" will be returned if it is empty.
125 my $current_events = $queue->pending();
126
127 # If there is at least one element enqued
128 if($current_events > 0) {
129 # Grab the data of the top enqueued event.
130 my $event = $queue->peek();
131
c95dfa5b
SS
132 # Log processed event.
133 $logger->Log("debug", "QUEUE - Processed event: $event");
88d9af2c 134
e8528a98
SS
135 # Send event data to the events parser to determine
136 # if any action is required.
137 $events->CheckAction($event);
138
88d9af2c
SS
139 # Drop processed event from queue.
140 $queue->dequeue();
141 }
142
e8528a98
SS
143 # Call RemoveBlocks routine from the Events module to check
144 # if items from the block list can be dropped.
145 $events->RemoveBlocks();
146
01147a7e
SS
147 # Sleep 10ms to reduce the load of the main process.
148 sleep(0.01);
88d9af2c
SS
149}
150
151#
152## Init function.
153#
154## This function contains code which has to be executed while guardian
155## is starting.
156#
157sub Init () {
915d9f45
SS
158 # Setup signal handler.
159 &SignalHandler();
160
6abac3d4
SS
161 # Setup IPC mechanism via Socket in an own thread.
162 threads->create(\&Socket);
163
3111df62
SS
164 # Generate hash of monitored files.
165 %monitored_files = &Guardian::Base::GenerateMonitoredFiles(\%mainsettings, \%monitored_files);
166
9c74e9bb
SS
167 # Start worker threads.
168 &StartWorkers();
88d9af2c
SS
169}
170
171#
172## Worker function.
173#
174## This function is responsible for monitoring modifications of the given logfile,
175## read them and pass them to the message parser.
176#
177## To get file modifications the inotify subsystem of the linux kernel is used.
178#
179## In order to prevent from permanently read and keep files opened, or dealing
180## with huge logfiles, at initialization time of the worker process, the file will
181## be opened once and the cursor position of the end of file (EOF) get stored. When
182## reading any newly added lines from the file, we directly can jump to the last
183## known position and get these lines. Afterwards, we store the current curser position
184## again, so we can do it in this way over and over again.
185#
186## All read lines get stored in an array, which will be passed to the Parser.
187#
188## If any response (action) from the parser get recieved, it will be put into the
189## shared event queue.
190#
191sub Worker ($) {
9c74e9bb
SS
192 my $file = $_[0];
193
cfe5a220
SS
194 # Obtain the parser name which should be used to parser any
195 # messages of this file.
196 my $parser = $monitored_files{$file};
197
9c74e9bb
SS
198 # Signal handler to kill worker.
199 $SIG{'KILL'} = sub { threads->exit(); };
88d9af2c 200
88d9af2c 201 # Create inotify watcher.
c0a59a63 202 my $watcher = new Linux::Inotify2 or die "Could not use inotify. $!";
88d9af2c
SS
203
204 # Monitor the specified file.
c0a59a63 205 $watcher->watch("$file", IN_MODIFY) or die "Could not monitor $file. $!";
88d9af2c 206
9c74e9bb
SS
207 # Switch watcher into non-blocking mode.
208 $watcher->blocking(0);
88d9af2c 209
c95dfa5b
SS
210 # Log successfully spawned worker.
211 $logger->Log("debug", "Spawned worker thread for: $file");
212
9c74e9bb
SS
213 # Infinite loop.
214 while(1) {
215 # Check for any events and perform them, if there
216 # is a least one.
217 if ($watcher->read) {
218 my @message = ();
88d9af2c 219
3111df62 220 # Obtain fileposition from hash.
cfe5a220 221 my $fileposition = $file_positions{$file};
3111df62 222
9c74e9bb 223 # Open the file.
c0a59a63 224 open (FILE, $file) or die "Could not open $file. $!";
88d9af2c 225
9c74e9bb
SS
226 # Seek to the last known position.
227 seek (FILE, $fileposition, 0);
88d9af2c 228
9c74e9bb
SS
229 # Get the log message.
230 while (my $line = <FILE>) {
231 # Remove any newlines.
232 chomp $line;
88d9af2c 233
9c74e9bb
SS
234 # Add all lines to the message array.
235 push (@message, $line);
236 }
88d9af2c 237
3111df62
SS
238 {
239 # Lock shared hash.
cfe5a220 240 lock(%file_positions);
3111df62
SS
241
242 # Update fileposition.
cfe5a220 243 $file_positions{$file} = tell(FILE);
3111df62 244 }
88d9af2c 245
9c74e9bb
SS
246 # Close file.
247 close(FILE);
88d9af2c 248
9c74e9bb
SS
249 # Send filename and message to the parser,
250 # which will return if an action has to be performed.
cfe5a220 251 my @action = &Guardian::Parser::Parser("$parser", @message);
88d9af2c 252
9c74e9bb
SS
253 # Send the action to the main process and put it into
254 # the queue.
255 if (@action) {
256 # Lock the queue.
257 lock($queue);
258
259 # Put the required action into the queue.
260 $queue->enqueue(@action);
261 }
262 } else {
263 # Sleep for 10ms until the next round of the loop will start.
264 sleep(0.01);
88d9af2c
SS
265 }
266 }
267}
268
6abac3d4
SS
269#
270## Socket function.
271#
272## This function uses the Socket module to create and listen to an UNIX socket.
273## It automatically accepts all incomming connections and pass the recieved
274## data messages to the the Message_Parser function which is also part of the
275## socket module.
276#
277## If a valid command has been sent through the socket, the corresponding event
278## will be enqueued into the shared event queue.
279#
280sub Socket () {
281 # Create the Server socket by calling the responsible function.
282 my $server = &Guardian::Socket::Server();
283
c95dfa5b
SS
284 # Log successfull creation of socket.
285 $logger->Log("debug", "Listening to Socket...");
286
6abac3d4
SS
287 # Accept incomming connections from the socket.
288 while (my $connection = $server->accept()) {
289 # Autoflush the socket after the data
290 # has been recieved.
291 $connection->autoflush(1);
292
293 # Gather all data from the connection.
294 while (my $message = <$connection>) {
295 # Remove any newlines.
296 chomp($message);
297
c95dfa5b
SS
298 # Log recieved socket command.
299 $logger->Log("debug", "Socket - Recieved message: $message");
300
6abac3d4
SS
301 # Send the recieved data message to the
302 # socket parser.
303 my $action = &Guardian::Socket::Message_Parser($message);
304
305 # If the parser returns to perform an action,
306 # add it to the main event queue.
307 if ($action) {
308 # Lock the queue.
309 lock($queue);
310
311 # Enqueue the returned action.
312 $queue->enqueue($action);
313 }
314 }
315 }
316}
317
915d9f45
SS
318#
319## Function for capturing process signals.
320#
321## This function captures any sent process signals and will call various
322## actions, basend on the captured signal.
323#
324sub SignalHandler {
325 $SIG{INT} = \&Shutdown;
326 $SIG{TERM} = \&Shutdown;
327 $SIG{QUIT} = \&Shutdown;
ba734c53 328 $SIG{HUP} = \&Reload;
915d9f45
SS
329}
330
9c74e9bb
SS
331#
332## Function to start the workers (threads) for all monitored files.
333#
3111df62 334## This function will loop through the hash of monitored files and will
9c74e9bb
SS
335## spawn an own thread based worker for each file. Every created worker will
336## be added to the array of running workers.
337#
338sub StartWorkers () {
cfe5a220
SS
339 # Init/Update hash which contains the cursor position of EOF.
340 %file_positions = &Guardian::Base::FilePositions(\%monitored_files, \%file_positions);
341
3111df62
SS
342 # Loop through the hash which contains the monitored files and start
343 # a worker thread for each single one.
344 foreach my $file (keys %monitored_files) {
c95dfa5b 345 $logger->Log("debug", "Starting worker thread for $file");
3111df62
SS
346 # Create worker thread for the file.
347 push @running_workers, threads->create(\&Worker,$file);
9c74e9bb
SS
348 }
349}
350
351#
352## Function to stop all running workers.
353#
354## This function is used to stop all currently running workers and will be
355## called when reloading or shutting down guardian.
356#
357sub StopWorkers () {
358 # Loop through all running workers.
359 foreach my $worker (@running_workers) {
360 # Send the worker the "KILL" signal and detach the
361 # thread so perl can do an automatically clean-up.
4d19939e 362 $worker->kill('KILL');
9c74e9bb 363 }
c95dfa5b 364 $logger->Log("debug", "All workers are stopped now...");
9c74e9bb
SS
365}
366
ba734c53
SS
367#
368## Reload function.
369#
370## This function will get called if the signal handler recieves a "SIGHUP" signal,
371## or the reload command will be sent via socket connection. It is responsible for
372## reloading all configure options and stopping/starting the worker threads.
373#
374sub Reload () {
c95dfa5b
SS
375 # Log reload.
376 $logger->Log("info", "Reload configuration...");
377
ba734c53
SS
378 # Stop all running workers.
379 &StopWorkers();
380
381 # Re-read configuration file.
382 %mainsettings = &Guardian::Config::UseConfig($cmdargs{"config"});
383
fc555263 384 # Update Logger settings.
aab61123 385 $logger = Guardian::Logger->Init(%mainsettings);
fc555263
SS
386
387 # Update logger object in mainsettings hash.
388 $mainsettings{Logger} = $logger;
389
57dc4265
SS
390 # Update ignore list.
391 &Guardian::Events::GenerateIgnoreList($mainsettings{IgnoreFile});
392
ba734c53
SS
393 # Re-generate hash of monitored files.
394 %monitored_files = &Guardian::Base::GenerateMonitoredFiles(\%mainsettings, \%monitored_files);
395
396 # Restart the worker threads.
397 &StartWorkers();
398}
399
915d9f45
SS
400#
401## Shutdown function.
402#
403## This function is used to do a clean shutdown of guardian. It will be called
404## by the signal handler when recieving INT (2), QUIT (3) and TERM (15) signals.
405#
406sub Shutdown () {
c95dfa5b
SS
407 # Log shutdown.
408 $logger->Log("info", "Shutting down...");
409
9c74e9bb
SS
410 # Stop all workers.
411 &StopWorkers();
412
915d9f45
SS
413 # Remove socket file on exit.
414 &Guardian::Socket::RemoveSocketFile();
415
0eb86493
SS
416 # Remove pid file on exit.
417 &Guardian::Daemon::RemovePIDFile();
418
a9ef502c
SS
419 # Sleep for one second to give perl some
420 # time to proper clean up everything before
421 # exiting.
422 sleep(1);
423
c95dfa5b
SS
424 # Log good bye message.
425 $logger->Log("debug", "Good Bye!");
426
915d9f45
SS
427 # Exit guardian.
428 exit;
429}