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

  • Committer: Teddy Hogeborn
  • Date: 2014-07-25 22:44:20 UTC
  • mto: (237.7.272 trunk)
  • mto: This revision was merged to the branch mainline in revision 321.
  • Revision ID: teddy@recompile.se-20140725224420-4a5ct2ptt0hsc92z
Require Python 2.7.

This is in preparation for the eventual move to Python 3, which will
happen as soon as all Python modules required by Mandos are available.
The mandos-ctl and mandos-monitor programs are already portable
between Python 2.6 and Python 3 without changes; this change will
bring the requirement up to Python 2.7.

* INSTALL (Prerequisites/Libraries/Mandos Server): Document
                                                   requirement of
                                                   Python 2.7; remove
                                                   Python-argparse
                                                   which is in the
                                                   Python 2.7 standard
                                                   library.
* debian/control (Source: mandos/Build-Depends-Indep): Depend on
                                                       exactly the
                                                       python2.7
                                                       package and all
                                                       the Python 2.7
                                                       versions of the
                                                       python modules.
  (Package: mandos/Depends): - '' - but still depend on python (<=2.7)
                            and the generic versions of the Python
                            modules; this is for mandos-ctl and
                            mandos-monitor, both of which are
                            compatible with Python 3, and use
                            #!/usr/bin/python.
* mandos: Use #!/usr/bin/python2.7 instead of #!/usr/bin/python.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/askpass-fifo.c
2
2
/*
3
3
 * Askpass-FIFO - Read a password from a FIFO and output it
4
4
 * 
5
 
 * Copyright © 2008,2009 Teddy Hogeborn
6
 
 * Copyright © 2008,2009 Björn Påhlsson
 
5
 * Copyright © 2008-2014 Teddy Hogeborn
 
6
 * Copyright © 2008-2014 Björn Påhlsson
7
7
 * 
8
8
 * This program is free software: you can redistribute it and/or
9
9
 * modify it under the terms of the GNU General Public License as
19
19
 * along with this program.  If not, see
20
20
 * <http://www.gnu.org/licenses/>.
21
21
 * 
22
 
 * Contact the authors at <https://www.fukt.bsnet.se/~belorn/> and
23
 
 * <https://www.fukt.bsnet.se/~teddy/>.
 
22
 * Contact the authors at <mandos@recompile.se>.
24
23
 */
25
24
 
26
25
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY() */
27
26
#include <sys/types.h>          /* ssize_t */
28
27
#include <sys/stat.h>           /* mkfifo(), S_IRUSR, S_IWUSR */
29
28
#include <iso646.h>             /* and */
30
 
#include <errno.h>              /* errno, EEXIST */
31
 
#include <stdio.h>              /* perror() */
32
 
#include <stdlib.h>             /* EXIT_FAILURE, NULL, size_t, free(), 
 
29
#include <errno.h>              /* errno, EACCES, ENOTDIR, ELOOP,
 
30
                                   ENAMETOOLONG, ENOSPC, EROFS,
 
31
                                   ENOENT, EEXIST, EFAULT, EMFILE,
 
32
                                   ENFILE, ENOMEM, EBADF, EINVAL, EIO,
 
33
                                   EISDIR, EFBIG */
 
34
#include <error.h>              /* error() */
 
35
#include <stdio.h>              /* fprintf(), vfprintf(),
 
36
                                   vasprintf() */
 
37
#include <stdlib.h>             /* EXIT_FAILURE, NULL, size_t, free(),
33
38
                                   realloc(), EXIT_SUCCESS */
34
39
#include <fcntl.h>              /* open(), O_RDONLY */
35
40
#include <unistd.h>             /* read(), close(), write(),
36
41
                                   STDOUT_FILENO */
37
 
 
 
42
#include <sysexits.h>           /* EX_OSERR, EX_OSFILE,
 
43
                                   EX_UNAVAILABLE, EX_IOERR */
 
44
#include <string.h>             /* strerror() */
 
45
#include <stdarg.h>             /* va_list, va_start(), ... */
 
46
 
 
47
 
 
48
/* Function to use when printing errors */
 
49
__attribute__((format (gnu_printf, 3, 4)))
 
50
void error_plus(int status, int errnum, const char *formatstring,
 
51
                ...){
 
52
  va_list ap;
 
53
  char *text;
 
54
  int ret;
 
55
  
 
56
  va_start(ap, formatstring);
 
57
  ret = vasprintf(&text, formatstring, ap);
 
58
  if(ret == -1){
 
59
    fprintf(stderr, "Mandos plugin %s: ",
 
60
            program_invocation_short_name);
 
61
    vfprintf(stderr, formatstring, ap);
 
62
    fprintf(stderr, ": ");
 
63
    fprintf(stderr, "%s\n", strerror(errnum));
 
64
    error(status, errno, "vasprintf while printing error");
 
65
    return;
 
66
  }
 
67
  fprintf(stderr, "Mandos plugin ");
 
68
  error(status, errnum, "%s", text);
 
69
  free(text);
 
70
}
38
71
 
