OpenCoverage

ts_asn1.c

Absolute File Name:

/home/opencoverage/opencoverage/guest-scripts/libressl/src/crypto/ts/ts_asn1.c

Switch to Source code

Preprocessed file

Line Source Count

1 -

2 -

3 static const ASN1_TEMPLATE TS_MSG_IMPRINT_seq_tt[] = { -

4 { -

5 .flags = 0, -

6 .tag = 0, -

7 .offset = -

8 __builtin_offsetof ( -

9 TS_MSG_IMPRINT -

10 , -

11 hash_algo -

12 ) -

13 , -

14 .field_name = "hash_algo", -

15 .item = &X509_ALGOR_it, -

16 }, -

17 { -

18 .flags = 0, -

19 .tag = 0, -

20 .offset = -

21 __builtin_offsetof ( -

22 TS_MSG_IMPRINT -

23 , -

24 hashed_msg -

25 ) -

26 , -

27 .field_name = "hashed_msg", -

28 .item = &ASN1_OCTET_STRING_it, -

29 }, -

30 }; -

31 -

32 const ASN1_ITEM TS_MSG_IMPRINT_it = { -

33 .itype = 0x1, -

34 .utype = 16, -

35 .templates = TS_MSG_IMPRINT_seq_tt, -

36 .tcount = sizeof(TS_MSG_IMPRINT_seq_tt) / sizeof(ASN1_TEMPLATE), -

37 .funcs = -

38 ((void *)0) -

39 , -

40 .size = sizeof(TS_MSG_IMPRINT), -

41 .sname = "TS_MSG_IMPRINT", -

42 }; -

43 -

44 -

45 TS_MSG_IMPRINT * -

46 d2i_TS_MSG_IMPRINT(TS_MSG_IMPRINT **a, const unsigned char **in, long len) -

47 { -

return

never executed: return (TS_MSG_IMPRINT *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &TS_MSG_IMPRINT_it);

(TS_MSG_IMPRINT *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,

never executed: return (TS_MSG_IMPRINT *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &TS_MSG_IMPRINT_it);

&TS_MSG_IMPRINT_it);

never executed: return (TS_MSG_IMPRINT *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &TS_MSG_IMPRINT_it);

50 } -

51 -

52 int -

53 i2d_TS_MSG_IMPRINT(const TS_MSG_IMPRINT *a, unsigned char **out) -

54 { -

return

never executed: return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_MSG_IMPRINT_it);

ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_MSG_IMPRINT_it);

never executed: return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_MSG_IMPRINT_it);

56 } -

57 -

58 TS_MSG_IMPRINT * -

59 TS_MSG_IMPRINT_new(void) -

60 { -

return

never executed: return (TS_MSG_IMPRINT *)ASN1_item_new(&TS_MSG_IMPRINT_it);

(TS_MSG_IMPRINT *)ASN1_item_new(&TS_MSG_IMPRINT_it);

never executed: return (TS_MSG_IMPRINT *)ASN1_item_new(&TS_MSG_IMPRINT_it);

62 } -

63 -

64 void -

65 TS_MSG_IMPRINT_free(TS_MSG_IMPRINT *a) -

66 { -

67 ASN1_item_free((ASN1_VALUE *)a, &TS_MSG_IMPRINT_it); -

}

executed 1 time by 1 test: end of block

Executed by:

freenull

69 -

70 TS_MSG_IMPRINT * -

71 TS_MSG_IMPRINT_dup(TS_MSG_IMPRINT *x) -

72 { -

return

never executed: return ASN1_item_dup(&TS_MSG_IMPRINT_it, x);

ASN1_item_dup(&TS_MSG_IMPRINT_it, x);

never executed: return ASN1_item_dup(&TS_MSG_IMPRINT_it, x);

74 } -

75 -

76 -

77 TS_MSG_IMPRINT * -

78 d2i_TS_MSG_IMPRINT_bio(BIO *bp, TS_MSG_IMPRINT **a) -

79 { -

return

never executed: return ASN1_item_d2i_bio(&TS_MSG_IMPRINT_it, bp, a);

ASN1_item_d2i_bio(&TS_MSG_IMPRINT_it, bp, a);

never executed: return ASN1_item_d2i_bio(&TS_MSG_IMPRINT_it, bp, a);

81 } -

82 -

83 int -

84 i2d_TS_MSG_IMPRINT_bio(BIO *bp, TS_MSG_IMPRINT *a) -

85 { -

return

never executed: return ASN1_item_i2d_bio(&TS_MSG_IMPRINT_it, bp, a);

ASN1_item_i2d_bio(&TS_MSG_IMPRINT_it, bp, a);

never executed: return ASN1_item_i2d_bio(&TS_MSG_IMPRINT_it, bp, a);

87 } -

88 -

89 -

90 TS_MSG_IMPRINT * -

91 d2i_TS_MSG_IMPRINT_fp(FILE *fp, TS_MSG_IMPRINT **a) -

92 { -

return

never executed: return ASN1_item_d2i_fp(&TS_MSG_IMPRINT_it, fp, a);

ASN1_item_d2i_fp(&TS_MSG_IMPRINT_it, fp, a);

never executed: return ASN1_item_d2i_fp(&TS_MSG_IMPRINT_it, fp, a);

94 } -

95 -

96 int -

97 i2d_TS_MSG_IMPRINT_fp(FILE *fp, TS_MSG_IMPRINT *a) -

98 { -

return

never executed: return ASN1_item_i2d_fp(&TS_MSG_IMPRINT_it, fp, a);

ASN1_item_i2d_fp(&TS_MSG_IMPRINT_it, fp, a);

never executed: return ASN1_item_i2d_fp(&TS_MSG_IMPRINT_it, fp, a);

100 } -

101 -

