/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 plugins.d/passprompt.c

  • Committer: Teddy Hogeborn
  • Date: 2008-07-20 06:33:48 UTC
  • Revision ID: teddy@fukt.bsnet.se-20080720063348-jscgy5p0itrgvlo8
* mandos-clients.conf ([foo]): Uncommented.
  ([foo]/secret): New.
  ([foo]/secfile): Commented out.
  ([foo]/checker): Changed to "fping -q -- %%(fqdn)s".
  ([foo]/timeout): New.

* server.py: New modeline for Python and Emacs.  Set a logging format.
  (Client.__init__): Bug fix: Choose either the value from the options
                     object or pass the argument through string_to_delta
                     for both "timeout" and "interval".
  (Client.checker_callback): Bug fix: Do not log spurious "Checker for
                             <foo> failed" messages.
  (Client.start_checker): Moved "Starting checker" log message down to
                          just before actually starting the subprocess.
                          Do not redirect the subprocesses' stdout to a
                          pipe.
  (peer_certificate, fingerprint): Added docstrings.
  (entry_group_state_changed): Call "killme()" instead of
                               "main_loop.quit()".
  (daemon, killme): New functions.
  (exitstatus, main_loop_started): New global variables.
  (__main__): Removed the "--cert", "--key", "--ca", and "--crl"
              options.  Removed the sleep command from the default
              checker.  Add a console logger in debug mode.  Call
              "killme()" instead of "main_loop.quit()" when there are no
              more clients.  Call "daemon()" if not in debug mode.
              Register "cleanup()" to run at exit.  Ignore some
              signals.  Catch DBusException to detect another running
              server and exit cleanly.  Exit with "exitstatus".
  (cleanup): New function.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/passprompt.c
1
 
/*  -*- coding: utf-8 -*- */
2
 
/*
3
 
 * Passprompt - Read a password from the terminal and print it
4
 
 *
5
 
 * Copyright © 2007-2008 Teddy Hogeborn & Björn Påhlsson
6
 
 * 
7
 
 * This program is free software: you can redistribute it and/or
8
 
 * modify it under the terms of the GNU General Public License as
9
 
 * published by the Free Software Foundation, either version 3 of the
10
 
 * License, or (at your option) any later version.
11
 
 * 
12
 
 * This program is distributed in the hope that it will be useful, but
13
 
 * WITHOUT ANY WARRANTY; without even the implied warranty of
14
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 
 * 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
19
 
 * <http://www.gnu.org/licenses/>.
20
 
 * 
21
 
 * Contact the authors at <https://www.fukt.bsnet.se/~belorn/> and
22
 
 * <https://www.fukt.bsnet.se/~teddy/>.
23
 
 */
24
 
 
25
1
#define _GNU_SOURCE             /* getline() */
26
 
 
 
2
#define _FORTIFY_SOURCE 2
27
3
#include <termios.h>            /* struct termios, tcsetattr(),
28
4
                                   TCSAFLUSH, tcgetattr(), ECHO */
29
5
#include <unistd.h>             /* struct termios, tcsetattr(),
35
11
                                   SIGQUIT, SIGHUP, SIGTERM */
36
12
#include <stddef.h>             /* NULL, size_t */
37
13
#include <sys/types.h>          /* ssize_t */
38
 
#include <stdlib.h>             /* EXIT_SUCCESS, EXIT_FAILURE,
39
 
                                   getopt_long */
 
14
#include <stdlib.h>             /* EXIT_SUCCESS, EXIT_FAILURE */
40
15
#include <stdio.h>              /* fprintf(), stderr, getline(),
41
16
                                   stdin, feof(), perror(), fputc(),
42
 
                                   stdout, getopt_long */
 
17
                                   stdout */
43
18
#include <errno.h>              /* errno, EINVAL */
44
19
#include <iso646.h>             /* or, not */
45
20
#include <stdbool.h>            /* bool, false, true */
46
 
#include <string.h>             /* strlen, rindex, strncmp, strcmp */
47
 
#include <getopt.h>             /* getopt_long */
48
21
 
49
22
volatile bool quit_now = false;
50
 
bool debug = false;
51
23
 
52
 
