/mandos/trunk

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

« back to all changes in this revision

Viewing changes to plugin-runner.c

  • Committer: Teddy Hogeborn
  • Date: 2008-08-25 01:16:38 UTC
  • Revision ID: teddy@fukt.bsnet.se-20080825011638-zgqej2cafhne05ay
* mandos-keygen: Strip 24-bit checksum of Radix-64 from output to make
                 output strictly base64.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin-runner.c
56
56
#include <argp.h>               /* struct argp_option, struct
57
57
                                   argp_state, struct argp,
58
58
                                   argp_parse(), ARGP_ERR_UNKNOWN,
59
 
                                   ARGP_KEY_END, ARGP_KEY_ARG, error_t */
 
59
                                   ARGP_KEY_END, ARGP_KEY_ARG,
 
60
                                   error_t */
60
61
#include <signal.h>             /* struct sigaction, sigemptyset(),
61
62
                                   sigaddset(), sigaction(),
62
63
                                   sigprocmask(), SIG_BLOCK, SIGCHLD,
78
79
  size_t buffer_size;
79
80
  size_t buffer_length;
80
81
  bool eof;
81
 
  bool completed;
82
 
  int status;
 
82
  volatile bool completed;
 
83
  volatile int status;
83
84
  struct process *next;
84
85
} process;
85
86
 
105
106
  if (new_plugin == NULL){
106
107
    return NULL;
107
108
  }
108
 
  char *copy_name = strdup(name);
109
 
  if(copy_name == NULL){
110
 
    return NULL;
 
109
  char *copy_name = NULL;
 
110
  if(name != NULL){
 
111
    copy_name = strdup(name);
 
112
    if(copy_name == NULL){
 
113
      return NULL;
 
114
    }
111
115
  }
112
116
  
113
117
  *new_plugin = (plugin) { .name = copy_name,
118
122
  
119
123
  new_plugin->argv = malloc(sizeof(char *) * 2);
120
124
  if (new_plugin->argv == NULL){
 
125
    free(copy_name);
121
126
    free(new_plugin);
122
127
    return NULL;
123
128
  }
126
131
 
127
132
  new_plugin->environ = malloc(sizeof(char *));
128
133
  if(new_plugin->environ == NULL){
 
134
    free(copy_name);
129
135
    free(new_plugin->argv);
130
136
    free(new_plugin);
131
137
    return NULL;
194
200
 
195
201
process *process_list = NULL;
196
202
 
197
 
/* Mark a process as completed when it exits, and save its exit
 
203
/* Mark processes as completed when they exit, and save their exit
198
204
   status. */
199
205
void handle_sigchld(__attribute__((unused)) int sig){
200
 
  process *proc = process_list;
201
 
  int status;
202
 
  pid_t pid = wait(&status);
203
 
  if(pid == -1){
204
 
    perror("wait");
205
 
    return;
206
 
  }
207
 
  while(proc != NULL and proc->pid != pid){
208
 
    proc = proc->next;
209
 
  }
210
 
  if(proc == NULL){
211
 
    /* Process not found in process list */
212
 
    return;
213
 
  }
214
 
  proc->status = status;
215
 
  proc->completed = true;
 
206
  while(true){
 
207
    process *proc = process_list;
 
208
    int status;
 
209
    pid_t pid = waitpid(-1, &status, WNOHANG);
 
210
    if(pid == 0){
 
211
      /* Only still running child processes */
 
212
      break;
 
213
    }
 
214
    if(pid == -1){
 
215
      if (errno != ECHILD){
 
216
        perror("waitpid");
 
217
      }
 
218
      /* No child processes */
 
219
      break;
 
220
    }
 
221
 
 
222
    /* A child exited, find it in process_list */
 
223
    while(proc != NULL and proc->pid != pid){
 
224
      proc = proc->next;
 
225
    }
 
226
    if(proc == NULL){
 
227
      /* Process not found in process list */
 
228
      continue;
 
229
    }
 
230
    proc->status = status;
 
231
    proc->completed = true;
 
232
  }
216
233
}
217
234
 
218
235
bool print_out_password(const char *buffer, size_t length){
237
254
    if(argv == NULL){
238
255
      return NULL;
239
256
    }
240
 
    argv[0] = NULL;     /* Will be set to argv[0] in main before parsing */
 
257
    argv[0] = NULL;     /* Will be set to argv[0] in main before
 
258
                           parsing */
241
259
    argv[1] = NULL;
242
260
  }
243
261
  *argc += 1;
247
265
    return NULL;
248
266
  }
249
267
  argv[*argc-1] = arg;
250
 
  argv[*argc] = NULL;   
 
268
  argv[*argc] = NULL;
251
269
  return argv;
252
270
}
253
271
 
254
272
static void free_plugin_list(plugin *plugin_list){
255
 
  for(plugin *next = plugin_list; plugin_list != NULL; plugin_list = next){
 
273
  for(plugin *next; plugin_list != NULL; plugin_list = next){
256
274
    next = plugin_list->next;
257
 
    free(plugin_list->name);
258
275
    for(char **arg = plugin_list->argv; *arg != NULL; arg++){
259
276
      free(*arg);
260
 
    }    
 
277
    }
261
278
    free(plugin_list->argv);
262
279
    for(char **env = plugin_list->environ; *env != NULL; env++){
263
280
      free(*env);
264
281
    }
265
282
    free(plugin_list->environ);
266
283
    free(plugin_list);
267
 
  }  
 
284
  }
268
285
}
269
286
 
