/mandos/release

To get this branch, use:
bzr branch http://bzr.recompile.se/loggerhead/mandos/release

« back to all changes in this revision

Viewing changes to plugin-runner.c

First version of a somewhat complete D-Bus server interface.  Also
change user/group name to "_mandos".

* debian/mandos.postinst: Rename old "mandos" user and group to
                          "_mandos"; create "_mandos" user and group
                          if none exist.
* debian/mandos-client.postinst: - '' -

* initramfs-tools-hook: Try "_mandos" before "mandos" as user and
                        group name.

* mandos (_datetime_to_dbus_struct): New; was previously local.
  (Client.started): Renamed to "last_started".  All users changed.
  (Client.started): New; boolean.
  (Client.dbus_object_path): New.
  (Client.check_command): Renamed to "checker_command".  All users
                          changed.
  (Client.__init__): Set and use "self.dbus_object_path".  Set
                     "self.started".
  (Client.start): Update "self.started".  Emit "self.PropertyChanged"
                  signals for both "started" and "last_started".
  (Client.stop): Update "self.started".  Emit "self.PropertyChanged"
                 signal for "started".
  (Client.checker_callback): Take additional "command" argument.  All
                             callers changed. Emit
                             "self.PropertyChanged" signal.
  (Client.bump_timeout): Emit "self.PropertyChanged" signal for
                         "last_checked_ok".
  (Client.start_checker): Emit "self.PropertyChanged" signal for
                          "checker_running".
  (Client.stop_checker): Emit "self.PropertyChanged" signal for
                         "checker_running".
  (Client.still_valid): Bug fix: use "getattr(self, started, False)"
                        instead of "self.started" in case this client
                        object is so new that the "started" attribute
                        has not been created yet.
  (Client.IntervalChanged, Client.CheckerIsRunning, Client.GetChecker,
  Client.GetCreated, Client.GetFingerprint, Client.GetHost,
  Client.GetInterval, Client.GetName, Client.GetStarted,
  Client.GetTimeout, Client.StateChanged, Client.TimeoutChanged):
  Removed; all callers changed.
  (Client.CheckerCompleted): Add "condition" and "command" arguments.
                             All callers changed.
  (Client.GetAllProperties, Client.PropertyChanged): New.
  (Client.StillValid): Renamed to "IsStillValid".
  (Client.StartChecker): Changed to its own function to avoid the
                         return value from "Client.start_checker()".
  (Client.Stop): Changed to its own function to avoid the return value
                 from "Client.stop()".
  (main): Try "_mandos" before "mandos" as user and group name.
          Removed inner function "remove_from_clients".  New inner
          class "MandosServer".

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin-runner.c
2
2
/*
3
3
 * Mandos plugin runner - Run Mandos plugins
4
4
 *
5
 
 * Copyright © 2007-2008 Teddy Hogeborn & Björn Påhlsson
 
5
 * Copyright © 2008 Teddy Hogeborn
 
6
 * Copyright © 2008 Björn Påhlsson
6
7
 * 
7
8
 * This program is free software: you can redistribute it and/or
8
9
 * modify it under the terms of the GNU General Public License as
27
28
#include <stdlib.h>             /* malloc(), exit(), EXIT_FAILURE,
28
29
                                   EXIT_SUCCESS, realloc() */
29
30
#include <stdbool.h>            /* bool, true, false */
30
 
#include <stdio.h>              /* perror, popen(), fileno(),
31
 
                                   fprintf(), stderr, STDOUT_FILENO */
 
31
#include <stdio.h>              /* perror, fileno(), fprintf(),
 
32
                                   stderr, STDOUT_FILENO */
32
33
#include <sys/types.h>          /* DIR, opendir(), stat(), struct
33
34
                                   stat, waitpid(), WIFEXITED(),
34
35
                                   WEXITSTATUS(), wait(), pid_t,
46
47
                                   fcntl(), setuid(), setgid(),
47
48
                                   F_GETFD, F_SETFD, FD_CLOEXEC,
48
49
                                   access(), pipe(), fork(), close()
49
 
                                   dup2, STDOUT_FILENO, _exit(),
 
50
                                   dup2(), STDOUT_FILENO, _exit(),
50
51
                                   execv(), write(), read(),
51
52
                                   close() */