static void termination_handler(__attribute__((unused))int signum){
 
24
void termination_handler(int signum){
53
25
  quit_now = true;
54
26
}
55
27
 
56
28
int main(int argc, char **argv){
57
 
  ssize_t ret;
 
29
  ssize_t ret = -1;
58
30
  size_t n;
59
31
  struct termios t_new, t_old;
60
32
  char *buffer = NULL;
61
 
  char *prefix = NULL;
62
33
  int status = EXIT_SUCCESS;
63
34
  struct sigaction old_action,
64
35
    new_action = { .sa_handler = termination_handler,
65
36
                   .sa_flags = 0 };
66
 
 
67
 
  while (true){
68
 
    static struct option long_options[] = {
69
 
      {"debug", no_argument, (int *)&debug, 1},
70
 
      {"prefix", required_argument, 0, 'p'},
71
 
      {0, 0, 0, 0} };
72
 
 
73
 
    int option_index = 0;
74
 
    ret = getopt_long (argc, argv, "p:", long_options, &option_index);
75
 
 
76
 
    if (ret == -1){
77
 
      break;
78
 
    }
79
 
      
80
 
    switch(ret){
81
 
    case 0:
82
 
      break;
83
 
    case 'p':
84
 
      prefix = optarg;
85
 
      break;
86
 
    default:
87
 
      fprintf(stderr, "bad arguments\n");
88
 
      exit(EXIT_FAILURE);
89
 
    }
90
 
  }
91
 
      
92
 
  if (debug){
93
 
    fprintf(stderr, "Starting %s\n", argv[0]);
94
 
  }
95
 
  if (debug){
96
 
    fprintf(stderr, "Storing current terminal attributes\n");
97
 
  }
98
37
  
99
38
  if (tcgetattr(STDIN_FILENO, &t_old) != 0){
100
39
    return EXIT_FAILURE;
102
41
  
103
42
  sigemptyset(&new_action.sa_mask);
104
43
  sigaddset(&new_action.sa_mask, SIGINT);
 
44
  sigaddset(&new_action.sa_mask, SIGQUIT);
105
45
  sigaddset(&new_action.sa_mask, SIGHUP);
106
46
  sigaddset(&new_action.sa_mask, SIGTERM);
107
47
  sigaction(SIGINT, NULL, &old_action);
108
48
  if (old_action.sa_handler != SIG_IGN)
109
49
    sigaction(SIGINT, &new_action, NULL);
 
50
  sigaction(SIGQUIT, NULL, &old_action);
 
51
  if (old_action.sa_handler != SIG_IGN)
 
52
    sigaction(SIGQUIT, &new_action, NULL);
110
53
  sigaction(SIGHUP, NULL, &old_action);
111
54
  if (old_action.sa_handler != SIG_IGN)
112
55
    sigaction(SIGHUP, &new_action, NULL);
113
56
  sigaction(SIGTERM, NULL, &old_action);
114
57
  if (old_action.sa_handler != SIG_IGN)
115
58
    sigaction(SIGTERM, &new_action, NULL);
116
 
 
117
 
  
118
 
  if (debug){
119
 
    fprintf(stderr, "Removing echo flag from terminal attributes\n");
120
 
  }
121
59
  
122
60
  t_new = t_old;
123
61
  t_new.c_lflag &= ~ECHO;
125
63
    perror("tcsetattr-echo");
126
64
    return EXIT_FAILURE;
127
65
  }
128
 
 
129
 
  if (debug){
130
 
    fprintf(stderr, "Waiting for input from stdin \n");
131
 
  }
 
66
  
132
67
  while(true){
133
68
    if (quit_now){
134
69
      status = EXIT_FAILURE;
135
70
      break;
136
71
    }
137
 
 
138
 
    if(prefix){
139
 
      fprintf(stderr, "%s Password: ", prefix);
140
 
    } else {
141
 
      fprintf(stderr, "Password: ");
142
 
    }      
 
72
    fprintf(stderr, "Password: ");
143
73
    ret = getline(&buffer, &n, stdin);
144
74
    if (ret > 0){
145
75
      fprintf(stdout, "%s", buffer);
146
76
      status = EXIT_SUCCESS;
147
77
      break;
148
78
    }
 
79
    // ret == 0 makes no other sence than to retry to read from stdin
149
80
    if (ret < 0){
150
81
      if (errno != EINTR and not feof(stdin)){
151
82
        perror("getline");
153
84
        break;
154
85
      }
155
86
    }
156
 
    /* if(ret == 0), then the only sensible thing to do is to retry to
157
 
       read from stdin */
158
87
    fputc('\n', stderr);
159
88
  }
160
 
  
161
 
  if (debug){
162
 
    fprintf(stderr, "Restoring terminal attributes\n");
163
 
  }
 
89
 
164
90
  if (tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_old) != 0){
165
91
    perror("tcsetattr+echo");
166
92
  }
167
93
  
168
 
  if (debug){
169
 
    fprintf(stderr, "%s is exiting\n", argv[0]);
170
 
  }
171
 
  
172
94
  return status;
173
95
}