270
287
int main(int argc, char *argv[]){
298
315
  ret = sigaction(SIGCHLD, &sigchld_action, &old_sigchld_action);
299
316
  if(ret == -1){
300
317
    perror("sigaction");
301
 
    exitstatus = EXIT_FAILURE;    
 
318
    exitstatus = EXIT_FAILURE;
302
319
    goto fallback;
303
320
  }
304
321
  
497
514
 
498
515
  if(custom_argv != NULL){
499
516
    custom_argv[0] = argv[0];
500
 
    ret = argp_parse (&argp, custom_argc, custom_argv, 0, 0, &plugin_list);
 
517
    ret = argp_parse (&argp, custom_argc, custom_argv, 0, 0,
 
518
                      &plugin_list);
501
519
    if (ret == ARGP_ERR_UNKNOWN){
502
520
      fprintf(stderr, "Unknown error while parsing arguments\n");
503
521
      exitstatus = EXIT_FAILURE;
680
698
      }
681
699
    }
682
700
    
683
 
    int pipefd[2]; 
 
701
    int pipefd[2];
684
702
    ret = pipe(pipefd);
685
703
    if (ret == -1){
686
704
      perror("pipe");
787
805
  }
788
806
  
789
807
  free_plugin_list(plugin_list);
 
808
  plugin_list = NULL;
790
809
  
791
810
  closedir(dir);
792
811
  dir = NULL;
830
849
          /* Remove the plugin */
831
850
          FD_CLR(proc->fd, &rfds_all);
832
851
          /* Block signal while modifying process_list */
833
 
          ret = sigprocmask (SIG_BLOCK, &sigchld_action.sa_mask, NULL);
 
852
          ret = sigprocmask(SIG_BLOCK, &sigchld_action.sa_mask, NULL);
834
853
          if(ret < 0){
835
854
            perror("sigprocmask");
836
855
            exitstatus = EXIT_FAILURE;
864
883
        }
865
884
        /* This process exited nicely, so print its buffer */
866
885
 
867
 
        bool bret = print_out_password(proc->buffer, proc->buffer_length);
 
886
        bool bret = print_out_password(proc->buffer,
 
887
                                       proc->buffer_length);
868
888
        if(not bret){
869
889
          perror("print_out_password");
870
890
          exitstatus = EXIT_FAILURE;
907
927
 fallback:
908
928
  
909
929
  if(process_list == NULL or exitstatus != EXIT_SUCCESS){
910
 
    /* Fallback if all plugins failed, none are found or an error occured */
 
930
    /* Fallback if all plugins failed, none are found or an error
 
931
       occured */
911
932
    bool bret;
912
933
    fprintf(stderr, "Going to fallback mode using getpass(3)\n");
913
934
    char *passwordbuffer = getpass("Password: ");