/mandos/trunk : revision 392

37

#include <stddef.h> /* NULL, size_t, ssize_t */

38

#include <sys/types.h> /* ssize_t */

39

#include <stdlib.h> /* EXIT_SUCCESS, EXIT_FAILURE,

40

getenv() */

40

getopt_long, getenv() */

41

#include <stdio.h> /* fprintf(), stderr, getline(),

42

stdin, feof(), fputc()

43

*/

42

stdin, feof(), perror(), fputc(),

43

getopt_long */

44

#include <errno.h> /* errno, EBADF, ENOTTY, EINVAL,

45

EFAULT, EFBIG, EIO, ENOSPC, EINTR

46

*/

47

#include <error.h> /* error() */

48

47

#include <iso646.h> /* or, not */

49

48

#include <stdbool.h> /* bool, false, true */

50

#include <string.h> /* strlen, rindex */

49

#include <string.h> /* strlen, rindex, strncmp, strcmp */

51

50

#include <argp.h> /* struct argp_option, struct

52

51

argp_state, struct argp,

53

52

argp_parse(), error_t,

71

70

}

72

71

73

72

int main(int argc, char **argv){

74

ssize_t sret;

75

int ret;

73

ssize_t ret;

76

74

size_t n;

77

75

struct termios t_new, t_old;

78

76

char *buffer = NULL;

88

86

.doc = "Prefix shown before the prompt", .group = 2 },

89

87

{ .name = "debug", .key = 128,

90

88

.doc = "Debug mode", .group = 3 },

91

/*

92

* These reproduce what we would get without ARGP_NO_HELP

93

*/

94

{ .name = "help", .key = '?',

95

.doc = "Give this help list", .group = -1 },

96

{ .name = "usage", .key = -3,

97

.doc = "Give a short usage message", .group = -1 },

98

{ .name = "version", .key = 'V',

99

.doc = "Print program version", .group = -1 },

100

89

{ .name = NULL }

101

90

};

102

91

103

92

error_t parse_opt (int key, char *arg, struct argp_state *state){

104

errno = 0;

105

93

switch (key){

106

94

case 'p':

107

95

prefix = arg;

109

97

case 128:

110

98

debug = true;

111

99

break;

112

/*

113

* These reproduce what we would get without ARGP_NO_HELP

114

*/

115

case '?': /* --help */

116

argp_state_help(state, state->out_stream,

117

(ARGP_HELP_STD_HELP | ARGP_HELP_EXIT_ERR)

118

& ~(unsigned int)ARGP_HELP_EXIT_OK);

119

case -3: /* --usage */

120

argp_state_help(state, state->out_stream,

121

ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);

122

case 'V': /* --version */

123

fprintf(state->out_stream, "%s\n", argp_program_version);

124

exit(argp_err_exit_status);

100

case ARGP_KEY_ARG:

101

argp_usage(state);

102

break;

103

case ARGP_KEY_END:

125

104

break;

126

105

default:

127

106

return ARGP_ERR_UNKNOWN;

128

107

}

129

return errno;

108

return 0;

130

109

}

131

110

132

111

struct argp argp = { .options = options, .parser = parse_opt,

133

112

.args_doc = "",

134

113

.doc = "Mandos password-prompt -- Read and"

135

114

" output a password" };

136

ret = argp_parse(&argp, argc, argv,

137

ARGP_IN_ORDER | ARGP_NO_HELP, NULL, NULL);

138

switch(ret){

139

case 0:

140

break;

141

case ENOMEM:

142

default:

143

errno = ret;

144

error(0, errno, "argp_parse");

145

return EX_OSERR;

146

case EINVAL:

147

return EX_USAGE;

115

ret = argp_parse(&argp, argc, argv, 0, 0, NULL);

116

if(ret == ARGP_ERR_UNKNOWN){

117

fprintf(stderr, "Unknown error while parsing arguments\n");

118

return EX_SOFTWARE;

148

119

}

149

120

}

150

121

157

128

158

129

