/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/plymouth.c

* plugins.d/plymouth.c: Break lines, fix whitespace.  Remove
                        unnecessary casts.

  (main) Exit with EX_UNAVAILABLE if plymouth is not found.  Use first
         argument of error() where useful.  Simplify logic of checking
         results of running the ask-for-password command.  Simplify
         assigning value to "plymouthd_argv".

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/plymouth.c
1
 
/*  -*- coding: utf-8 -*- */
2
 
/*
3
 
 * Plymouth - Read a password from Plymouth and output it
4
 
 * 
5
 
 * Copyright © 2010 Teddy Hogeborn
6
 
 * Copyright © 2010 Björn Påhlsson
7
 
 * 
8
 
 * This program is free software: you can redistribute it and/or
9
 
 * modify it under the terms of the GNU General Public License as
10
 
 * published by the Free Software Foundation, either version 3 of the
11
 
 * License, or (at your option) any later version.
12
 
 * 
13
 
 * This program is distributed in the hope that it will be useful, but
14
 
 * WITHOUT ANY WARRANTY; without even the implied warranty of
15
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16
 
 * General Public License for more details.
17
 
 * 
18
 
 * You should have received a copy of the GNU General Public License
19
 
 * along with this program.  If not, see
20
 
 * <http://www.gnu.org/licenses/>.
21
 
 * 
22
 
 * Contact the authors at <mandos@fukt.bsnet.se>.
23
 
 */
24
 
 
25
1
#define _GNU_SOURCE             /* asprintf(), TEMP_FAILURE_RETRY() */
26
2
#include <signal.h>             /* sig_atomic_t, struct sigaction,
27
3
                                   sigemptyset(), sigaddset(), SIGINT,
76
52
  char *prompt;
77
53
  const char *const cryptsource = getenv("cryptsource");
78
54
  const char *const crypttarget = getenv("crypttarget");
79
 
  const char prompt_start[] = "Unlocking the disk";
80
 
  const char prompt_end[] = "Enter passphrase";
 
55
  const char prompt_start[] = "Enter passphrase to unlock the disk";
81
56
  
82
57
  if(cryptsource == NULL){
83
58
    if(crypttarget == NULL){
84
 
      ret = asprintf(&prompt, "%s\n%s", prompt_start, prompt_end);
 
59
      ret = asprintf(&prompt, "%s: ", prompt_start);
85
60
    } else {
86
 
      ret = asprintf(&prompt, "%s (%s)\n%s", prompt_start,
87
 
                     crypttarget, prompt_end);
 
61
      ret = asprintf(&prompt, "%s (%s): ", prompt_start,
 
62
                     crypttarget);
88
63
    }
89
64
  } else {
90
65
    if(crypttarget == NULL){
91
 
      ret = asprintf(&prompt, "%s %s\n%s", prompt_start, cryptsource,
92
 
                     prompt_end);
 
66
      ret = asprintf(&prompt, "%s %s: ", prompt_start, cryptsource);
93
67
    } else {
94
 
      ret = asprintf(&prompt, "%s %s (%s)\n%s", prompt_start,
95
 
                     cryptsource, crypttarget, prompt_end);
 
68
      ret = asprintf(&prompt, "%s %s (%s): ", prompt_start,
 
69
                     cryptsource, crypttarget);
96
70
    }
97
71
  }
98
72
  if(ret == -1){
144
118
        _exit(EX_OSERR);
145
119
      }
146
120
    }
147
 
    
 
121
 
148
122
    char **new_argv = NULL;
149
 
    char **tmp;
 
123
    char *tmp;
150
124
    int i = 0;
151
 
    for (; argv[i]!=NULL; i++){
 
125
    for (; argv[i]!=(char *)NULL; i++){
152
126
      tmp = realloc(new_argv, sizeof(const char *) * ((size_t)i + 1));
153
127
      if (tmp == NULL){
154
128
        error(0, errno, "realloc");
155
129
        free(new_argv);
156
130
        _exit(EX_OSERR);
157
131
      }
158
 
      new_argv = tmp;
 
132
      new_argv = (char **)tmp;
159
133
      new_argv[i] = strdup(argv[i]);
160
134
    }
161
 
    new_argv[i] = NULL;
 
135
    new_argv[i] = (char *) NULL;
162
136
    
163
137
    execv(path, (char *const *)new_argv);
164
138
    error(0, errno, "execv");
198
172
      return 0;
199
173
    }
200
174
  }
201
 
  char exe_target[sizeof(plymouthd_path)];
 
175
  char exe_target[sizeof(plymouth_path)];
202
176
  char *exe_link;
203
177
  ret = asprintf(&exe_link, "/proc/%s/exe", proc_entry->d_name);
204
178
  if(ret == -1){
225
199
  
226
200
  ssize_t sret = readlink(exe_link, exe_target, sizeof(exe_target));
227
201
  free(exe_link);
228
 
  if((sret != (ssize_t)sizeof(plymouthd_path)-1) or
229
 
      (memcmp(plymouthd_path, exe_target,
230
 
              sizeof(plymouthd_path)-1) != 0)){
 
202
  if((sret != (ssize_t)sizeof(plymouth_path)-1) or
 
203
      (memcmp(plymouth_path, exe_target,
 
204
              sizeof(plymouth_path)-1) != 0)){
231
205
    return 0;
232
206
  }
233
207
  return 1;
247
221
  if(maxvalue == 0){
248
222
    struct dirent **direntries;
249
223
    ret = scandir("/proc", &direntries, is_plymouth, alphasort);
250
 
    if (ret == -1){
251
 
      error(0, errno, "scandir");
252
 
    }
253
 
    if (ret > 0){
254
 
      ret = sscanf(direntries[0]->d_name, "%" SCNuMAX, &maxvalue);
255
 
      if (ret < 0){
256
 
        error(0, errno, "sscanf");
257
 
      }
258
 
    }
 
224
    sscanf(direntries[0]->d_name, "%" SCNuMAX, &maxvalue);
259
225
  }
260
226
  pid_t pid;
261
227
  pid = (pid_t)maxvalue;