102 static const ASN1_TEMPLATE TS_REQ_seq_tt[] = { -

103 { -

104 .flags = 0, -

105 .tag = 0, -

106 .offset = -

107 __builtin_offsetof ( -

108 TS_REQ -

109 , -

110 version -

111 ) -

112 , -

113 .field_name = "version", -

114 .item = &ASN1_INTEGER_it, -

115 }, -

116 { -

117 .flags = 0, -

118 .tag = 0, -

119 .offset = -

120 __builtin_offsetof ( -

121 TS_REQ -

122 , -

123 msg_imprint -

124 ) -

125 , -

126 .field_name = "msg_imprint", -

127 .item = &TS_MSG_IMPRINT_it, -

128 }, -

129 { -

130 .flags = (0x1), -

131 .tag = 0, -

132 .offset = -

133 __builtin_offsetof ( -

134 TS_REQ -

135 , -

136 policy_id -

137 ) -

138 , -

139 .field_name = "policy_id", -

140 .item = &ASN1_OBJECT_it, -

141 }, -

142 { -

143 .flags = (0x1), -

144 .tag = 0, -

145 .offset = -

146 __builtin_offsetof ( -

147 TS_REQ -

148 , -

149 nonce -

150 ) -

151 , -

152 .field_name = "nonce", -

153 .item = &ASN1_INTEGER_it, -

154 }, -

155 { -

156 .flags = (0x1), -

157 .tag = 0, -

158 .offset = -

159 __builtin_offsetof ( -

160 TS_REQ -

161 , -

162 cert_req -

163 ) -

164 , -

165 .field_name = "cert_req", -

166 .item = &ASN1_FBOOLEAN_it, -

167 }, -

168 { -

169 .flags = (0x1 << 3)|(0x2<<6) | (0x2 << 1) | (0x1), -

170 .tag = 0, -

171 .offset = -

172 __builtin_offsetof ( -

173 TS_REQ -

174 , -

175 extensions -

176 ) -

177 , -

178 .field_name = "extensions", -

179 .item = &X509_EXTENSION_it, -

180 }, -

181 }; -

182 -

183 const ASN1_ITEM TS_REQ_it = { -

184 .itype = 0x1, -

185 .utype = 16, -

186 .templates = TS_REQ_seq_tt, -

187 .tcount = sizeof(TS_REQ_seq_tt) / sizeof(ASN1_TEMPLATE), -

188 .funcs = -

189 ((void *)0) -

190 , -

191 .size = sizeof(TS_REQ), -

192 .sname = "TS_REQ", -

193 }; -

194 -

195 -

196 TS_REQ * -

197 d2i_TS_REQ(TS_REQ **a, const unsigned char **in, long len) -

198 { -

199

return

never executed: return (TS_REQ *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &TS_REQ_it);

(TS_REQ *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,

never executed: return (TS_REQ *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &TS_REQ_it);

200

&TS_REQ_it);

never executed: return (TS_REQ *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &TS_REQ_it);

201 } -

202 -

203 int -

204 i2d_TS_REQ(const TS_REQ *a, unsigned char **out) -

205 { -

206

return

never executed: return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_REQ_it);

ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_REQ_it);

never executed: return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_REQ_it);

207 } -

208 -

209 TS_REQ * -

210 TS_REQ_new(void) -

211 { -

212

return

never executed: return (TS_REQ *)ASN1_item_new(&TS_REQ_it);

(TS_REQ *)ASN1_item_new(&TS_REQ_it);

never executed: return (TS_REQ *)ASN1_item_new(&TS_REQ_it);

213 } -

214 -

215 void -

216 TS_REQ_free(TS_REQ *a) -

217 { -

218 ASN1_item_free((ASN1_VALUE *)a, &TS_REQ_it); -

219

}

executed 1 time by 1 test: end of block

Executed by:

freenull

220 -

221 TS_REQ * -

222 TS_REQ_dup(TS_REQ *x) -

223 { -

224

return

never executed: return ASN1_item_dup(&TS_REQ_it, x);

ASN1_item_dup(&TS_REQ_it, x);

never executed: return ASN1_item_dup(&TS_REQ_it, x);

225 } -

226 -

227 -

228 TS_REQ * -

229 d2i_TS_REQ_bio(BIO *bp, TS_REQ **a) -

230 { -

231

return

never executed: return ASN1_item_d2i_bio(&TS_REQ_it, bp, a);

ASN1_item_d2i_bio(&TS_REQ_it, bp, a);

never executed: return ASN1_item_d2i_bio(&TS_REQ_it, bp, a);

232 } -

233 -

234 int -

235 i2d_TS_REQ_bio(BIO *bp, TS_REQ *a) -

236 { -

237

return

never executed: return ASN1_item_i2d_bio(&TS_REQ_it, bp, a);

ASN1_item_i2d_bio(&TS_REQ_it, bp, a);

never executed: return ASN1_item_i2d_bio(&TS_REQ_it, bp, a);

238 } -

239 -

240 -

241 TS_REQ * -

242 d2i_TS_REQ_fp(FILE *fp, TS_REQ **a) -

243 { -

244

return

never executed: return ASN1_item_d2i_fp(&TS_REQ_it, fp, a);

ASN1_item_d2i_fp(&TS_REQ_it, fp, a);

never executed: return ASN1_item_d2i_fp(&TS_REQ_it, fp, a);

245 } -

246 -

247 int -

248 i2d_TS_REQ_fp(FILE *fp, TS_REQ *a) -

249 { -

250

return

never executed: return ASN1_item_i2d_fp(&TS_REQ_it, fp, a);

ASN1_item_i2d_fp(&TS_REQ_it, fp, a);

never executed: return ASN1_item_i2d_fp(&TS_REQ_it, fp, a);

251 } -

252 -

253 static const ASN1_TEMPLATE TS_ACCURACY_seq_tt[] = { -

254 { -

255 .flags = (0x1), -

256 .tag = 0, -

257 .offset = -

258 __builtin_offsetof ( -

259 TS_ACCURACY -

260 , -

261 seconds -

262 ) -

263 , -

264 .field_name = "seconds", -

265 .item = &ASN1_INTEGER_it, -

266 }, -

267 { -

268 .flags = (0x1 << 3)|(0x2<<6) | (0x1), -

269 .tag = 0, -

270 .offset = -

271 __builtin_offsetof ( -

272 TS_ACCURACY -

273 , -

274 millis -

275 ) -

276 , -

277 .field_name = "millis", -

278 .item = &ASN1_INTEGER_it, -

279 }, -

280 { -

281 .flags = (0x1 << 3)|(0x2<<6) | (0x1), -

282 .tag = 1, -

283 .offset = -

284 __builtin_offsetof ( -

285 TS_ACCURACY -

286 , -

287 micros -

288 ) -

289 , -

290 .field_name = "micros", -

291 .item = &ASN1_INTEGER_it, -

292 }, -

293 }; -