if(tcgetattr(STDIN_FILENO, &t_old) != 0){

159

130

int e = errno;

160

error(0, errno, "tcgetattr");

131

perror("tcgetattr");

161

132

switch(e){

162

133

case EBADF:

163

134

case ENOTTY:

170

141

sigemptyset(&new_action.sa_mask);

171

142

ret = sigaddset(&new_action.sa_mask, SIGINT);

172

143

if(ret == -1){

173

error(0, errno, "sigaddset");

144

perror("sigaddset");

174

145

return EX_OSERR;

175

146

}

176

147

ret = sigaddset(&new_action.sa_mask, SIGHUP);

177

148

if(ret == -1){

178

error(0, errno, "sigaddset");

149

perror("sigaddset");

179

150

return EX_OSERR;

180

151

}

181

152

ret = sigaddset(&new_action.sa_mask, SIGTERM);

182

153

if(ret == -1){

183

error(0, errno, "sigaddset");

154

perror("sigaddset");

184

155

return EX_OSERR;

185

156

}

186

157

/* Need to check if the handler is SIG_IGN before handling:

189

160

*/

190

161

ret = sigaction(SIGINT, NULL, &old_action);

191

162

if(ret == -1){

192

error(0, errno, "sigaction");

163

perror("sigaction");

193

164

return EX_OSERR;

194

165

}

195

166

if(old_action.sa_handler != SIG_IGN){

196

167

ret = sigaction(SIGINT, &new_action, NULL);

197

168

if(ret == -1){

198

error(0, errno, "sigaction");

169

perror("sigaction");

199

170

return EX_OSERR;

200

171

}

201

172

}

202

173

ret = sigaction(SIGHUP, NULL, &old_action);

203

174

if(ret == -1){

204

error(0, errno, "sigaction");

175

perror("sigaction");

205

176

return EX_OSERR;

206

177

}

207

178

if(old_action.sa_handler != SIG_IGN){

208

179

ret = sigaction(SIGHUP, &new_action, NULL);

209

180

if(ret == -1){

210

error(0, errno, "sigaction");

181

perror("sigaction");

211

182

return EX_OSERR;

212

183

}

213

184

}

214

185

ret = sigaction(SIGTERM, NULL, &old_action);

215

186

if(ret == -1){

216

error(0, errno, "sigaction");

187

perror("sigaction");

217

188

return EX_OSERR;

218

189

}

219

190

if(old_action.sa_handler != SIG_IGN){

220

191

ret = sigaction(SIGTERM, &new_action, NULL);

221

192

if(ret == -1){

222

error(0, errno, "sigaction");

193

perror("sigaction");

223

194

return EX_OSERR;

224

195

}

225

196

}

233

204

t_new.c_lflag &= ~(tcflag_t)ECHO;

234

205

if(tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_new) != 0){

235

206

int e = errno;

236

error(0, errno, "tcsetattr-echo");

207

perror("tcsetattr-echo");

237

208

switch(e){

238

209

case EBADF:

239

210

case ENOTTY:

260

231

fprintf(stderr, "%s ", prefix);

261

232

}

262

233

{

263

const char *cryptsource = getenv("CRYPTTAB_SOURCE");

264

const char *crypttarget = getenv("CRYPTTAB_NAME");

265

/* Before cryptsetup 1.1.0~rc2 */

266

if(cryptsource == NULL){

267

cryptsource = getenv("cryptsource");

268

}

269

if(crypttarget == NULL){

270

crypttarget = getenv("crypttarget");

271

}

272

const char *const prompt1 = "Unlocking the disk";

273

const char *const prompt2 = "Enter passphrase";

234

const char *cryptsource = getenv("cryptsource");

235

const char *crypttarget = getenv("crypttarget");

236

const char *const prompt

237

= "Enter passphrase to unlock the disk";

274

238

if(cryptsource == NULL){

275

239

if(crypttarget == NULL){

276

fprintf(stderr, "%s to unlock the disk: ", prompt2);

240

fprintf(stderr, "%s: ", prompt);

277

241

} else {

278

fprintf(stderr, "%s (%s)\n%s: ", prompt1, crypttarget,

279

prompt2);

242

fprintf(stderr, "%s (%s): ", prompt, crypttarget);

280

243

}

281

244

} else {

282

245

if(crypttarget == NULL){

283

fprintf(stderr, "%s %s\n%s: ", prompt1, cryptsource,

284

prompt2);

246

fprintf(stderr, "%s %s: ", prompt, cryptsource);

285

247

} else {

286

fprintf(stderr, "%s %s (%s)\n%s: ", prompt1, cryptsource,

287

crypttarget, prompt2);

248

fprintf(stderr, "%s %s (%s): ", prompt, cryptsource,

249

crypttarget);

288

250

}

289

251

}

290

252

}

291

sret = getline(&buffer, &n, stdin);

292

if(sret > 0){

253

ret = getline(&buffer, &n, stdin);

254

if(ret > 0){

293

255

status = EXIT_SUCCESS;

294

256

/* Make n = data size instead of allocated buffer size */

295

n = (size_t)sret;

257

n = (size_t)ret;

296

258

/* Strip final newline */

297

259

if(n > 0 and buffer[n-1] == '\n'){

298

260

buffer[n-1] = '\0'; /* not strictly necessary */

300

262

}

301

263

size_t written = 0;

302

264

while(written < n){

303

sret = write(STDOUT_FILENO, buffer + written, n - written);

304

if(sret < 0){

265

ret = write(STDOUT_FILENO, buffer + written, n - written);

266

if(ret < 0){

305

267

int e = errno;

306

error(0, errno, "write");

268

perror("write");

307

269

switch(e){

308

270

case EBADF:

309

271

case EFAULT:

320

282

}

321

283

break;

322

284

}

323

written += (size_t)sret;

285

written += (size_t)ret;

324

286

}

325

sret = close(STDOUT_FILENO);

326

if(sret == -1){

287

ret = close(STDOUT_FILENO);

288

if(ret == -1){

327

289

int e = errno;

328

error(0, errno, "close");

290

perror("close");

329

291

switch(e){

330

292

case EBADF:

331

293

status = EX_OSFILE;

338

300

}

339

301

break;

340

302

}

341

if(sret < 0){

303

if(ret < 0){

342

304

int e = errno;

343

305

if(errno != EINTR and not feof(stdin)){

344

error(0, errno, "getline");

306

perror("getline");

345

307

switch(e){

346

308

case EBADF:

347

309

status = EX_UNAVAILABLE;

354

316

break;

355

317

}

356

318

}

357

/* if(sret == 0), then the only sensible thing to do is to retry to

319

/* if(ret == 0), then the only sensible thing to do is to retry to

358

320

read from stdin */

359

321

fputc('\n', stderr);

360

322

if(debug and not quit_now){

370

332

fprintf(stderr, "Restoring terminal attributes\n");

371

333

}

372

334

if(tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_old) != 0){

373

error(0, errno, "tcsetattr+echo");

335

perror("tcsetattr+echo");

374

336

}

375

337

376

338

if(quit_now){

378

340

old_action.sa_handler = SIG_DFL;

379

341

ret = sigaction(signal_received, &old_action, NULL);

380

342

if(ret == -1){

381

error(0, errno, "sigaction");

343

perror("sigaction");

382

344

}

383

345

raise(signal_received);

384

346

}