/mandos/release

« back to all changes in this revision

Viewing changes to plugins.d/plymouth.c

• browse files at revision 284
• compare with another revision
• download diff
• download tarball
• view history from revision 284

• reverse the comparison (284 to 237.7.427)
• stop comparing with revision 237.7.427

Show diffs side-by-side

added

removed

plugins.d/plymouth.c

2

2

/*

3

3

 * Plymouth - Read a password from Plymouth and output it

4

4

 * 

5

 

 * Copyright © 2010-2016 Teddy Hogeborn

6

 

 * Copyright © 2010-2016 Björn Påhlsson

 

5

 * Copyright © 2010-2011 Teddy Hogeborn

 

6

 * Copyright © 2010-2011 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 <mandos@recompile.se>.

 

22

 * Contact the authors at <mandos@fukt.bsnet.se>.

23

23

 */

24

24

 

25

25

#define _GNU_SOURCE             /* asprintf(), TEMP_FAILURE_RETRY() */

54

54

#include <stdarg.h>             /* va_list, va_start(), ... */

55

55

 

56

56

sig_atomic_t interrupted_by_signal = 0;

57

 

 

58

 

/* Used by Ubuntu 11.04 (Natty Narwahl) */

59

 

const char plymouth_old_pid[] = "/dev/.initramfs/plymouth.pid";

60

 

/* Used by Ubuntu 11.10 (Oneiric Ocelot) */

61

 

const char plymouth_pid[] = "/run/initramfs/plymouth.pid";

62

 

 

 

57

const char plymouth_pid[] = "/dev/.initramfs/plymouth.pid";

63

58

const char plymouth_path[] = "/bin/plymouth";

64

59

const char plymouthd_path[] = "/sbin/plymouthd";

65

60

const char *plymouthd_default_argv[] = {"/sbin/plymouthd",

66

61

                                        "--mode=boot",

67

62

                                        "--attach-to-session",

 

63

                                        "--pid-file="

 

64

                                        "/dev/.initramfs/"

 

65

                                        "plymouth.pid",

68

66

                                        NULL };

69

67

 

70

68

static void termination_handler(__attribute__((unused))int signum){

75

73

}

76

74

 

77

75

/* Function to use when printing errors */

78

 

__attribute__((format (gnu_printf, 3, 4)))

79

76