294 -

295 const ASN1_ITEM TS_ACCURACY_it = { -

296 .itype = 0x1, -

297 .utype = 16, -

298 .templates = TS_ACCURACY_seq_tt, -

299 .tcount = sizeof(TS_ACCURACY_seq_tt) / sizeof(ASN1_TEMPLATE), -

300 .funcs = -

301 ((void *)0) -

302 , -

303 .size = sizeof(TS_ACCURACY), -

304 .sname = "TS_ACCURACY", -

305 }; -

306 -

307 -

308 TS_ACCURACY * -

309 d2i_TS_ACCURACY(TS_ACCURACY **a, const unsigned char **in, long len) -

310 { -

311

return

never executed: return (TS_ACCURACY *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &TS_ACCURACY_it);

(TS_ACCURACY *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,

never executed: return (TS_ACCURACY *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &TS_ACCURACY_it);

312

&TS_ACCURACY_it);

never executed: return (TS_ACCURACY *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &TS_ACCURACY_it);

313 } -

314 -

315 int -

316 i2d_TS_ACCURACY(const TS_ACCURACY *a, unsigned char **out) -

317 { -

318

return

never executed: return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_ACCURACY_it);

ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_ACCURACY_it);

never executed: return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_ACCURACY_it);

319 } -

320 -

321 TS_ACCURACY * -

322 TS_ACCURACY_new(void) -

323 { -

324

return

never executed: return (TS_ACCURACY *)ASN1_item_new(&TS_ACCURACY_it);

(TS_ACCURACY *)ASN1_item_new(&TS_ACCURACY_it);

never executed: return (TS_ACCURACY *)ASN1_item_new(&TS_ACCURACY_it);

325 } -

326 -

327 void -

328 TS_ACCURACY_free(TS_ACCURACY *a) -

329 { -

330 ASN1_item_free((ASN1_VALUE *)a, &TS_ACCURACY_it); -

331

}

executed 1 time by 1 test: end of block

Executed by:

freenull

332 -

333 TS_ACCURACY * -

334 TS_ACCURACY_dup(TS_ACCURACY *x) -

335 { -

336

return

never executed: return ASN1_item_dup(&TS_ACCURACY_it, x);

ASN1_item_dup(&TS_ACCURACY_it, x);

never executed: return ASN1_item_dup(&TS_ACCURACY_it, x);

337 } -

338 -

339 static const ASN1_TEMPLATE TS_TST_INFO_seq_tt[] = { -

340 { -

341 .flags = 0, -

342 .tag = 0, -

343 .offset = -

344 __builtin_offsetof ( -

345 TS_TST_INFO -

346 , -

347 version -

348 ) -

349 , -

350 .field_name = "version", -

351 .item = &ASN1_INTEGER_it, -

352 }, -

353 { -

354 .flags = 0, -

355 .tag = 0, -

356 .offset = -

357 __builtin_offsetof ( -

358 TS_TST_INFO -

359 , -

360 policy_id -

361 ) -

362 , -

363 .field_name = "policy_id", -

364 .item = &ASN1_OBJECT_it, -

365 }, -

366 { -

367 .flags = 0, -

368 .tag = 0, -

369 .offset = -

370 __builtin_offsetof ( -

371 TS_TST_INFO -

372 , -

373 msg_imprint -

374 ) -

375 , -

376 .field_name = "msg_imprint", -

377 .item = &TS_MSG_IMPRINT_it, -

378 }, -

379 { -

380 .flags = 0, -

381 .tag = 0, -

382 .offset = -

383 __builtin_offsetof ( -

384 TS_TST_INFO -

385 , -

386 serial -

387 ) -

388 , -

389 .field_name = "serial", -

390 .item = &ASN1_INTEGER_it, -

391 }, -

392 { -

393 .flags = 0, -

394 .tag = 0, -

395 .offset = -

396 __builtin_offsetof ( -

397 TS_TST_INFO -

398 , -

399 time -

400 ) -

401 , -

402 .field_name = "time", -

403 .item = &ASN1_GENERALIZEDTIME_it, -

404 }, -

405 { -

406 .flags = (0x1), -

407 .tag = 0, -

408 .offset = -

409 __builtin_offsetof ( -

410 TS_TST_INFO -

411 , -

412 accuracy -

413 ) -

414 , -

415 .field_name = "accuracy", -

416 .item = &TS_ACCURACY_it, -

417 }, -

418 { -

419 .flags = (0x1), -

420 .tag = 0, -

421 .offset = -

422 __builtin_offsetof ( -

423 TS_TST_INFO -

424 , -

425 ordering -

426 ) -

427 , -

428 .field_name = "ordering", -

429 .item = &ASN1_FBOOLEAN_it, -

430 }, -

431 { -

432 .flags = (0x1), -

433 .tag = 0, -

434 .offset = -

435 __builtin_offsetof ( -

436 TS_TST_INFO -

437 , -

438 nonce -

439 ) -

440 , -

441 .field_name = "nonce", -

442 .item = &ASN1_INTEGER_it, -

443 }, -

444 { -

445 .flags = (0x2 << 3)|(0x2<<6) | (0x1), -

446 .tag = 0, -

447 .offset = -

448 __builtin_offsetof ( -

449 TS_TST_INFO -

450 , -

451 tsa -

452 ) -

453 , -

454 .field_name = "tsa", -

455 .item = &GENERAL_NAME_it, -

456 }, -

457 { -

458 .flags = (0x1 << 3)|(0x2<<6) | (0x2 << 1) | (0x1), -

459 .tag = 1, -

460 .offset = -

461 __builtin_offsetof ( -

462 TS_TST_INFO -

463 , -

464 extensions -

465 ) -

466 , -

467 .field_name = "extensions", -

468 .item = &X509_EXTENSION_it, -

469 }, -

470 }; -

