/mandos/trunk

« back to all changes in this revision

Viewing changes to plugins.d/plymouth.c

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

• reverse the comparison (237.4.106 to 533)
• stop comparing with revision 533

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-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

 

5

 * Copyright © 2010-2018 Teddy Hogeborn

 

6

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

 

7

 * 

 

8

 * This file is part of Mandos.

 

9

 * 

 

10

 * Mandos is free software: you can redistribute it and/or modify it

 

11

 * under the terms of the GNU General Public License as published by

 

12

 * the Free Software Foundation, either version 3 of the License, or

 

13

 * (at your option) any later version.

 

14

 * 

 

15

 * Mandos is distributed in the hope that it will be useful, but

14

16

 * WITHOUT ANY WARRANTY; without even the implied warranty of

15

17

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

16

18

 * General Public License for more details.

17

19

 * 

18

20

 * 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

 * along with Mandos.  If not, see <http://www.gnu.org/licenses/>.

21

22

 * 

22

23

 * Contact the authors at <mandos@recompile.se>.

23

24

 */

56

57

sig_atomic_t interrupted_by_signal = 0;

57

58

 

58

59

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

59

 

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

 

60

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

60

61

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

61

 

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

 

62

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

 

63

/* Used by Debian 9 (stretch) */

 

64

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

62

65

 

63

66

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

64

67

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

84

87

  

85

88

  va_start(ap, formatstring);

86

89

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

87

 

  if (ret == -1){

 

90

  if(ret == -1){

88

91

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

89

92

            program_invocation_short_name);

90

93

    vfprintf(stderr, formatstring, ap);

154

157

  return true;

155

158

}

156

159

 

 

160

__attribute__((nonnull (2, 3)))

157

161

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

158

 

                   const char **argv, bool interruptable,

 

162

                   const char * const *argv, bool interruptable,

159

163

                   bool daemonize){

160

164

  int status;

161

165

  int ret;

173

177

      }

174

178

    }

175

179

    

176

 

    char **new_argv = NULL;

 

180

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

 

181

    if(new_argv == NULL){

 

182

      error_plus(0, errno, "malloc");

 

183

      _exit(EX_OSERR);

 

184

    }

177

185

    char **tmp;

178

186

    int i = 0;

179

 

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

180

 

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

181

 

      if (tmp == NULL){

 

187

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

 

188

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

 

189

      if(tmp == NULL){

182

190

        error_plus(0, errno, "realloc");

183

191

        free(new_argv);

184

192

        _exit(EX_OSERR);

213

221

  return false;

214

222

}

215

223

 

 

224

__attribute__((nonnull))

216

225

int is_plymouth(const struct dirent *proc_entry){

217

226

  int ret;

218

227

  {

219

 

    uintmax_t maxvalue;

 

228

    uintmax_t proc_id;

220

229

    char *tmp;

221

230

    errno = 0;

222

 

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

 

231

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

223

232

 

224

233

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

225

 

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

 

234

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

226

235

      return 0;

227

236

    }

228

237

  }

263

272

 

264

273

pid_t get_pid(void){

265

274

  int ret;

266

 

  uintmax_t maxvalue = 0;

 

275

  uintmax_t proc_id = 0;

267

276

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

268

277

  /* Try the new pid file location */

269

278

  if(pidfile != NULL){

270

 

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

 

279

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

271

280

    if(ret != 1){

272

 

      maxvalue = 0;

 

281

      proc_id = 0;

273

282

    }

274

283

    fclose(pidfile);

275

284

  }

276

285

  /* Try the old pid file location */

277

 

  if(maxvalue == 0){

278

 

    pidfile = fopen(plymouth_pid, "r");

279

 

    if(pidfile != NULL){

280

 

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

281

 

      if(ret != 1){

282

 

        maxvalue = 0;

 

286

  if(proc_id == 0){

 

287

    pidfile = fopen(plymouth_old_pid, "r");

 

288

    if(pidfile != NULL){

 

289

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

 

290

      if(ret != 1){

 

291

        proc_id = 0;

 

292

      }

 

293

      fclose(pidfile);

 

294

    }

 

295

  }

 

296

  /* Try the old old pid file location */

 

297

  if(proc_id == 0){

 

298

    pidfile = fopen(plymouth_old_old_pid, "r");

 

299

    if(pidfile != NULL){

 

300

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

 

301

      if(ret != 1){

 

302

        proc_id = 0;

283

303

      }

284

304

      fclose(pidfile);

285

305

    }

286

306

  }

287

307

  /* Look for a plymouth process */

288

 

  if(maxvalue == 0){

 

308

  if(proc_id == 0){

289

309

    struct dirent **direntries = NULL;

290

310

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

291

 

    if (ret == -1){

 

311

    if(ret == -1){

292

312

      error_plus(0, errno, "scandir");

293

313

    }

294

 

    if (ret > 0){

295

 

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

296

 

      if (ret < 0){

297

 

        error_plus(0, errno, "sscanf");

 

314

    if(ret > 0){

 

315

      for(int i = ret-1; i >= 0; i--){

 

316

        if(proc_id == 0){

 

317

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

 

318

          if(ret < 0){

 

319

            error_plus(0, errno, "sscanf");

 

320

          }

 

321

        }

 

322

        free(direntries[i]);

298

323

      }

299

324

    }

300

325

    /* scandir might preallocate for this variable (man page unclear).

302

327

    free(direntries);

303

328

  }

304

329

  pid_t pid;

305

 

  pid = (pid_t)maxvalue;

306

 

  if((uintmax_t)pid == maxvalue){

 

330

  pid = (pid_t)proc_id;

 

331

  if((uintmax_t)pid == proc_id){

307

332

    return pid;

308

333

  }

309

334

  

310

335

  return 0;

311

336

}

312

337

 

313

 

const char **getargv(pid_t pid){

 

338

char **getargv(pid_t pid){

314

339

  int cl_fd;

315

340

  char *cmdline_filename;

316

341

  ssize_t sret;

377

402

    return NULL;

378

403

  }

379

404

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

380

 

  return (const char **)argv;

 

405

  return argv;

381

406

}

382

407

 

383

408

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

458

483

  }

459

484

  kill_and_wait(plymouth_command_pid);

460

485

  

461

 

  const char **plymouthd_argv;

 

486

  char **plymouthd_argv = NULL;

462

487

  pid_t pid = get_pid();

463

488

  if(pid == 0){

464

489

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

465

 

    plymouthd_argv = plymouthd_default_argv;

466

490

  } else {

467

491

    plymouthd_argv = getargv(pid);

468

492

  }

471

495

                       { plymouth_path, "quit", NULL },

472

496

                       false, false);

473

497

  if(not bret){

 

498

    if(plymouthd_argv != NULL){

 

499

      free(*plymouthd_argv);

 

500

      free(plymouthd_argv);

 

501

    }

474

502

    exit(EXIT_FAILURE);

475

503

  }

476

 

  bret = exec_and_wait(NULL, plymouthd_path, plymouthd_argv,

 

504

  bret = exec_and_wait(NULL, plymouthd_path,

 

505

                       (plymouthd_argv != NULL)

 

506

                       ? (const char * const *)plymouthd_argv

 

507

                       : plymouthd_default_argv,

477

508

                       false, true);

 

509

  if(plymouthd_argv != NULL){

 

510

    free(*plymouthd_argv);

 

511

    free(plymouthd_argv);

 

512

  }

478

513

  if(not bret){

479

514

    exit(EXIT_FAILURE);

480

515

  }

• Older »

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