void error_plus(int status, int errnum, const char *formatstring,

80

77

                ...){

81

78

  va_list ap;

84

81

  

85

82

  va_start(ap, formatstring);

86

83

  ret = vasprintf(&text, formatstring, ap);

87

 

  if(ret == -1){

 

84

  if (ret == -1){

88

85

    fprintf(stderr, "Mandos plugin %s: ",

89

86

            program_invocation_short_name);

90

87

    vfprintf(stderr, formatstring, ap);

154

151

  return true;

155

152

}

156

153

 

157

 

__attribute__((nonnull (2, 3)))

158

154

bool exec_and_wait(pid_t *pid_return, const char *path,

159

 

                   const char * const *argv, bool interruptable,

 

155

                   const char **argv, bool interruptable,

160

156

                   bool daemonize){

161

157

  int status;

162

158

  int ret;

174

170

      }

175

171

    }

176

172

    

177

 

    char **new_argv = malloc(sizeof(const char *));

178

 

    if(new_argv == NULL){

179

 

      error_plus(0, errno, "malloc");

180

 

      _exit(EX_OSERR);

181

 

    }

 

173

    char **new_argv = NULL;

182

174

    char **tmp;

183

175

    int i = 0;

184

176

    for (; argv[i]!=NULL; i++){

185

 

      tmp = realloc(new_argv, sizeof(const char *) * ((size_t)i + 2));

186

 

      if(tmp == NULL){

 

177

      tmp = realloc(new_argv, sizeof(const char *) * ((size_t)i + 1));

 

178

      if (tmp == NULL){

187

179

        error_plus(0, errno, "realloc");

188

180

        free(new_argv);

189

181

        _exit(EX_OSERR);

218

210

  return false;

219

211

}

220

212

 

221

 

__attribute__((nonnull))

222

213

int is_plymouth(const struct dirent *proc_entry){

223

214

  int ret;

224

215

  {

225

 

    uintmax_t proc_id;

 

216

    uintmax_t maxvalue;

226

217

    char *tmp;

227

218

    errno = 0;

228

 

    proc_id = strtoumax(proc_entry->d_name, &tmp, 10);

 

219

    maxvalue = strtoumax(proc_entry->d_name, &tmp, 10);

229

220

 

230

221

    if(errno != 0 or *tmp != '\0'

231

 

       or proc_id != (uintmax_t)((pid_t)proc_id)){

 

222

       or maxvalue != (uintmax_t)((pid_t)maxvalue)){

232

223

      return 0;

233

224

    }

234

225

  }

269

260

 

270

261

pid_t get_pid(void){

271

262

  int ret;

272

 

  uintmax_t proc_id = 0;

273

263

  FILE *pidfile = fopen(plymouth_pid, "r");

274

 

  /* Try the new pid file location */

 

264

  uintmax_t maxvalue = 0;

275

265

  if(pidfile != NULL){

276

 

    ret = fscanf(pidfile, "%" SCNuMAX, &proc_id);

 

266

    ret = fscanf(pidfile, "%" SCNuMAX, &maxvalue);

277

267

    if(ret != 1){

278

 

      proc_id = 0;

 

268

      maxvalue = 0;

279

269

    }

280

270

    fclose(pidfile);

281

271

  }

282

 

  /* Try the old pid file location */

283

 

  if(proc_id == 0){

284

 

    pidfile = fopen(plymouth_pid, "r");

285

 

    if(pidfile != NULL){

286

 

      ret = fscanf(pidfile, "%" SCNuMAX, &proc_id);

287

 

      if(ret != 1){

288

 

        proc_id = 0;

289

 

      }

290

 

      fclose(pidfile);

291

 

    }

292

 

  }

293

 

  /* Look for a plymouth process */

294

 

  if(proc_id == 0){

 

272

  if(maxvalue == 0){

295

273

    struct dirent **direntries = NULL;

296

274

    ret = scandir("/proc", &direntries, is_plymouth, alphasort);

297

 

    if(ret == -1){

 

275

    if (ret == -1){

298

276

      error_plus(0, errno, "scandir");

299

277

    }

300

 

    if(ret > 0){

301

 

      ret = sscanf(direntries[0]->d_name, "%" SCNuMAX, &proc_id);

302

 

      if(ret < 0){

 

278

    if (ret > 0){

 

279

      ret = sscanf(direntries[0]->d_name, "%" SCNuMAX, &maxvalue);

 

280

      if (ret < 0){

303

281

        error_plus(0, errno, "sscanf");

304

282

      }

305

283

    }

308

286

    free(direntries);

309

287

  }

310

288

  pid_t pid;

311

 

  pid = (pid_t)proc_id;

312

 

  if((uintmax_t)pid == proc_id){

 

289

  pid = (pid_t)maxvalue;

 

290

  if((uintmax_t)pid == maxvalue){

313

291

    return pid;

314

292

  }

315

293

  

316

294

  return 0;

317

295

}

318

296

 

319

 

const char * const * getargv(pid_t pid){

 

297

const char **getargv(pid_t pid){

320

298

  int cl_fd;

321

299

  char *cmdline_filename;

322

300

  ssize_t sret;

383

361

    return NULL;

384

362

  }

385

363

  argz_extract(cmdline, cmdline_len, argv); /* Create argv */

386

 

  return (const char * const *)argv;

 

364

  return (const char **)argv;

387

365

}

388

366

 

389

367

int main(__attribute__((unused))int argc,

464

442

  }

465

443

  kill_and_wait(plymouth_command_pid);

466

444

  

467

 

  const char * const *plymouthd_argv;

 

445

  const char **plymouthd_argv;

468

446

  pid_t pid = get_pid();

469

447

  if(pid == 0){

470

448

    error_plus(0, 0, "plymouthd pid not found");

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0