471 -

472 const ASN1_ITEM TS_TST_INFO_it = { -

473 .itype = 0x1, -

474 .utype = 16, -

475 .templates = TS_TST_INFO_seq_tt, -

476 .tcount = sizeof(TS_TST_INFO_seq_tt) / sizeof(ASN1_TEMPLATE), -

477 .funcs = -

478 ((void *)0) -

479 , -

480 .size = sizeof(TS_TST_INFO), -

481 .sname = "TS_TST_INFO", -

482 }; -

483 -

484 -

485 TS_TST_INFO * -

486 d2i_TS_TST_INFO(TS_TST_INFO **a, const unsigned char **in, long len) -

487 { -

488

return

never executed: return (TS_TST_INFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &TS_TST_INFO_it);

(TS_TST_INFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,

never executed: return (TS_TST_INFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &TS_TST_INFO_it);

489

&TS_TST_INFO_it);

never executed: return (TS_TST_INFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &TS_TST_INFO_it);

490 } -

491 -

492 int -

493 i2d_TS_TST_INFO(const TS_TST_INFO *a, unsigned char **out) -

494 { -

495

return

never executed: return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_TST_INFO_it);

ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_TST_INFO_it);

never executed: return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_TST_INFO_it);

496 } -

497 -

498 TS_TST_INFO * -

499 TS_TST_INFO_new(void) -

500 { -

501

return

never executed: return (TS_TST_INFO *)ASN1_item_new(&TS_TST_INFO_it);

(TS_TST_INFO *)ASN1_item_new(&TS_TST_INFO_it);

never executed: return (TS_TST_INFO *)ASN1_item_new(&TS_TST_INFO_it);

502 } -

503 -

504 void -

505 TS_TST_INFO_free(TS_TST_INFO *a) -

506 { -

507 ASN1_item_free((ASN1_VALUE *)a, &TS_TST_INFO_it); -

508

}

executed 1 time by 1 test: end of block

Executed by:

freenull

509 -

510 TS_TST_INFO * -

511 TS_TST_INFO_dup(TS_TST_INFO *x) -

512 { -

513

return

never executed: return ASN1_item_dup(&TS_TST_INFO_it, x);

ASN1_item_dup(&TS_TST_INFO_it, x);

never executed: return ASN1_item_dup(&TS_TST_INFO_it, x);

514 } -

515 -

516 -

517 TS_TST_INFO * -

518 d2i_TS_TST_INFO_bio(BIO *bp, TS_TST_INFO **a) -

519 { -

520

return

never executed: return ASN1_item_d2i_bio(&TS_TST_INFO_it, bp, a);

ASN1_item_d2i_bio(&TS_TST_INFO_it, bp, a);

never executed: return ASN1_item_d2i_bio(&TS_TST_INFO_it, bp, a);

521 } -

522 -

523 int -

524 i2d_TS_TST_INFO_bio(BIO *bp, TS_TST_INFO *a) -

525 { -

526

return

never executed: return ASN1_item_i2d_bio(&TS_TST_INFO_it, bp, a);

ASN1_item_i2d_bio(&TS_TST_INFO_it, bp, a);

never executed: return ASN1_item_i2d_bio(&TS_TST_INFO_it, bp, a);

527 } -

528 -

529 -

530 TS_TST_INFO * -

531 d2i_TS_TST_INFO_fp(FILE *fp, TS_TST_INFO **a) -

532 { -

533

return

never executed: return ASN1_item_d2i_fp(&TS_TST_INFO_it, fp, a);

ASN1_item_d2i_fp(&TS_TST_INFO_it, fp, a);

never executed: return ASN1_item_d2i_fp(&TS_TST_INFO_it, fp, a);

534 } -

535 -

536 int -

537 i2d_TS_TST_INFO_fp(FILE *fp, TS_TST_INFO *a) -

538 { -

539

return

never executed: return ASN1_item_i2d_fp(&TS_TST_INFO_it, fp, a);

ASN1_item_i2d_fp(&TS_TST_INFO_it, fp, a);

never executed: return ASN1_item_i2d_fp(&TS_TST_INFO_it, fp, a);

540 } -

541 -

542 static const ASN1_TEMPLATE TS_STATUS_INFO_seq_tt[] = { -

543 { -

544 .flags = 0, -

545 .tag = 0, -

546 .offset = -

547 __builtin_offsetof ( -

548 TS_STATUS_INFO -

549 , -

550 status -

551 ) -

552 , -

553 .field_name = "status", -

554 .item = &ASN1_INTEGER_it, -

555 }, -

556 { -

557 .flags = (0x2 << 1) | (0x1), -

558 .tag = 0, -

559 .offset = -

560 __builtin_offsetof ( -

561 TS_STATUS_INFO -

562 , -

563 text -

564 ) -

565 , -

566 .field_name = "text", -

567 .item = &ASN1_UTF8STRING_it, -

568 }, -

569 { -

570 .flags = (0x1), -

571 .tag = 0, -

572 .offset = -

573 __builtin_offsetof ( -

574 TS_STATUS_INFO -

575 , -

576 failure_info -

577 ) -

578 , -

579 .field_name = "failure_info", -

580 .item = &ASN1_BIT_STRING_it, -

581 }, -

582 }; -

583 -

584 const ASN1_ITEM TS_STATUS_INFO_it = { -

585 .itype = 0x1, -

586 .utype = 16, -

587 .templates = TS_STATUS_INFO_seq_tt, -

588 .tcount = sizeof(TS_STATUS_INFO_seq_tt) / sizeof(ASN1_TEMPLATE), -

589 .funcs = -

590 ((void *)0) -

591 , -

592 .size = sizeof(TS_STATUS_INFO), -

593 .sname = "TS_STATUS_INFO", -

594 }; -

595 -

596 -

597 TS_STATUS_INFO * -

598 d2i_TS_STATUS_INFO(TS_STATUS_INFO **a, const unsigned char **in, long len) -