39
72
int main(__attribute__((unused))int argc,
40
73
         __attribute__((unused))char **argv){
43
76
  
44
77
  /* Create FIFO */
45
78
  const char passfifo[] = "/lib/cryptsetup/passfifo";
46
 
  ret = (int)TEMP_FAILURE_RETRY(mkfifo(passfifo, S_IRUSR | S_IWUSR));
47
 
  if(ret == -1 and errno != EEXIST){
48
 
    perror("mkfifo");
49
 
    return EXIT_FAILURE;
 
79
  ret = mkfifo(passfifo, S_IRUSR | S_IWUSR);
 
80
  if(ret == -1){
 
81
    int e = errno;
 
82
    switch(e){
 
83
    case EACCES:
 
84
    case ENOTDIR:
 
85
    case ELOOP:
 
86
      error_plus(EX_OSFILE, errno, "mkfifo");
 
87
    case ENAMETOOLONG:
 
88
    case ENOSPC:
 
89
    case EROFS:
 
90
    default:
 
91
      error_plus(EX_OSERR, errno, "mkfifo");
 
92
    case ENOENT:
 
93
      /* no "/lib/cryptsetup"? */
 
94
      error_plus(EX_UNAVAILABLE, errno, "mkfifo");
 
95
    case EEXIST:
 
96
      break;                    /* not an error */
 
97
    }
50
98
  }
51
99
  
52
100
  /* Open FIFO */
53
 
  int fifo_fd = (int)TEMP_FAILURE_RETRY(open(passfifo, O_RDONLY));
 
101
  int fifo_fd = open(passfifo, O_RDONLY);
54
102
  if(fifo_fd == -1){
55
 
    perror("open");
56
 
    return EXIT_FAILURE;
 
103
    int e = errno;
 
104
    error_plus(0, errno, "open");
 
105
    switch(e){
 
106
    case EACCES:
 
107
    case ENOENT:
 
108
    case EFAULT:
 
109
      return EX_UNAVAILABLE;
 
110
    case ENAMETOOLONG:
 
111
    case EMFILE:
 
112
    case ENFILE:
 
113
    case ENOMEM:
 
114
    default:
 
115
      return EX_OSERR;
 
116
    case ENOTDIR:
 
117
    case ELOOP:
 
118
      return EX_OSFILE;
 
119
    }
57
120
  }
58
121
  
59
122
  /* Read from FIFO */
62
125
  {
63
126
    size_t buf_allocated = 0;
64
127
    const size_t blocksize = 1024;
65
 
    do{
 
128
    do {
66
129
      if(buf_len + blocksize > buf_allocated){
67
130
        char *tmp = realloc(buf, buf_allocated + blocksize);
68
131
        if(tmp == NULL){
69
 
          perror("realloc");
 
132
          error_plus(0, errno, "realloc");
70
133
          free(buf);
71
 
          return EXIT_FAILURE;
 
134
          return EX_OSERR;
72
135
        }
73
136
        buf = tmp;
74
137
        buf_allocated += blocksize;
75
138
      }
76
 
      sret = TEMP_FAILURE_RETRY(read(fifo_fd, buf + buf_len,
77
 
                                     buf_allocated - buf_len));
 
139
      sret = read(fifo_fd, buf + buf_len, buf_allocated - buf_len);
78
140
      if(sret == -1){
79
 
        perror("read");
 
141
        int e = errno;
80
142
        free(buf);
81
 
        return EXIT_FAILURE;
 
143
        errno = e;
 
144
        error_plus(0, errno, "read");
 
145
        switch(e){
 
146
        case EBADF:
 
147
        case EFAULT:
 
148
        case EINVAL:
 
149
        default:
 
150
          return EX_OSERR;
 
151
        case EIO:
 
152
          return EX_IOERR;
 
153
        case EISDIR:
 
154
          return EX_UNAVAILABLE;
 
155
        }
82
156
      }
83
157
      buf_len += (size_t)sret;
84
 
    }while(sret != 0);
 
158
    } while(sret != 0);
85
159
  }
86
160
  
87
161
  /* Close FIFO */
88
 
  TEMP_FAILURE_RETRY(close(fifo_fd));
 
162
  close(fifo_fd);
89
163
  
90
164
  /* Print password to stdout */
91
165
  size_t written = 0;
92
166
  while(written < buf_len){
93
 
    sret = TEMP_FAILURE_RETRY(write(STDOUT_FILENO, buf + written,
94
 
                                    buf_len - written));
 
167
    sret = write(STDOUT_FILENO, buf + written, buf_len - written);
95
168
    if(sret == -1){
96
 
      perror("write");
 
169
      int e = errno;
97
170
      free(buf);
98
 
      return EXIT_FAILURE;
 
171
      errno = e;
 
172
      error_plus(0, errno, "write");
 
173
      switch(e){
 
174
      case EBADF:
 
175
      case EFAULT:
 
176
      case EINVAL:
 
177
        return EX_OSFILE;
 
178
      case EFBIG:
 
179
      case EIO:
 
180
      case ENOSPC:
 
181
      default:
 
182
        return EX_IOERR;
 
183
      }
99
184
    }
100
185
    written += (size_t)sret;
101
186
  }
102
187
  free(buf);
103
188
  
 
189
  ret = close(STDOUT_FILENO);
 
190
  if(ret == -1){
 
191
    int e = errno;
 
192
    error_plus(0, errno, "close");
 
193
    switch(e){
 
194
    case EBADF:
 
195
      return EX_OSFILE;
 
196
    case EIO:
 
197
    default:
 
198
      return EX_IOERR;
 
199
    }
 
200
  }
104
201
  return EXIT_SUCCESS;
105
202
}