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

  • Committer: Teddy Hogeborn
  • Date: 2011-02-27 17:26:35 UTC
  • Revision ID: teddy@fukt.bsnet.se-20110227172635-hw1sire7k3vuo1co
Update copyright year to "2011" wherever appropriate.

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-2011 Teddy Hogeborn
 
6
 * Copyright © 2010-2011 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
 
1
25
#define _GNU_SOURCE             /* asprintf(), TEMP_FAILURE_RETRY() */
2
26
#include <signal.h>             /* sig_atomic_t, struct sigaction,
3
27
                                   sigemptyset(), sigaddset(), SIGINT,
52
76
  char *prompt;
53
77
  const char *const cryptsource = getenv("cryptsource");
54
78
  const char *const crypttarget = getenv("crypttarget");
55
 
  const char prompt_start[] = "Enter passphrase to unlock the disk";
 
79
  const char prompt_start[] = "Unlocking the disk";
 
80
  const char prompt_end[] = "Enter passphrase";
56
81
  
57
82
  if(cryptsource == NULL){
58
83
    if(crypttarget == NULL){
59
 
      ret = asprintf(&prompt, "%s: ", prompt_start);
 
84
      ret = asprintf(&prompt, "%s\n%s", prompt_start, prompt_end);
60
85
    } else {
61
 
      ret = asprintf(&prompt, "%s (%s): ", prompt_start,
62
 
                     crypttarget);
 
86
      ret = asprintf(&prompt, "%s (%s)\n%s", prompt_start,
 
87
                     crypttarget, prompt_end);
63
88
    }
64
89
  } else {
65
90
    if(crypttarget == NULL){
66
 
      ret = asprintf(&prompt, "%s %s: ", prompt_start, cryptsource);
 
91
      ret = asprintf(&prompt, "%s %s\n%s", prompt_start, cryptsource,
 
92
                     prompt_end);
67
93
    } else {
68
 
      ret = asprintf(&prompt, "%s %s (%s): ", prompt_start,
69
 
                     cryptsource, crypttarget);
 
94
      ret = asprintf(&prompt, "%s %s (%s)\n%s", prompt_start,
 
95
                     cryptsource, crypttarget, prompt_end);
70
96
    }
71
97
  }
72
98
  if(ret == -1){
118
144
        _exit(EX_OSERR);
119
145
      }
120
146
    }
121
 
 
 
147
    
122
148
    char **new_argv = NULL;
123
 
    char *tmp;
 
149
    char **tmp;
124
150
    int i = 0;
125
 
    for (; argv[i]!=(char *)NULL; i++){
 
151
    for (; argv[i]!=NULL; i++){
126
152
      tmp = realloc(new_argv, sizeof(const char *) * ((size_t)i + 1));
127
153
      if (tmp == NULL){
128
154
        error(0, errno, "realloc");
129
155
        free(new_argv);
130
156
        _exit(EX_OSERR);
131
157
      }
132
 
      new_argv = (char **)tmp;
 
158
      new_argv = tmp;
133
159
      new_argv[i] = strdup(argv[i]);
134
160
    }
135
 
    new_argv[i] = (char *) NULL;
 
161
    new_argv[i] = NULL;
136
162
    
137
163
    execv(path, (char *const *)new_argv);
138
164
    error(0, errno, "execv");
172
198
      return 0;
173
199
    }
174
200
  }
175
 
  char exe_target[sizeof(plymouth_path)];
 
201
  char exe_target[sizeof(plymouthd_path)];
176
202
  char *exe_link;
177
203
  ret = asprintf(&exe_link, "/proc/%s/exe", proc_entry->d_name);
178
204
  if(ret == -1){
199
225
  
200
226
  ssize_t sret = readlink(exe_link, exe_target, sizeof(exe_target));
201
227
  free(exe_link);
202
 
  if((sret != (ssize_t)sizeof(plymouth_path)-1) or
203
 
      (memcmp(plymouth_path, exe_target,
204
 
              sizeof(plymouth_path)-1) != 0)){
 
228
  if((sret != (ssize_t)sizeof(plymouthd_path)-1) or
 
229
      (memcmp(plymouthd_path, exe_target,
 
230
              sizeof(plymouthd_path)-1) != 0)){
205
231
    return 0;
206
232
  }
207
233
  return 1;
221
247
  if(maxvalue == 0){
222
248
    struct dirent **direntries;
223
249
    ret = scandir("/proc", &direntries, is_plymouth, alphasort);
224
 
    sscanf(direntries[0]->d_name, "%" SCNuMAX, &maxvalue);
 
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
    }
225
259
  }
226
260
  pid_t pid;
227
261
  pid = (pid_t)maxvalue;