599 { -

600

return

never executed: return (TS_STATUS_INFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &TS_STATUS_INFO_it);

(TS_STATUS_INFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,

never executed: return (TS_STATUS_INFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &TS_STATUS_INFO_it);

601

&TS_STATUS_INFO_it);

never executed: return (TS_STATUS_INFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &TS_STATUS_INFO_it);

602 } -

603 -

604 int -

605 i2d_TS_STATUS_INFO(const TS_STATUS_INFO *a, unsigned char **out) -

606 { -

607

return

never executed: return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_STATUS_INFO_it);

ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_STATUS_INFO_it);

never executed: return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_STATUS_INFO_it);

608 } -

609 -

610 TS_STATUS_INFO * -

611 TS_STATUS_INFO_new(void) -

612 { -

613

return

never executed: return (TS_STATUS_INFO *)ASN1_item_new(&TS_STATUS_INFO_it);

(TS_STATUS_INFO *)ASN1_item_new(&TS_STATUS_INFO_it);

never executed: return (TS_STATUS_INFO *)ASN1_item_new(&TS_STATUS_INFO_it);

614 } -

615 -

616 void -

617 TS_STATUS_INFO_free(TS_STATUS_INFO *a) -

618 { -

619 ASN1_item_free((ASN1_VALUE *)a, &TS_STATUS_INFO_it); -

620

}

executed 1 time by 1 test: end of block

Executed by:

freenull

621 -

622 TS_STATUS_INFO * -

623 TS_STATUS_INFO_dup(TS_STATUS_INFO *x) -

624 { -

625

return

never executed: return ASN1_item_dup(&TS_STATUS_INFO_it, x);

ASN1_item_dup(&TS_STATUS_INFO_it, x);

never executed: return ASN1_item_dup(&TS_STATUS_INFO_it, x);

626 } -

627 -

628 static int -

629 ts_resp_set_tst_info(TS_RESP *a) -

630 { -

631 long status; -

632 -

633 status = ASN1_INTEGER_get(a->status_info->status); -

634 -

635

if (a->token

a->token	Description
TRUE	never evaluated
FALSE	never evaluated

) {

636

if (status != 0

status != 0	Description
TRUE	never evaluated
FALSE	never evaluated

&& status != 1

status != 1	Description
TRUE	never evaluated
FALSE	never evaluated

) {

637 ERR_put_error(47,(0xfff),(131),__FILE__,544); -

638

return

never executed: return 0;

639 } -

640

if (a->tst_info !=

a->tst_info != ((void *)0)	Description
TRUE	never evaluated
FALSE	never evaluated

641

((void *)0)

a->tst_info != ((void *)0)	Description
TRUE	never evaluated
FALSE	never evaluated

642 ) -

643

TS_TST_INFO_free(a->tst_info);

never executed: TS_TST_INFO_free(a->tst_info);

644 a->tst_info = PKCS7_to_TS_TST_INFO(a->token); -

645

if (!a->tst_info

!a->tst_info	Description
TRUE	never evaluated
FALSE	never evaluated

) {

646 ERR_put_error(47,(0xfff),(129),__FILE__,551); -

647

return

never executed: return 0;

648 } -

649

}

never executed: end of block

else if (status == 0

status == 0	Description
TRUE	never evaluated
FALSE	never evaluated

|| status == 1

status == 1	Description
TRUE	never evaluated
FALSE	never evaluated

) {

650 ERR_put_error(47,(0xfff),(130),__FILE__,555); -

651

return

never executed: return 0;

652 } -

653 -

654

return

never executed: return 1;

655 } -

656 -

657 static int -

658 ts_resp_cb(int op, ASN1_VALUE **pval, const ASN1_ITEM *it, void *exarg) -

659 { -

660 TS_RESP *ts_resp = (TS_RESP *)*pval; -

661 -

662

if (op == 1

op == 1	Description
TRUE	never evaluated
FALSE	never evaluated

) {

663 ts_resp->tst_info = -

664 ((void *)0) -

665 ; -

666

}

never executed: end of block

else if (op == 3

op == 3	Description
TRUE	never evaluated
FALSE	never evaluated

) {

667

if (ts_resp->tst_info !=

ts_resp->tst_i...!= ((void *)0)	Description
TRUE	never evaluated
FALSE	never evaluated

668

((void *)0)

ts_resp->tst_i...!= ((void *)0)	Description
TRUE	never evaluated
FALSE	never evaluated

669 ) -

670

TS_TST_INFO_free(ts_resp->tst_info);

never executed: TS_TST_INFO_free(ts_resp->tst_info);

671

}

never executed: end of block

else if (op == 5

op == 5	Description
TRUE	never evaluated
FALSE	never evaluated

) {

672

if (ts_resp_set_tst_info(ts_resp) == 0

ts_resp_set_ts...(ts_resp) == 0	Description
TRUE	never evaluated
FALSE	never evaluated

)

673

return

never executed: return 0;

674

}

never executed: end of block

675

return

never executed: return 1;

676 } -

677 -

678 static const ASN1_AUX TS_RESP_aux = { -

679 .app_data = -

680 ((void *)0) -

681 , -

682 .flags = 0, -

683 .ref_offset = 0, -

684 .ref_lock = 0, -

685 .asn1_cb = ts_resp_cb, -

686 .enc_offset = 0, -

687 }; -

688 static const ASN1_TEMPLATE TS_RESP_seq_tt[] = { -

689 { -

690 .flags = 0, -

691 .tag = 0, -

692 .offset = -

693 __builtin_offsetof ( -

694 TS_RESP -

695 , -

696 status_info -

697 ) -

698 , -

699 .field_name = "status_info", -

700 .item = &TS_STATUS_INFO_it, -

701 }, -

702 { -

703 .flags = (0x1), -

704 .tag = 0, -

705 .offset = -

706 __builtin_offsetof ( -

707 TS_RESP -

708 , -

709 token -

710 ) -

711 , -

712 .field_name = "token", -

713 .item = &PKCS7_it, -

714 }, -

715 }; -

716 -