52
53
#include <fcntl.h>              /* fcntl(), F_GETFD, F_SETFD,
69
70
#define PDIR "/lib/mandos/plugins.d"
70
71
#define AFILE "/conf/conf.d/mandos/plugin-runner.conf"
71
72
 
72
 
const char *argp_program_version = "plugin-runner 1.0";
 
73
const char *argp_program_version = "plugin-runner " VERSION;
73
74
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
74
75
 
75
 
struct plugin;
76
 
 
77
76
typedef struct plugin{
78
77
  char *name;                   /* can be NULL or any plugin name */
79
78
  char **argv;
208
207
 * Descriptor Flags".
209
208
 * *Note File Descriptor Flags:(libc)Descriptor Flags.
210
209
 */
211
 
static int set_cloexec_flag(int fd)
212
 
{
 
210
static int set_cloexec_flag(int fd){
213
211
  int ret = fcntl(fd, F_GETFD, 0);
214
212
  /* If reading the flags failed, return error indication now. */
215
213
  if(ret < 0){
222
220
 
223
221
/* Mark processes as completed when they exit, and save their exit
224
222
   status. */
225
 
void handle_sigchld(__attribute__((unused)) int sig){
 
223
static void handle_sigchld(__attribute__((unused)) int sig){
226
224
  while(true){
227
225
    plugin *proc = plugin_list;
228
226
    int status;
253
251
}
254
252
 
255
253
/* Prints out a password to stdout */
256
 
bool print_out_password(const char *buffer, size_t length){
 
254
static bool print_out_password(const char *buffer, size_t length){
257
255
  ssize_t ret;
258
256
  for(size_t written = 0; written < length; written += (size_t)ret){
259
257
    ret = TEMP_FAILURE_RETRY(write(STDOUT_FILENO, buffer + written,
394
392
      if(arg == NULL){
395
393
        break;
396
394
      }
397
 
      {
398
 
        char *envdef = strdup(arg);
399
 
        if(envdef == NULL){
400
 
          break;
401
 
        }
402
 
        if(not add_environment(getplugin(NULL), envdef, true)){
403
 
          perror("add_environment");
404
 
        }
 
395
      if(not add_environment(getplugin(NULL), arg, true)){
 
396
        perror("add_environment");
405
397
      }
406
398
      break;
407
399
    case 'o':                   /* --options-for */
435
427
        if(envdef == NULL){
436
428
          break;
437
429
        }
438
 
        char *p_name = strndup(arg, (size_t) (envdef-arg));
439
 
        if(p_name == NULL){
440
 
          break;
441
 
        }
442
 
        envdef++;
443
 
        if(not add_environment(getplugin(p_name), envdef, true)){
 
430
        *envdef = '\0';
 
431
        if(not add_environment(getplugin(arg), envdef+1, true)){
444
432
          perror("add_environment");
445
433
        }
446
434
      }
464
452
      }
465
453
      break;
466
454
    case 128:                   /* --plugin-dir */
 
455
      free(plugindir);
467
456
      plugindir = strdup(arg);
468
457
      if(plugindir == NULL){
469
458
        perror("strdup");
482
471
      debug = true;
483
472
      break;
484
473
    case ARGP_KEY_ARG:
485
 
      fprintf(stderr, "Ignoring unknown argument \"%s\"\n", arg);
 
474
      /* Cryptsetup always passes an argument, which is an empty
 
475
         string if "none" was specified in /etc/crypttab.  So if
 
476
         argument was empty, we ignore it silently. */
 
477
      if(arg[0] != '\0'){
 
478
        fprintf(stderr, "Ignoring unknown argument \"%s\"\n", arg);
 
479
      }
486
480
      break;
487
481
    case ARGP_KEY_END:
488
482
      break;
507
501
    case 128:                   /* --plugin-dir */
508
502
      break;
509
503
    case 129:                   /* --config-file */
 
504
      free(argfile);
510
505
      argfile = strdup(arg);
511
506
      if(argfile == NULL){
512
507
        perror("strdup");
706
701
      
707
702
      const char const *bad_suffixes[] = { "~", "#", ".dpkg-new",
708
703
                                           ".dpkg-old",
 
704
                                           ".dpkg-bak",
709
705
                                           ".dpkg-divert", NULL };
710
706
      for(const char **pre = bad_prefixes; *pre != NULL; pre++){
711
707
        size_t pre_len = strlen(*pre);
742
738
    }
743
739
 
744
740
    char *filename;
745
 
    ret = asprintf(&filename, "%s/%s", plugindir, dirst->d_name);
 
741
    if(plugindir == NULL){
 
742
      ret = asprintf(&filename, PDIR "/%s", dirst->d_name);
 
743
    } else {
 
744
      ret = asprintf(&filename, "%s/%s", plugindir, dirst->d_name);
 
745
    }
746
746
    if(ret < 0){
747
747
      perror("asprintf");
748
748
      continue;
848
848
        perror("sigaction");
849
849
        _exit(EXIT_FAILURE);
850
850
      }
851
 
      ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
 
851
      ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
852
852
      if(ret < 0){
853
853
        perror("sigprocmask");
854
854
        _exit(EXIT_FAILURE);
855
855
      }
856
 
 
 
856
      
857
857
      ret = dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
858
858
      if(ret == -1){
859
859
        perror("dup2");
909
909
    if (maxfd < new_plugin->fd){
910
910
      maxfd = new_plugin->fd;
911
911
    }
912
 
    
913
912
  }
914
913
  
915
914
  closedir(dir);
916
915
  dir = NULL;
917
 
 
 
916
  
918
917
  for(plugin *p = plugin_list; p != NULL; p = p->next){
919
918
    if(p->pid != 0){
920
919
      break;
925
924
      free_plugin_list();
926
925
    }
927
926
  }
928
 
 
 
927
  
929
928
  /* Main loop while running plugins exist */
930
929
  while(plugin_list){
931
930
    fd_set rfds = rfds_all;
937
936
    }
938
937
    /* OK, now either a process completed, or something can be read
939
938
       from one of them */
940
 
    for(plugin *proc = plugin_list; proc != NULL; proc = proc->next){
 
939
    for(plugin *proc = plugin_list; proc != NULL;){
941
940
      /* Is this process completely done? */
942
941
      if(proc->eof and proc->completed){
943
942
        /* Only accept the plugin output if it exited cleanly */
970
969
            exitstatus = EXIT_FAILURE;
971
970
            goto fallback;
972
971
          }
 
972
          
 
973
          plugin *next_plugin = proc->next;
973
974
          free_plugin(proc);
 
975
          proc = next_plugin;
 
976
          
974
977
          /* We are done modifying process list, so unblock signal */
975
978
          ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask,
976
979
                             NULL);
983
986
          if(plugin_list == NULL){
984
987
            break;
985
988
          }
 
989
          
986
990
          continue;
987
991
        }
988
992
        
989
993
        /* This process exited nicely, so print its buffer */
990
 
 
 
994
        
991
995
        bool bret = print_out_password(proc->buffer,
992
996
                                       proc->buffer_length);
993
997
        if(not bret){
1000
1004
      /* This process has not completed.  Does it have any output? */
1001
1005
      if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
1002
1006
        /* This process had nothing to say at this time */
 
1007
        proc = proc->next;
1003
1008
        continue;
1004
1009
      }
1005
1010
      /* Before reading, make the process' data buffer large enough */
1018
1023
                 BUFFER_SIZE);
1019
1024
      if(ret < 0){
1020
1025
        /* Read error from this process; ignore the error */
 
1026
        proc = proc->next;
1021
1027
        continue;
1022
1028
      }
1023
1029
      if(ret == 0){
1057
1063
    perror("sigaction");
1058
1064
    exitstatus = EXIT_FAILURE;
1059
1065
  }
1060
 
 
 
1066
  
1061
1067
  if(custom_argv != NULL){
1062
1068
    for(char **arg = custom_argv+1; *arg != NULL; arg++){
1063
1069
      free(*arg);
1069
1075
    closedir(dir);
1070
1076
  }
1071
1077
  
1072
 
  /* Free the process list and kill the processes */
 
1078
  /* Kill the processes */
1073
1079
  for(plugin *p = plugin_list; p != NULL; p = p->next){
1074
1080
    if(p->pid != 0){
1075
1081
      close(p->fd);
1088
1094
  if(errno != ECHILD){
1089
1095
    perror("wait");
1090
1096
  }
1091
 
 
 
1097
  
1092
1098
  free_plugin_list();
1093
1099
  
1094
1100
  free(plugindir);