717 const ASN1_ITEM TS_RESP_it = { -

718 .itype = 0x1, -

719 .utype = 16, -

720 .templates = TS_RESP_seq_tt, -

721 .tcount = sizeof(TS_RESP_seq_tt) / sizeof(ASN1_TEMPLATE), -

722 .funcs = &TS_RESP_aux, -

723 .size = sizeof(TS_RESP), -

724 .sname = "TS_RESP", -

725 }; -

726 -

727 -

728 TS_RESP * -

729 d2i_TS_RESP(TS_RESP **a, const unsigned char **in, long len) -

730 { -

731

return

never executed: return (TS_RESP *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &TS_RESP_it);

(TS_RESP *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,

never executed: return (TS_RESP *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &TS_RESP_it);

732

&TS_RESP_it);

never executed: return (TS_RESP *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &TS_RESP_it);

733 } -

734 -

735 int -

736 i2d_TS_RESP(const TS_RESP *a, unsigned char **out) -

737 { -

738

return

never executed: return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_RESP_it);

ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_RESP_it);

never executed: return ASN1_item_i2d((ASN1_VALUE *)a, out, &TS_RESP_it);

739 } -

740 -

741 TS_RESP * -

742 TS_RESP_new(void) -

743 { -

744

return

never executed: return (TS_RESP *)ASN1_item_new(&TS_RESP_it);

(TS_RESP *)ASN1_item_new(&TS_RESP_it);

never executed: return (TS_RESP *)ASN1_item_new(&TS_RESP_it);

745 } -

746 -

747 void -

748 TS_RESP_free(TS_RESP *a) -

749 { -

750 ASN1_item_free((ASN1_VALUE *)a, &TS_RESP_it); -

751

}

executed 1 time by 1 test: end of block

Executed by:

freenull

752 -

753 TS_RESP * -

754 TS_RESP_dup(TS_RESP *x) -

755 { -

756

return

never executed: return ASN1_item_dup(&TS_RESP_it, x);

ASN1_item_dup(&TS_RESP_it, x);

never executed: return ASN1_item_dup(&TS_RESP_it, x);

757 } -

758 -

759 -

760 TS_RESP * -

761 d2i_TS_RESP_bio(BIO *bp, TS_RESP **a) -

762 { -

763

return

never executed: return ASN1_item_d2i_bio(&TS_RESP_it, bp, a);

ASN1_item_d2i_bio(&TS_RESP_it, bp, a);

never executed: return ASN1_item_d2i_bio(&TS_RESP_it, bp, a);

764 } -

765 -

766 int -

767 i2d_TS_RESP_bio(BIO *bp, TS_RESP *a) -

768 { -

769

return

never executed: return ASN1_item_i2d_bio(&TS_RESP_it, bp, a);

ASN1_item_i2d_bio(&TS_RESP_it, bp, a);

never executed: return ASN1_item_i2d_bio(&TS_RESP_it, bp, a);

770 } -

771 -

772 -

773 TS_RESP * -

774 d2i_TS_RESP_fp(FILE *fp, TS_RESP **a) -

775 { -

776

return

never executed: return ASN1_item_d2i_fp(&TS_RESP_it, fp, a);

ASN1_item_d2i_fp(&TS_RESP_it, fp, a);

never executed: return ASN1_item_d2i_fp(&TS_RESP_it, fp, a);

777 } -

778 -

779 int -

780 i2d_TS_RESP_fp(FILE *fp, TS_RESP *a) -

781 { -

782

return

never executed: return ASN1_item_i2d_fp(&TS_RESP_it, fp, a);

ASN1_item_i2d_fp(&TS_RESP_it, fp, a);

never executed: return ASN1_item_i2d_fp(&TS_RESP_it, fp, a);

783 } -

784 -

785 static const ASN1_TEMPLATE ESS_ISSUER_SERIAL_seq_tt[] = { -

786 { -

787 .flags = (0x2 << 1), -

788 .tag = 0, -

789 .offset = -

790 __builtin_offsetof ( -

791 ESS_ISSUER_SERIAL -

792 , -

793 issuer -

794 ) -

795 , -

796 .field_name = "issuer", -

797 .item = &GENERAL_NAME_it, -

798 }, -

799 { -

800 .flags = 0, -

801 .tag = 0, -

802 .offset = -

803 __builtin_offsetof ( -

804 ESS_ISSUER_SERIAL -

805 , -

806 serial -

807 ) -

808 , -

809 .field_name = "serial", -

810 .item = &ASN1_INTEGER_it, -

811 }, -

812 }; -

813 -

814 const ASN1_ITEM ESS_ISSUER_SERIAL_it = { -

815 .itype = 0x1, -

816 .utype = 16, -

817 .templates = ESS_ISSUER_SERIAL_seq_tt, -

818 .tcount = sizeof(ESS_ISSUER_SERIAL_seq_tt) / sizeof(ASN1_TEMPLATE), -

819 .funcs = -

820 ((void *)0) -

821 , -

822 .size = sizeof(ESS_ISSUER_SERIAL), -

823 .sname = "ESS_ISSUER_SERIAL", -

824 }; -

825 -

826 -

827 ESS_ISSUER_SERIAL * -

828 d2i_ESS_ISSUER_SERIAL(ESS_ISSUER_SERIAL **a, const unsigned char **in, long len) -

829 { -

830

return

never executed: return (ESS_ISSUER_SERIAL *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &ESS_ISSUER_SERIAL_it);

(ESS_ISSUER_SERIAL *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,

never executed: return (ESS_ISSUER_SERIAL *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &ESS_ISSUER_SERIAL_it);

831

&ESS_ISSUER_SERIAL_it);

never executed: return (ESS_ISSUER_SERIAL *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &ESS_ISSUER_SERIAL_it);

832 } -

833 -

834 int -

835 i2d_ESS_ISSUER_SERIAL(const ESS_ISSUER_SERIAL *a, unsigned char **out) -

836 { -

837

return

never executed: return ASN1_item_i2d((ASN1_VALUE *)a, out, &ESS_ISSUER_SERIAL_it);

ASN1_item_i2d((ASN1_VALUE *)a, out, &ESS_ISSUER_SERIAL_it);

never executed: return ASN1_item_i2d((ASN1_VALUE *)a, out, &ESS_ISSUER_SERIAL_it);

838 } -

839 -

840 ESS_ISSUER_SERIAL * -

841 ESS_ISSUER_SERIAL_new(void) -

842 { -

843

return

never executed: return (ESS_ISSUER_SERIAL *)ASN1_item_new(&ESS_ISSUER_SERIAL_it);

(ESS_ISSUER_SERIAL *)ASN1_item_new(&ESS_ISSUER_SERIAL_it);

never executed: return (ESS_ISSUER_SERIAL *)ASN1_item_new(&ESS_ISSUER_SERIAL_it);

844 } -

845 -

846 void -

847 ESS_ISSUER_SERIAL_free(ESS_ISSUER_SERIAL *a) -

848 { -

849 ASN1_item_free((ASN1_VALUE *)a, &ESS_ISSUER_SERIAL_it); -

850

}

executed 1 time by 1 test: end of block

Executed by:

freenull

851 -

852 ESS_ISSUER_SERIAL * -

853 ESS_ISSUER_SERIAL_dup(ESS_ISSUER_SERIAL *x) -

854 { -

855

return

never executed: return ASN1_item_dup(&ESS_ISSUER_SERIAL_it, x);

ASN1_item_dup(&ESS_ISSUER_SERIAL_it, x);

never executed: return ASN1_item_dup(&ESS_ISSUER_SERIAL_it, x);

856 } -

857 -

858 static const ASN1_TEMPLATE ESS_CERT_ID_seq_tt[] = { -

859 { -

860 .flags = 0, -

861 .tag = 0, -

862 .offset = -

863 __builtin_offsetof ( -

864 ESS_CERT_ID -

865 , -

866 hash -

867 ) -

868 , -

869 .field_name = "hash", -

870 .item = &ASN1_OCTET_STRING_it, -

871 }, -

872 { -

873 .flags = (0x1), -

874 .tag = 0, -

875 .offset = -

876 __builtin_offsetof ( -

877 ESS_CERT_ID -

878 , -

879 issuer_serial -

880 ) -

881 , -

882 .field_name = "issuer_serial", -

883 .item = &ESS_ISSUER_SERIAL_it, -

884 }, -

885 }; -

886 -

887 const ASN1_ITEM ESS_CERT_ID_it = { -

888 .itype = 0x1, -

889 .utype = 16, -

890 .templates = ESS_CERT_ID_seq_tt, -

891 .tcount = sizeof(ESS_CERT_ID_seq_tt) / sizeof(ASN1_TEMPLATE), -

892 .funcs = -

893 ((void *)0) -

894 , -

895 .size = sizeof(ESS_CERT_ID), -

896 .sname = "ESS_CERT_ID", -

897 }; -

898 -

899 -

900 ESS_CERT_ID * -

901 d2i_ESS_CERT_ID(ESS_CERT_ID **a, const unsigned char **in, long len) -

902 { -

903

return

never executed: return (ESS_CERT_ID *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &ESS_CERT_ID_it);

(ESS_CERT_ID *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,

never executed: return (ESS_CERT_ID *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &ESS_CERT_ID_it);

904

&ESS_CERT_ID_it);

never executed: return (ESS_CERT_ID *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &ESS_CERT_ID_it);

905 } -

906 -

907 int -

908 i2d_ESS_CERT_ID(const ESS_CERT_ID *a, unsigned char **out) -

909 { -

910

return

never executed: return ASN1_item_i2d((ASN1_VALUE *)a, out, &ESS_CERT_ID_it);

ASN1_item_i2d((ASN1_VALUE *)a, out, &ESS_CERT_ID_it);

never executed: return ASN1_item_i2d((ASN1_VALUE *)a, out, &ESS_CERT_ID_it);

911 } -

912 -

913 ESS_CERT_ID * -

914 ESS_CERT_ID_new(void) -

915 { -

916

return

never executed: return (ESS_CERT_ID *)ASN1_item_new(&ESS_CERT_ID_it);

(ESS_CERT_ID *)ASN1_item_new(&ESS_CERT_ID_it);

never executed: return (ESS_CERT_ID *)ASN1_item_new(&ESS_CERT_ID_it);

917 } -

918 -

919 void -

920 ESS_CERT_ID_free(ESS_CERT_ID *a) -

921 { -

922 ASN1_item_free((ASN1_VALUE *)a, &ESS_CERT_ID_it); -

923

}

executed 1 time by 1 test: end of block

Executed by:

freenull

924 -

925 ESS_CERT_ID * -

926 ESS_CERT_ID_dup(ESS_CERT_ID *x) -

927 { -

928

return

never executed: return ASN1_item_dup(&ESS_CERT_ID_it, x);

ASN1_item_dup(&ESS_CERT_ID_it, x);

never executed: return ASN1_item_dup(&ESS_CERT_ID_it, x);

929 } -

930 -

931 static const ASN1_TEMPLATE ESS_SIGNING_CERT_seq_tt[] = { -

932 { -

933 .flags = (0x2 << 1), -

934 .tag = 0, -

935 .offset = -

936 __builtin_offsetof ( -

937 ESS_SIGNING_CERT -

938 , -

939 cert_ids -

940 ) -

941 , -

942 .field_name = "cert_ids", -

943 .item = &ESS_CERT_ID_it, -

944 }, -

945 { -

946 .flags = (0x2 << 1) | (0x1), -

947 .tag = 0, -

948 .offset = -

949 __builtin_offsetof ( -

950 ESS_SIGNING_CERT -

951 , -

952 policy_info -

953 ) -

954 , -

955 .field_name = "policy_info", -

956 .item = &POLICYINFO_it, -

957 }, -

958 }; -

959 -

960 const ASN1_ITEM ESS_SIGNING_CERT_it = { -

961 .itype = 0x1, -

962 .utype = 16, -

963 .templates = ESS_SIGNING_CERT_seq_tt, -

964 .tcount = sizeof(ESS_SIGNING_CERT_seq_tt) / sizeof(ASN1_TEMPLATE), -

965 .funcs = -

966 ((void *)0) -

967 , -

968 .size = sizeof(ESS_SIGNING_CERT), -

969 .sname = "ESS_SIGNING_CERT", -

970 }; -

971 -

972 -

973 ESS_SIGNING_CERT * -

974 d2i_ESS_SIGNING_CERT(ESS_SIGNING_CERT **a, const unsigned char **in, long len) -

975 { -

976

return

never executed: return (ESS_SIGNING_CERT *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &ESS_SIGNING_CERT_it);

(ESS_SIGNING_CERT *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,

never executed: return (ESS_SIGNING_CERT *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &ESS_SIGNING_CERT_it);

977

&ESS_SIGNING_CERT_it);

never executed: return (ESS_SIGNING_CERT *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, &ESS_SIGNING_CERT_it);

978 } -

979 -

980 int -

981 i2d_ESS_SIGNING_CERT(const ESS_SIGNING_CERT *a, unsigned char **out) -

982 { -

983

return

never executed: return ASN1_item_i2d((ASN1_VALUE *)a, out, &ESS_SIGNING_CERT_it);

ASN1_item_i2d((ASN1_VALUE *)a, out, &ESS_SIGNING_CERT_it);

never executed: return ASN1_item_i2d((ASN1_VALUE *)a, out, &ESS_SIGNING_CERT_it);

984 } -

985 -

986 ESS_SIGNING_CERT * -

987 ESS_SIGNING_CERT_new(void) -

988 { -

989

return

never executed: return (ESS_SIGNING_CERT *)ASN1_item_new(&ESS_SIGNING_CERT_it);

(ESS_SIGNING_CERT *)ASN1_item_new(&ESS_SIGNING_CERT_it);

never executed: return (ESS_SIGNING_CERT *)ASN1_item_new(&ESS_SIGNING_CERT_it);

990 } -

991 -

992 void -

993 ESS_SIGNING_CERT_free(ESS_SIGNING_CERT *a) -

994 { -

995 ASN1_item_free((ASN1_VALUE *)a, &ESS_SIGNING_CERT_it); -

996

}

executed 1 time by 1 test: end of block

Executed by:

freenull

997 -

998 ESS_SIGNING_CERT * -

999 ESS_SIGNING_CERT_dup(ESS_SIGNING_CERT *x) -

1000 { -

1001

return

never executed: return ASN1_item_dup(&ESS_SIGNING_CERT_it, x);

ASN1_item_dup(&ESS_SIGNING_CERT_it, x);

never executed: return ASN1_item_dup(&ESS_SIGNING_CERT_it, x);

1002 } -

1003 -

1004 -

1005 TS_TST_INFO * -

1006 PKCS7_to_TS_TST_INFO(PKCS7 *token) -

1007 { -

1008 PKCS7_SIGNED *pkcs7_signed; -

1009 PKCS7 *enveloped; -

1010 ASN1_TYPE *tst_info_wrapper; -

1011 ASN1_OCTET_STRING *tst_info_der; -

1012 const unsigned char *p; -

1013 -

1014

if (!(OBJ_obj2nid((token)->type) == 22)

!(OBJ_obj2nid(...->type) == 22)	Description
TRUE	never evaluated
FALSE	never evaluated

) {

1015 ERR_put_error(47,(0xfff),(132),__FILE__,860); -

1016

return

never executed: return ((void *)0) ;

1017

((void *)0)

never executed: return ((void *)0) ;

1018

;

never executed: return ((void *)0) ;

1019 } -

1020 -

1021 -

1022

if (PKCS7_ctrl(token,2,0,

PKCS7_ctrl(tok... ((void *)0) )	Description
TRUE	never evaluated
FALSE	never evaluated

1023

((void *)0)

PKCS7_ctrl(tok... ((void *)0) )	Description
TRUE	never evaluated
FALSE	never evaluated

1024

)

PKCS7_ctrl(tok... ((void *)0) )	Description
TRUE	never evaluated
FALSE	never evaluated

) {

1025 ERR_put_error(47,(0xfff),(134),__FILE__,866); -

1026

return

never executed: return ((void *)0) ;

1027

((void *)0)

never executed: return ((void *)0) ;

1028

;

never executed: return ((void *)0) ;

1029 } -

1030 -

1031 -

1032 pkcs7_signed = token->d.sign; -

1033 enveloped = pkcs7_signed->contents; -

1034

if (OBJ_obj2nid(enveloped->type) != 207

OBJ_obj2nid(en...->type) != 207	Description
TRUE	never evaluated
FALSE	never evaluated

) {

1035 ERR_put_error(47,(0xfff),(132),__FILE__,874); -

1036

return

never executed: return ((void *)0) ;

1037

((void *)0)

never executed: return ((void *)0) ;

1038

;

never executed: return ((void *)0) ;

1039 } -

1040 -

1041 -

1042 tst_info_wrapper = enveloped->d.other; -

1043

if (tst_info_wrapper->type != 4

tst_info_wrapper->type != 4	Description
TRUE	never evaluated
FALSE	never evaluated

) {

1044 ERR_put_error(47,(0xfff),(133),__FILE__,881); -

1045

return

never executed: return ((void *)0) ;

1046

((void *)0)

never executed: return ((void *)0) ;

1047

;

never executed: return ((void *)0) ;

1048 } -

1049 -

1050 -

1051 tst_info_der = tst_info_wrapper->value.octet_string; -

1052 -

1053 p = tst_info_der->data; -

1054

return

never executed: return d2i_TS_TST_INFO( ((void *)0) , &p, tst_info_der->length);

d2i_TS_TST_INFO(

never executed: return d2i_TS_TST_INFO( ((void *)0) , &p, tst_info_der->length);

1055

((void *)0)

never executed: return d2i_TS_TST_INFO( ((void *)0) , &p, tst_info_der->length);

1056

, &p, tst_info_der->length);

never executed: return d2i_TS_TST_INFO( ((void *)0) , &p, tst_info_der->length);

1057 } -

Switch to Source code

Preprocessed file

Generated by Squish Coco 4.2.2