Print this page
4853 illumos-gate is not lint-clean when built with openssl 1.0 (fix openssl 0.9.8 lint)
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/cmd/cmd-inet/usr.lib/wanboot/wanboot-cgi/wanboot-cgi.c
+++ new/usr/src/cmd/cmd-inet/usr.lib/wanboot/wanboot-cgi/wanboot-cgi.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21 /*
22 22 * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
23 23 * Copyright 2012 Milan Jurik. All rights reserved.
24 24 */
25 25
26 26 #include <stdio.h>
27 27 #include <stdlib.h>
28 28 #include <strings.h>
29 29 #include <string.h>
30 30 #include <libgen.h>
31 31 #include <unistd.h>
32 32 #include <fcntl.h>
33 33 #include <errno.h>
34 34 #include <netdb.h>
35 35 #include <libnvpair.h>
36 36 #include <sys/types.h>
37 37 #include <sys/wait.h>
38 38 #include <sys/stat.h>
39 39 #include <sys/param.h>
40 40 #include <sys/sysmacros.h>
41 41 #include <sys/mman.h>
42 42 #include <sys/socket.h>
43 43 #include <sys/utsname.h>
44 44 #include <sys/wanboot_impl.h>
45 45 #include <netinet/in.h>
46 46 #include <arpa/inet.h>
47 47
48 48 #include <openssl/crypto.h>
49 49 #include <openssl/x509.h>
50 50 #include <openssl/x509v3.h>
51 51 #include <openssl/pem.h>
52 52 #include <openssl/pkcs12.h>
53 53 #include <openssl/evp.h>
54 54 #include <openssl/err.h>
55 55
56 56 #include <p12aux.h>
57 57
58 58 #include <parseURL.h>
59 59 /*
60 60 * These can be replaced with wanbootutil.h once the openssl interfaces
61 61 * are moved to libwanboot.
62 62 */
63 63 #include <wanboot/key_util.h>
64 64 #include <wanboot/key_xdr.h>
65 65 #include <hmac_sha1.h>
66 66
67 67 #include <netboot_paths.h>
68 68 #include <wanboot_conf.h>
69 69
70 70 /*
71 71 * Exit status:
72 72 */
73 73 #define WBCGI_STATUS_OK 0
74 74 #define WBCGI_STATUS_ERR 1
75 75
76 76 #define WBCGI_FILE_EXISTS(file, statbuf) \
77 77 (stat(file, &statbuf) == 0 && S_ISREG(statbuf.st_mode))
78 78
79 79 #define WBCGI_DIR_EXISTS(dir, statbuf) \
80 80 (stat(dir, &statbuf) == 0 && S_ISDIR(statbuf.st_mode))
81 81
82 82 #define WBCGI_HMAC_PATH "/usr/lib/inet/wanboot/hmac"
83 83 #define WBCGI_ENCR_PATH "/usr/lib/inet/wanboot/encr"
84 84 #define WBCGI_KEYMGMT_PATH "/usr/lib/inet/wanboot/keymgmt"
85 85 #define WBCGI_MKISOFS_PATH "/bin/mkisofs"
86 86
87 87 #define WBCGI_DEV_URANDOM "/dev/urandom"
88 88
89 89 #define WBCGI_CONTENT_TYPE "Content-Type: "
90 90 #define WBCGI_CONTENT_LENGTH "Content-Length: "
91 91 #define WBCGI_WANBOOT_BNDTXT "WANBoot_Part_Boundary"
92 92 #define WBCGI_CRNL "\r\n"
93 93
94 94 #define WBCGI_CNSTR "CN="
95 95 #define WBCGI_CNSTR_LEN (sizeof (WBCGI_CNSTR) - 1)
96 96 #define WBCGI_NAMESEP ",/\n\r"
97 97
98 98 #define WBCGI_MAXBUF 256
99 99
100 100 /*
101 101 * Possible return values from netboot_ftw():
102 102 */
103 103 #define WBCGI_FTW_CBOK 2 /* CB terminated walk OK */
104 104 #define WBCGI_FTW_CBCONT 1 /* CB wants walk should continue */
105 105 #define WBCGI_FTW_DONE 0 /* Walk terminated without CBERR/CBOK */
106 106 #define WBCGI_FTW_CBERR -1 /* CB terminated walk with err */
107 107
108 108 /*
109 109 * getsubopt() is used to map one of the contents[] keywords
110 110 * to one of these types
111 111 */
112 112 #define WBCGI_CONTENT_ERROR -1
113 113 #define WBCGI_CONTENT_BOOTFILE 0
114 114 #define WBCGI_CONTENT_BOOTFS 1
115 115 #define WBCGI_CONTENT_ROOTFS 2
116 116
117 117 static char *contents[] =
118 118 { "bootfile", "bootfs", "rootfs", NULL };
119 119
120 120 /*
121 121 * getsubopt() is used to parse the query string for
122 122 * the keywords defined by queryopts[]
123 123 */
124 124 #define WBCGI_QUERYOPT_CONTENT 0
125 125 #define WBCGI_QUERYOPT_NET 1
126 126 #define WBCGI_QUERYOPT_CID 2
127 127 #define WBCGI_QUERYOPT_NONCE 3
128 128
129 129 static char *queryopts[] =
130 130 { "CONTENT", "IP", "CID", "NONCE", NULL };
131 131
132 132 static bc_handle_t bc_handle;
133 133
134 134
135 135 static char *
136 136 status_msg(int status)
137 137 {
138 138 char *msg;
139 139
140 140 switch (status) {
141 141 case 400:
142 142 msg = "Bad Request";
143 143 break;
144 144 case 403:
145 145 msg = "Forbidden";
146 146 break;
147 147 case 500:
148 148 msg = "Internal Server Error";
149 149 break;
150 150 default:
151 151 msg = "Unknown status";
152 152 break;
153 153 }
154 154
155 155 return (msg);
156 156 }
157 157
158 158 static void
159 159 print_status(int status, const char *spec_msg)
160 160 {
161 161 if (spec_msg == NULL) {
162 162 spec_msg = "";
163 163 }
164 164
165 165 (void) fprintf(stdout, "Status: %d %s %s%s", status,
166 166 status_msg(status), spec_msg, WBCGI_CRNL);
167 167 }
168 168
169 169 static char *
170 170 make_path(const char *root, const char *suffix)
171 171 {
172 172 char path[MAXPATHLEN];
173 173 char *ptr = NULL;
174 174 int chars;
175 175
176 176 if ((chars = snprintf(path, sizeof (path),
177 177 "%s/%s", root, suffix)) < 0 || chars > sizeof (path) ||
178 178 (ptr = strdup(path)) == NULL) {
179 179 print_status(500, "(error making path)");
180 180 }
181 181
182 182 return (ptr);
183 183 }
184 184
185 185 static void
186 186 free_path(char **pathp)
187 187 {
188 188 if (*pathp != NULL) {
189 189 free(*pathp);
190 190 *pathp = NULL;
191 191 }
192 192 }
193 193
194 194 static char *
195 195 gen_tmppath(const char *prefix, const char *net, const char *cid)
196 196 {
197 197 pid_t pid;
198 198 time_t secs;
199 199 int chars;
200 200 char path[MAXPATHLEN];
201 201 char *ptr = NULL;
202 202
203 203 if ((pid = getpid()) < 0 || (secs = time(NULL)) < 0 ||
204 204 (chars = snprintf(path, sizeof (path), "/tmp/%s_%s_%s_%ld_%ld",
205 205 prefix, net, cid, pid, secs)) < 0 || chars > sizeof (path) ||
206 206 (ptr = strdup(path)) == NULL) {
207 207 print_status(500, "(error creating temporary filename)");
208 208 }
209 209
210 210 return (ptr);
211 211 }
212 212
213 213 /*
214 214 * File I/O stuff:
215 215 */
216 216 static boolean_t
217 217 write_buffer(int fd, const void *buffer, size_t buflen)
218 218 {
219 219 size_t nwritten;
220 220 ssize_t nbytes;
221 221 const char *buf = buffer;
222 222
223 223 for (nwritten = 0; nwritten < buflen; nwritten += nbytes) {
224 224 nbytes = write(fd, &buf[nwritten], buflen - nwritten);
225 225 if (nbytes <= 0) {
226 226 return (B_FALSE);
227 227 }
228 228 }
229 229
230 230 return (B_TRUE);
231 231 }
232 232
233 233 static boolean_t
234 234 write_file(int ofd, const char *filename, size_t size)
235 235 {
236 236 boolean_t ret = B_TRUE;
237 237 int ifd;
238 238 char buf[1024];
239 239 size_t rlen;
240 240 ssize_t wlen;
241 241
242 242 if ((ifd = open(filename, O_RDONLY)) < 0) {
243 243 return (B_FALSE);
244 244 }
245 245
246 246 for (; size != 0; size -= wlen) {
247 247 rlen = (size < sizeof (buf)) ? size : sizeof (buf);
248 248
249 249 if ((wlen = read(ifd, buf, rlen)) < 0 ||
250 250 !write_buffer(ofd, buf, wlen)) {
251 251 ret = B_FALSE;
252 252 break;
253 253 }
254 254 }
255 255 (void) close(ifd);
256 256
257 257 return (ret);
258 258 }
259 259
260 260 static boolean_t
261 261 copy_file(const char *src, const char *dest)
262 262 {
263 263 boolean_t ret = B_FALSE;
264 264 char message[WBCGI_MAXBUF];
265 265 const size_t chunksize = 16 * PAGESIZE;
266 266 size_t validsize;
267 267 size_t nwritten = 0;
268 268 size_t nbytes = 0;
269 269 off_t roff;
270 270 int mflags = MAP_PRIVATE;
271 271 char *buf = NULL;
272 272 struct stat st;
273 273 int rfd = -1;
274 274 int wfd = -1;
275 275 int chars;
276 276
277 277 if ((rfd = open(src, O_RDONLY)) < 0 ||
278 278 (wfd = open(dest, O_CREAT|O_EXCL|O_RDWR, S_IRUSR|S_IWUSR)) < 0 ||
279 279 fstat(rfd, &st) == -1) {
280 280 goto cleanup;
281 281 }
282 282
283 283 for (nbytes = st.st_size, roff = 0; nwritten < nbytes;
284 284 nwritten += validsize, roff += validsize) {
285 285 buf = mmap(buf, chunksize, PROT_READ, mflags, rfd, roff);
286 286 if (buf == MAP_FAILED) {
287 287 goto cleanup;
288 288 }
289 289 mflags |= MAP_FIXED;
290 290
291 291 validsize = MIN(chunksize, nbytes - nwritten);
292 292 if (!write_buffer(wfd, buf, validsize)) {
293 293 (void) munmap(buf, chunksize);
294 294 goto cleanup;
295 295 }
296 296
297 297 }
298 298 if (buf != NULL) {
299 299 (void) munmap(buf, chunksize);
300 300 }
301 301
302 302 ret = B_TRUE;
303 303 cleanup:
304 304 if (ret == B_FALSE) {
305 305 if ((chars = snprintf(message, sizeof (message),
306 306 "error copying %s to %s", src, dest)) > 0 &&
307 307 chars <= sizeof (message)) {
308 308 print_status(500, message);
309 309 } else {
310 310 print_status(500, NULL);
311 311 }
312 312 }
313 313 if (rfd != -1) {
314 314 (void) close(rfd);
315 315 }
316 316 if (wfd != -1) {
317 317 (void) close(wfd);
318 318 }
319 319
320 320 return (ret);
321 321 }
322 322
323 323 static boolean_t
324 324 create_nonce(const char *noncepath, const char *nonce)
325 325 {
326 326 boolean_t ret = B_TRUE;
327 327 int fd;
328 328
329 329 if ((fd = open(noncepath,
330 330 O_WRONLY|O_CREAT|O_EXCL, S_IRUSR|S_IWUSR)) == -1 ||
331 331 !write_buffer(fd, nonce, strlen(nonce))) {
332 332 print_status(500, "(error creating nonce file)");
333 333 ret = B_FALSE;
334 334 }
335 335 if (fd != -1) {
336 336 (void) close(fd);
337 337 }
338 338
339 339 return (ret);
340 340 }
341 341
342 342 static boolean_t
343 343 create_timestamp(const char *timestamppath, const char *timestamp)
344 344 {
345 345 boolean_t ret = B_TRUE;
346 346 int fd;
347 347
348 348 if ((fd = open(timestamppath,
349 349 O_WRONLY|O_CREAT|O_EXCL, S_IRUSR|S_IWUSR)) == -1 ||
350 350 !write_buffer(fd, timestamp, strlen(timestamp))) {
351 351 print_status(500, "(error creating timestamp file)");
352 352 ret = B_FALSE;
353 353 }
354 354 if (fd != -1) {
355 355 (void) close(fd);
356 356 }
357 357
358 358 return (ret);
359 359 }
360 360
361 361 static boolean_t
362 362 create_urandom(const char *urandompath)
363 363 {
364 364 boolean_t ret = B_TRUE;
365 365 int fd;
366 366
367 367 if ((fd = open(urandompath,
368 368 O_WRONLY|O_CREAT|O_EXCL, S_IRUSR|S_IWUSR)) == -1 ||
369 369 !write_file(fd, WBCGI_DEV_URANDOM, 32 * 1024)) {
370 370 print_status(500, "(error creating urandom file)");
371 371 ret = B_FALSE;
372 372 }
373 373 if (fd != -1) {
374 374 (void) close(fd);
375 375 }
376 376
377 377 return (ret);
378 378 }
379 379
380 380 static boolean_t
381 381 create_null_hash(const char *hashpath)
382 382 {
383 383 boolean_t ret = B_TRUE;
384 384 int fd;
385 385 static char null_hash[HMAC_DIGEST_LEN];
386 386
387 387 if ((fd = open(hashpath,
388 388 O_WRONLY|O_CREAT|O_EXCL, S_IRUSR|S_IWUSR)) == -1 ||
389 389 !write_buffer(fd, null_hash, sizeof (null_hash))) {
390 390 print_status(500, "(error creating null hash)");
391 391 ret = B_FALSE;
392 392 }
393 393 if (fd != -1) {
394 394 (void) close(fd);
395 395 }
396 396
397 397 return (ret);
398 398 }
399 399
400 400
401 401 static char *
402 402 determine_doc_root(void)
403 403 {
404 404 char *doc_root;
405 405
406 406 /*
407 407 * If DOCUMENT_ROOT is valid, use that.
408 408 */
409 409 if ((doc_root = getenv("DOCUMENT_ROOT")) == NULL ||
410 410 strlen(doc_root) == 0) {
411 411 /*
412 412 * No DOCUMENT_ROOT - try PATH_TRANSLATED.
413 413 */
414 414 if ((doc_root = getenv("PATH_TRANSLATED")) == NULL ||
415 415 strlen(doc_root) == 0) {
416 416 /*
417 417 * Can't determine the document root.
418 418 */
419 419 return (NULL);
420 420 }
421 421 }
422 422
423 423 return (doc_root);
424 424 }
425 425
426 426 static boolean_t
427 427 get_request_info(int *contentp, char **netp, char **cidp, char **noncep,
428 428 char **docrootp)
429 429 {
430 430 char *method;
431 431 char *query_string;
432 432 char *value;
433 433 char *junk;
434 434 int i;
435 435
436 436 if ((method = getenv("REQUEST_METHOD")) == NULL ||
437 437 strncasecmp(method, "GET", strlen("GET") != 0)) {
438 438 print_status(403, "(GET method expected)");
439 439 return (B_FALSE);
440 440 }
441 441
442 442 if ((query_string = getenv("QUERY_STRING")) == NULL) {
443 443 print_status(400, "(empty query string)");
444 444 return (B_FALSE);
445 445 }
446 446
447 447 for (i = 0; i < strlen(query_string); i++) {
448 448 if (query_string[i] == '&') {
449 449 query_string[i] = ',';
450 450 }
451 451 }
452 452
453 453 *contentp = WBCGI_CONTENT_ERROR;
454 454 *netp = *cidp = *noncep = NULL;
455 455
456 456 if ((*docrootp = determine_doc_root()) == NULL) {
457 457 print_status(400, "(unable to determine document root)");
458 458 return (B_FALSE);
459 459 }
460 460
461 461 while (*query_string != '\0') {
462 462 switch (getsubopt(&query_string, queryopts, &value)) {
463 463 case WBCGI_QUERYOPT_CONTENT:
464 464 *contentp = getsubopt(&value, contents, &junk);
465 465 break;
466 466 case WBCGI_QUERYOPT_NET:
467 467 *netp = value;
468 468 break;
469 469 case WBCGI_QUERYOPT_CID:
470 470 *cidp = value;
471 471 break;
472 472 case WBCGI_QUERYOPT_NONCE:
473 473 *noncep = value;
474 474 break;
475 475 default:
476 476 print_status(400, "(illegal query string)");
477 477 return (B_FALSE);
478 478 }
479 479 }
480 480
481 481 switch (*contentp) {
482 482 default:
483 483 print_status(400, "(missing or illegal CONTENT)");
484 484 return (B_FALSE);
485 485
486 486 case WBCGI_CONTENT_BOOTFS:
487 487 if (*netp == NULL || *cidp == NULL || *noncep == NULL) {
488 488 print_status(400,
489 489 "(CONTENT, IP, CID and NONCE required)");
490 490 return (B_FALSE);
491 491 }
492 492 break;
493 493
494 494 case WBCGI_CONTENT_BOOTFILE:
495 495 case WBCGI_CONTENT_ROOTFS:
496 496 if (*netp == NULL || *cidp == NULL || *docrootp == NULL) {
497 497 print_status(400,
498 498 "(CONTENT, IP, CID and DOCUMENT_ROOT required)");
499 499 return (B_FALSE);
500 500 }
501 501 break;
502 502 }
503 503
504 504 return (B_TRUE);
505 505 }
506 506
507 507 static boolean_t
508 508 encrypt_payload(const char *payload, const char *encr_payload,
509 509 const char *keyfile, const char *encryption_type)
510 510 {
511 511 struct stat sbuf;
512 512 int chars;
513 513 char cmd[MAXPATHLEN];
514 514 FILE *fp;
515 515 int status;
516 516 char msg[WBCGI_MAXBUF];
517 517
518 518 if (!WBCGI_FILE_EXISTS(payload, sbuf)) {
519 519 print_status(500, "(encrypt_payload: missing payload)");
520 520 return (B_FALSE);
521 521 }
522 522
523 523 if ((chars = snprintf(cmd, sizeof (cmd),
524 524 "%s -o type=%s -k %s < %s > %s", WBCGI_ENCR_PATH,
525 525 encryption_type, keyfile, payload, encr_payload)) < 0 ||
526 526 chars > sizeof (cmd)) {
527 527 print_status(500, "(encrypt_payload: buffer overflow)");
528 528 return (B_FALSE);
529 529 }
530 530
531 531 if ((fp = popen(cmd, "w")) == NULL) {
532 532 print_status(500, "(encrypt_payload: missing/file error)");
533 533 return (B_FALSE);
534 534 }
535 535 if ((status = WEXITSTATUS(pclose(fp))) != 0) {
536 536 (void) snprintf(msg, sizeof (msg),
537 537 "(encrypt_payload: failed, status=%d)", status);
538 538 print_status(500, msg);
539 539 return (B_FALSE);
540 540 }
541 541
542 542 if (!WBCGI_FILE_EXISTS(encr_payload, sbuf)) {
543 543 print_status(500, "(encrypt_payload: bad encrypted file)");
544 544 return (B_FALSE);
545 545 }
546 546
547 547 return (B_TRUE);
548 548 }
549 549
550 550 static boolean_t
551 551 hash_payload(const char *payload, const char *payload_hash,
552 552 const char *keyfile)
553 553 {
554 554 struct stat sbuf;
555 555 int chars;
556 556 char cmd[MAXPATHLEN];
557 557 FILE *fp;
558 558 int status;
559 559 char msg[WBCGI_MAXBUF];
560 560
561 561 if (!WBCGI_FILE_EXISTS(payload, sbuf)) {
562 562 print_status(500, "(hash_payload: missing payload)");
563 563 return (B_FALSE);
564 564 }
565 565
566 566 if ((chars = snprintf(cmd, sizeof (cmd), "%s -i %s -k %s > %s",
567 567 WBCGI_HMAC_PATH, payload, keyfile, payload_hash)) < 0 ||
568 568 chars > sizeof (cmd)) {
569 569 print_status(500, "(hash_payload: buffer overflow)");
570 570 return (B_FALSE);
571 571 }
572 572
573 573 if ((fp = popen(cmd, "w")) == NULL) {
574 574 print_status(500, "(hash_payload: missing/file error)");
575 575 return (B_FALSE);
576 576 }
577 577 if ((status = WEXITSTATUS(pclose(fp))) != 0) {
578 578 (void) snprintf(msg, sizeof (msg),
579 579 "(hash_payload: failed, status=%d)", status);
580 580 print_status(500, msg);
581 581 return (B_FALSE);
582 582 }
583 583
584 584 if (!WBCGI_FILE_EXISTS(payload_hash, sbuf) ||
585 585 sbuf.st_size < HMAC_DIGEST_LEN) {
586 586 print_status(500, "(hash_payload: bad signature file)");
587 587 return (B_FALSE);
588 588 }
589 589
590 590 return (B_TRUE);
591 591 }
592 592
593 593 static boolean_t
594 594 extract_keystore(const char *path, const char *keystorepath)
595 595 {
596 596 struct stat sbuf;
597 597 int chars;
598 598 char cmd[MAXPATHLEN];
599 599 FILE *fp;
600 600 int status;
601 601 char msg[WBCGI_MAXBUF];
602 602
603 603 if (!WBCGI_FILE_EXISTS(path, sbuf)) {
604 604 print_status(500, "(extract_keystore: missing keystore)");
605 605 return (B_FALSE);
606 606 }
607 607
608 608 if ((chars = snprintf(cmd, sizeof (cmd),
609 609 "%s -x -f %s -s %s -o type=rsa",
610 610 WBCGI_KEYMGMT_PATH, keystorepath, path)) < 0 ||
611 611 chars > sizeof (cmd)) {
612 612 print_status(500, "(extract_keystore: buffer overflow)");
613 613 return (B_FALSE);
614 614 }
615 615
616 616 if ((fp = popen(cmd, "w")) == NULL) {
617 617 print_status(500, "(extract_keystore: missing/file error)");
618 618 return (B_FALSE);
619 619 }
620 620 if ((status = WEXITSTATUS(pclose(fp))) != 0) {
621 621 (void) snprintf(msg, sizeof (msg),
622 622 "(extract_keystore: failed, status=%d)", status);
623 623 print_status(500, msg);
624 624 return (B_FALSE);
625 625 }
626 626
627 627 if (!WBCGI_FILE_EXISTS(keystorepath, sbuf)) {
628 628 print_status(500, "(extract_keystore: failed to create)");
629 629 return (B_FALSE);
630 630 }
631 631
632 632 return (B_TRUE);
633 633 }
634 634
635 635 static boolean_t
636 636 mkisofs(const char *image_dir, const char *image)
637 637 {
638 638 struct stat sbuf;
639 639 int chars;
640 640 char cmd[MAXPATHLEN];
641 641 FILE *fp;
642 642 int status;
643 643 char msg[WBCGI_MAXBUF];
644 644
645 645 if (!WBCGI_DIR_EXISTS(image_dir, sbuf)) {
646 646 print_status(500, "(mksiofs: missing image_dir)");
647 647 return (B_FALSE);
648 648 }
649 649
650 650 if ((chars = snprintf(cmd, sizeof (cmd), "%s -quiet -o %s -r %s",
651 651 WBCGI_MKISOFS_PATH, image, image_dir)) < 0 ||
652 652 chars > sizeof (cmd)) {
653 653 print_status(500, "(mkisofs: buffer overflow)");
654 654 return (B_FALSE);
655 655 }
656 656
657 657 if ((fp = popen(cmd, "w")) == NULL) {
658 658 print_status(500, "(mkisofs: missing/file error)");
659 659 return (B_FALSE);
660 660 }
661 661 if ((status = WEXITSTATUS(pclose(fp))) != 0) {
662 662 (void) snprintf(msg, sizeof (msg),
663 663 "(mkisofs: failed, status=%d)", status);
664 664 print_status(500, msg);
665 665 return (B_FALSE);
666 666 }
667 667
668 668 if (!WBCGI_FILE_EXISTS(image, sbuf)) {
669 669 print_status(500, "(mksiofs: failed to create image)");
670 670 return (B_FALSE);
671 671 }
672 672
673 673 return (B_TRUE);
674 674 }
675 675
676 676 /*
677 677 * This function, when invoked with a file name, optional network and
678 678 * client ID strings, and callback function will search for the file
679 679 * in the following locations:
680 680 *
681 681 * NB_NETBOOT_ROOT/<network>/<client id>/<file>
682 682 * NB_NETBOOT_ROOT/<client id>/<file>
683 683 * NB_NETBOOT_ROOT/<network>/<file>
684 684 * NB_NETBOOT_ROOT/<file>
685 685 *
686 686 * The callback function is invoked each time the file is found until
687 687 * we have searched all of the above locations or the callback function
688 688 * returns a value other than WBCGI_FTW_CBCONT.
689 689 *
690 690 * Arguments:
691 691 * filename - Name of file to search for.
692 692 * net - Optional network number to include in search hierarchy.
693 693 * cid - Optional client ID to include in search hierarchy.
694 694 * cb - Callback function to be called when file is found.
695 695 * arg - Argument to be supplied to the callback funtion.
696 696 *
697 697 * Returns:
698 698 * WBCGI_FTW_DONE, WBCGI_FTW_CBOK or WBCGI_FTW_CBERR.
699 699 */
700 700 static int
701 701 netboot_ftw(const char *filename, const char *net, const char *cid,
702 702 int (*cb)(const char *, void *arg), void *arg)
703 703 {
704 704 char ckpath[4][MAXPATHLEN];
705 705 int ret;
706 706 struct stat buf;
707 707 int i = 0;
708 708
709 709 if (snprintf(ckpath[i++], MAXPATHLEN, "%s%s", NB_NETBOOT_ROOT, filename)
710 710 >= MAXPATHLEN)
711 711 return (WBCGI_FTW_CBERR);
712 712
713 713 if (net != NULL && snprintf(ckpath[i++], MAXPATHLEN, "%s%s/%s",
714 714 NB_NETBOOT_ROOT, net, filename) >= MAXPATHLEN)
715 715 return (WBCGI_FTW_CBERR);
716 716
717 717 if (cid != NULL) {
718 718 if (snprintf(ckpath[i++], MAXPATHLEN, "%s%s/%s",
719 719 NB_NETBOOT_ROOT, cid, filename) >= MAXPATHLEN)
720 720 return (WBCGI_FTW_CBERR);
721 721
722 722 if (net != NULL && snprintf(ckpath[i++], MAXPATHLEN,
723 723 "%s%s/%s/%s", NB_NETBOOT_ROOT, net, cid, filename) >=
724 724 MAXPATHLEN)
725 725 return (WBCGI_FTW_CBERR);
726 726 }
727 727
728 728 /*
729 729 * Loop through hierarchy and check for file existence.
730 730 */
731 731 while (i > 0) {
732 732 --i;
733 733 if (WBCGI_FILE_EXISTS(ckpath[i], buf)) {
734 734 if ((ret = cb(ckpath[i], arg)) != WBCGI_FTW_CBCONT)
735 735 return (ret);
736 736 }
737 737 }
738 738 return (WBCGI_FTW_DONE);
739 739 }
740 740
741 741 /*ARGSUSED*/
742 742 static int
743 743 noact_cb(const char *path, void *arg)
744 744 {
745 745 return (WBCGI_FTW_CBOK);
746 746 }
747 747
748 748 static int
749 749 set_pathname(const char *path, void *pathname)
750 750 {
751 751 *(char **)pathname = strdup((char *)path);
752 752 return (WBCGI_FTW_CBOK);
753 753 }
754 754
755 755 static int
756 756 create_keystore(const char *path, void *keystorepath)
757 757 {
758 758 if (!extract_keystore(path, (char *)keystorepath)) {
759 759 return (WBCGI_FTW_CBERR);
760 760 }
761 761 return (WBCGI_FTW_CBOK);
762 762 }
763 763
764 764 static int
765 765 copy_certstore(const char *path, void *certstorepath)
766 766 {
767 767 if (!copy_file(path, (char *)certstorepath)) {
768 768 return (WBCGI_FTW_CBERR);
769 769 }
770 770 return (WBCGI_FTW_CBOK);
771 771 }
772 772
773 773 /*
774 774 * Add the certs found in the trustfile found in path (a trust store) to
775 775 * the file found at bootfs_dir/truststore. If necessary, create the
776 776 * output file.
777 777 */
778 778 static int
779 779 build_trustfile(const char *path, void *truststorepath)
780 780 {
781 781 int ret = WBCGI_FTW_CBERR;
782 782 STACK_OF(X509) *i_anchors = NULL;
783 783 STACK_OF(X509) *o_anchors = NULL;
784 784 char message[WBCGI_MAXBUF];
785 785 PKCS12 *p12 = NULL;
786 786 FILE *rfp = NULL;
787 787 FILE *wfp = NULL;
788 788 struct stat i_st;
789 789 struct stat o_st;
790 790 X509 *x = NULL;
791 791 int errtype = 0;
792 792 int wfd = -1;
793 793 int chars;
794 794 int i;
795 795
796 796 if (!WBCGI_FILE_EXISTS(path, i_st)) {
797 797 goto cleanup;
798 798 }
799 799
800 800 if (WBCGI_FILE_EXISTS((char *)truststorepath, o_st)) {
801 801 /*
802 802 * If we are inadvertantly writing to the input file.
803 803 * return success.
804 804 * XXX Pete: how can this happen, and why success?
805 805 */
806 806 if (i_st.st_ino == o_st.st_ino) {
807 807 ret = WBCGI_FTW_CBCONT;
808 808 goto cleanup;
809 809 }
810 810 if ((wfp = fopen((char *)truststorepath, "r+")) == NULL) {
811 811 goto cleanup;
812 812 }
813 813 /*
814 814 * Read what's already there, so that new information
815 815 * can be added.
816 816 */
817 817 if ((p12 = d2i_PKCS12_fp(wfp, NULL)) == NULL) {
818 818 errtype = 1;
819 819 goto cleanup;
820 820 }
821 821 i = sunw_PKCS12_parse(p12, WANBOOT_PASSPHRASE, DO_NONE, NULL,
822 822 0, NULL, NULL, NULL, &o_anchors);
823 823 if (i <= 0) {
824 824 errtype = 1;
825 825 goto cleanup;
826 826 }
827 827
828 828 PKCS12_free(p12);
829 829 p12 = NULL;
830 830 } else {
831 831 if (errno != ENOENT) {
832 832 chars = snprintf(message, sizeof (message),
833 833 "(error accessing file %s, error %s)",
834 834 path, strerror(errno));
835 835 if (chars > 0 && chars < sizeof (message))
836 836 print_status(500, message);
837 837 else
838 838 print_status(500, NULL);
839 839 return (WBCGI_FTW_CBERR);
840 840 }
841 841
842 842 /*
843 843 * Note: We could copy the file to the new trustfile, but
844 844 * we can't verify the password that way. Therefore, copy
845 845 * it by reading it.
846 846 */
847 847 if ((wfd = open((char *)truststorepath,
848 848 O_CREAT|O_EXCL|O_RDWR, 0700)) < 0) {
849 849 goto cleanup;
850 850 }
851 851 if ((wfp = fdopen(wfd, "w+")) == NULL) {
852 852 goto cleanup;
853 853 }
854 854 o_anchors = sk_X509_new_null();
855 855 if (o_anchors == NULL) {
856 856 goto cleanup;
857 857 }
858 858 }
859 859
860 860 if ((rfp = fopen(path, "r")) == NULL) {
861 861 goto cleanup;
862 862 }
863 863 if ((p12 = d2i_PKCS12_fp(rfp, NULL)) == NULL) {
864 864 errtype = 1;
865 865 goto cleanup;
866 866 }
867 867 i = sunw_PKCS12_parse(p12, WANBOOT_PASSPHRASE, DO_NONE, NULL, 0, NULL,
868 868 NULL, NULL, &i_anchors);
869 869 if (i <= 0) {
|
↓ open down ↓ |
869 lines elided |
↑ open up ↑ |
870 870 errtype = 1;
871 871 goto cleanup;
872 872 }
873 873 PKCS12_free(p12);
874 874 p12 = NULL;
875 875
876 876 /*
877 877 * Merge the two stacks of pkcs12 certs.
878 878 */
879 879 for (i = 0; i < sk_X509_num(i_anchors); i++) {
880 + /* LINTED */
880 881 x = sk_X509_delete(i_anchors, i);
881 882 (void) sk_X509_push(o_anchors, x);
882 883 }
883 884
884 885 /*
885 886 * Create the pkcs12 structure from the modified input stack and
886 887 * then write out that structure.
887 888 */
888 889 p12 = sunw_PKCS12_create((const char *)WANBOOT_PASSPHRASE, NULL, NULL,
889 890 o_anchors);
890 891 if (p12 == NULL) {
891 892 goto cleanup;
892 893 }
893 894 rewind(wfp);
894 895 if (i2d_PKCS12_fp(wfp, p12) == 0) {
895 896 goto cleanup;
896 897 }
897 898
898 899 ret = WBCGI_FTW_CBCONT;
899 900 cleanup:
900 901 if (ret == WBCGI_FTW_CBERR) {
901 902 if (errtype == 1) {
902 903 chars = snprintf(message, sizeof (message),
903 904 "(internal PKCS12 error while copying %s to %s)",
904 905 path, (char *)truststorepath);
905 906 } else {
906 907 chars = snprintf(message, sizeof (message),
907 908 "(error copying %s to %s)",
908 909 path, (char *)truststorepath);
909 910 }
910 911 if (chars > 0 && chars <= sizeof (message)) {
911 912 print_status(500, message);
912 913 } else {
913 914 print_status(500, NULL);
914 915 }
915 916 }
916 917 if (rfp != NULL) {
917 918 (void) fclose(rfp);
918 919 }
919 920 if (wfp != NULL) {
920 921 /* Will also close wfd */
921 922 (void) fclose(wfp);
922 923 }
923 924 if (p12 != NULL) {
924 925 PKCS12_free(p12);
925 926 }
926 927 if (i_anchors != NULL) {
927 928 sk_X509_pop_free(i_anchors, X509_free);
928 929 }
929 930 if (o_anchors != NULL) {
930 931 sk_X509_pop_free(o_anchors, X509_free);
931 932 }
932 933
933 934 return (ret);
934 935 }
935 936
936 937 static boolean_t
937 938 check_key_type(const char *keyfile, const char *keytype, int flag)
938 939 {
939 940 boolean_t ret = B_FALSE;
940 941 FILE *key_fp = NULL;
941 942 wbku_key_attr_t ka;
942 943
943 944 /*
944 945 * Map keytype into the ka structure
945 946 */
946 947 if (wbku_str_to_keyattr(keytype, &ka, flag) != WBKU_SUCCESS) {
947 948 goto cleanup;
948 949 }
949 950
950 951 /*
951 952 * Open the key file for reading.
952 953 */
953 954 if ((key_fp = fopen(keyfile, "r")) == NULL) {
954 955 goto cleanup;
955 956 }
956 957
957 958 /*
958 959 * Find the valid client key, if it exists.
959 960 */
960 961 if (wbku_find_key(key_fp, NULL, &ka, NULL, B_FALSE) != WBKU_SUCCESS) {
961 962 goto cleanup;
962 963 }
963 964
964 965 ret = B_TRUE;
965 966 cleanup:
966 967 if (key_fp != NULL) {
967 968 (void) fclose(key_fp);
968 969 }
969 970
970 971 return (ret);
971 972 }
972 973
973 974 static boolean_t
974 975 resolve_hostname(const char *hostname, nvlist_t *nvl, boolean_t may_be_crap)
975 976 {
976 977 struct sockaddr_in sin;
977 978 struct hostent *hp;
978 979 struct utsname un;
979 980 static char myname[SYS_NMLN] = { '\0' };
980 981 char *cp = NULL;
981 982 char msg[WBCGI_MAXBUF];
982 983
983 984 /*
984 985 * Initialize cached nodename
985 986 */
986 987 if (strlen(myname) == 0) {
987 988 if (uname(&un) == -1) {
988 989 (void) snprintf(msg, sizeof (msg),
989 990 "(unable to retrieve uname, errno %d)", errno);
990 991 print_status(500, msg);
991 992 return (B_FALSE);
992 993 }
993 994 (void) strcpy(myname, un.nodename);
994 995 }
995 996
996 997 /*
997 998 * If hostname is local node name, return the address this
998 999 * request came in on, which is supplied as SERVER_ADDR in the
999 1000 * cgi environment. This ensures we don't send back a possible
1000 1001 * alternate address that may be unreachable from the client's
1001 1002 * network. Otherwise, just resolve with nameservice.
1002 1003 */
1003 1004 if ((strcmp(hostname, myname) != 0) ||
1004 1005 ((cp = getenv("SERVER_ADDR")) == NULL)) {
1005 1006 if (((hp = gethostbyname(hostname)) == NULL) ||
1006 1007 (hp->h_addrtype != AF_INET) ||
1007 1008 (hp->h_length != sizeof (struct in_addr))) {
1008 1009 if (!may_be_crap) {
1009 1010 print_status(500, "(error resolving hostname)");
1010 1011 }
1011 1012 return (may_be_crap);
1012 1013 }
1013 1014 (void) memcpy(&sin.sin_addr, hp->h_addr, hp->h_length);
1014 1015 cp = inet_ntoa(sin.sin_addr);
1015 1016 }
1016 1017
1017 1018 if (nvlist_add_string(nvl, (char *)hostname, cp) != 0) {
1018 1019 print_status(500, "(error adding hostname to nvlist)");
1019 1020 return (B_FALSE);
1020 1021 }
1021 1022
1022 1023 return (B_TRUE);
1023 1024 }
1024 1025
1025 1026 /*
1026 1027 * one_name() is called for each certificate found and is passed the string
1027 1028 * that X509_NAME_oneline() returns. Its job is to find the common name and
1028 1029 * determine whether it is a host name; if it is then a line suitable for
1029 1030 * inclusion in /etc/inet/hosts is written to that file.
1030 1031 */
1031 1032 static boolean_t
1032 1033 one_name(const char *namestr, nvlist_t *nvl)
1033 1034 {
1034 1035 boolean_t ret = B_TRUE;
1035 1036 char *p;
1036 1037 char *q;
1037 1038 char c;
1038 1039
1039 1040 if (namestr != NULL &&
1040 1041 (p = strstr(namestr, WBCGI_CNSTR)) != NULL) {
1041 1042 p += WBCGI_CNSTR_LEN;
1042 1043
1043 1044 if ((q = strpbrk(p, WBCGI_NAMESEP)) != NULL) {
1044 1045 c = *q;
1045 1046 *q = '\0';
1046 1047 ret = resolve_hostname(p, nvl, B_TRUE);
1047 1048 *q = c;
1048 1049 } else {
1049 1050 ret = resolve_hostname(p, nvl, B_TRUE);
1050 1051 }
1051 1052 }
1052 1053
1053 1054 return (ret);
1054 1055 }
1055 1056
1056 1057 /*
1057 1058 * Loop through the certificates in a file
1058 1059 */
1059 1060 static int
1060 1061 get_hostnames(const char *path, void *nvl)
1061 1062 {
1062 1063 int ret = WBCGI_FTW_CBERR;
1063 1064 STACK_OF(X509) *certs = NULL;
1064 1065 PKCS12 *p12 = NULL;
1065 1066 char message[WBCGI_MAXBUF];
1066 1067 char buf[WBCGI_MAXBUF + 1];
1067 1068 FILE *rfp = NULL;
1068 1069 X509 *x = NULL;
1069 1070 int errtype = 0;
1070 1071 int chars;
1071 1072 int i;
1072 1073
1073 1074 if ((rfp = fopen(path, "r")) == NULL) {
1074 1075 goto cleanup;
1075 1076 }
1076 1077
1077 1078 if ((p12 = d2i_PKCS12_fp(rfp, NULL)) == NULL) {
1078 1079 errtype = 1;
1079 1080 goto cleanup;
1080 1081 }
1081 1082 i = sunw_PKCS12_parse(p12, WANBOOT_PASSPHRASE, DO_NONE, NULL, 0, NULL,
|
↓ open down ↓ |
192 lines elided |
↑ open up ↑ |
1082 1083 NULL, NULL, &certs);
1083 1084 if (i <= 0) {
1084 1085 errtype = 1;
1085 1086 goto cleanup;
1086 1087 }
1087 1088
1088 1089 PKCS12_free(p12);
1089 1090 p12 = NULL;
1090 1091
1091 1092 for (i = 0; i < sk_X509_num(certs); i++) {
1093 + /* LINTED */
1092 1094 x = sk_X509_value(certs, i);
1093 1095 if (!one_name(sunw_issuer_attrs(x, buf, sizeof (buf) - 1),
1094 1096 nvl)) {
1095 1097 goto cleanup;
1096 1098 }
1097 1099 }
1098 1100
1099 1101 ret = WBCGI_FTW_CBCONT;
1100 1102 cleanup:
1101 1103 if (ret == WBCGI_FTW_CBERR) {
1102 1104 if (errtype == 1) {
1103 1105 chars = snprintf(message, sizeof (message),
1104 1106 "(internal PKCS12 error reading %s)", path);
1105 1107 } else {
1106 1108 chars = snprintf(message, sizeof (message),
1107 1109 "error reading %s", path);
1108 1110 }
1109 1111 if (chars > 0 && chars <= sizeof (message)) {
1110 1112 print_status(500, message);
1111 1113 } else {
1112 1114 print_status(500, NULL);
1113 1115 }
1114 1116 }
1115 1117 if (rfp != NULL) {
1116 1118 (void) fclose(rfp);
1117 1119 }
1118 1120 if (p12 != NULL) {
1119 1121 PKCS12_free(p12);
1120 1122 }
1121 1123 if (certs != NULL) {
1122 1124 sk_X509_pop_free(certs, X509_free);
1123 1125 }
1124 1126
1125 1127 return (ret);
1126 1128 }
1127 1129
1128 1130 /*
1129 1131 * Create a hosts file by extracting hosts from client and truststore
1130 1132 * files. Use the CN. Then we should copy that file to the inet dir.
1131 1133 */
1132 1134 static boolean_t
1133 1135 create_hostsfile(const char *hostsfile, const char *net, const char *cid)
1134 1136 {
1135 1137 boolean_t ret = B_FALSE;
1136 1138 nvlist_t *nvl;
1137 1139 nvpair_t *nvp;
1138 1140 FILE *hostfp = NULL;
1139 1141 int hostfd = -1;
1140 1142 int i;
1141 1143 char *hostslist;
1142 1144 const char *bc_urls[] = { BC_ROOT_SERVER, BC_BOOT_LOGGER, NULL };
1143 1145
1144 1146 /*
1145 1147 * Allocate nvlist handle to store our hostname/IP pairs.
1146 1148 */
1147 1149 if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0) {
1148 1150 print_status(500, "(error allocating hostname nvlist)");
1149 1151 goto cleanup;
1150 1152 }
1151 1153
1152 1154 /*
1153 1155 * Extract and resolve hostnames from CNs.
1154 1156 */
1155 1157 if (netboot_ftw(NB_CLIENT_CERT, net, cid,
1156 1158 get_hostnames, nvl) == WBCGI_FTW_CBERR ||
1157 1159 netboot_ftw(NB_CA_CERT, net, cid,
1158 1160 get_hostnames, nvl) == WBCGI_FTW_CBERR) {
1159 1161 goto cleanup;
1160 1162 }
1161 1163
1162 1164 /*
1163 1165 * Extract and resolve hostnames from any URLs in bootconf.
1164 1166 */
1165 1167 for (i = 0; bc_urls[i] != NULL; ++i) {
1166 1168 char *urlstr;
1167 1169 url_t url;
1168 1170
1169 1171 if ((urlstr = bootconf_get(&bc_handle, bc_urls[i])) != NULL &&
1170 1172 url_parse(urlstr, &url) == URL_PARSE_SUCCESS) {
1171 1173 if (!resolve_hostname(url.hport.hostname,
1172 1174 nvl, B_FALSE)) {
1173 1175 goto cleanup;
1174 1176 }
1175 1177 }
1176 1178 }
1177 1179
1178 1180 /*
1179 1181 * If there is a resolve-hosts list in bootconf, resolve those
1180 1182 * hostnames too.
1181 1183 */
1182 1184 if ((hostslist = bootconf_get(&bc_handle, BC_RESOLVE_HOSTS)) != NULL) {
1183 1185 char *hostname;
1184 1186
1185 1187 for (hostname = strtok(hostslist, ","); hostname != NULL;
1186 1188 hostname = strtok(NULL, ",")) {
1187 1189 if (!resolve_hostname(hostname, nvl, B_FALSE)) {
1188 1190 goto cleanup;
1189 1191 }
1190 1192 }
1191 1193 }
1192 1194
1193 1195 /*
1194 1196 * Now write the hostname/IP pairs gathered to the hosts file.
1195 1197 */
1196 1198 if ((hostfd = open(hostsfile,
1197 1199 O_RDWR|O_CREAT|O_EXCL, S_IRUSR|S_IWUSR)) == -1 ||
1198 1200 (hostfp = fdopen(hostfd, "w+")) == NULL) {
1199 1201 print_status(500, "(error creating hosts file)");
1200 1202 goto cleanup;
1201 1203 }
1202 1204 for (nvp = nvlist_next_nvpair(nvl, NULL); nvp != NULL;
1203 1205 nvp = nvlist_next_nvpair(nvl, nvp)) {
1204 1206 char *hostname;
1205 1207 char *ipstr;
1206 1208
1207 1209 hostname = nvpair_name(nvp);
1208 1210 if (nvpair_value_string(nvp, &ipstr) != 0) {
1209 1211 print_status(500, "(nvl error writing hosts file)");
1210 1212 goto cleanup;
1211 1213 }
1212 1214
1213 1215 if (fprintf(hostfp, "%s\t%s\n", ipstr, hostname) < 0) {
1214 1216 print_status(500, "(error writing hosts file)");
1215 1217 goto cleanup;
1216 1218 }
1217 1219 }
1218 1220
1219 1221 ret = B_TRUE;
1220 1222 cleanup:
1221 1223 if (nvl != NULL) {
1222 1224 nvlist_free(nvl);
1223 1225 }
1224 1226 if (hostfp != NULL) {
1225 1227 /*
1226 1228 * hostfd is automatically closed as well.
1227 1229 */
1228 1230 (void) fclose(hostfp);
1229 1231 }
1230 1232
1231 1233 return (ret);
1232 1234 }
1233 1235
1234 1236 static boolean_t
1235 1237 bootfile_payload(const char *docroot, char **bootpathp)
1236 1238 {
1237 1239 boolean_t ret = B_FALSE;
1238 1240 char *boot_file;
1239 1241 struct stat sbuf;
1240 1242
1241 1243 if ((boot_file = bootconf_get(&bc_handle, BC_BOOT_FILE)) == NULL) {
1242 1244 print_status(500, "(boot_file must be specified)");
1243 1245 goto cleanup;
1244 1246 }
1245 1247 if ((*bootpathp = make_path(docroot, boot_file)) == NULL) {
1246 1248 goto cleanup;
1247 1249 }
1248 1250 if (!WBCGI_FILE_EXISTS(*bootpathp, sbuf)) {
1249 1251 print_status(500, "(boot_file missing)");
1250 1252 goto cleanup;
1251 1253 }
1252 1254
1253 1255 ret = B_TRUE;
1254 1256 cleanup:
1255 1257 return (ret);
1256 1258 }
1257 1259
1258 1260 /*
1259 1261 * Create the wanboot file system whose contents are determined by the
1260 1262 * security configuration specified in bootconf.
1261 1263 */
1262 1264 static boolean_t
1263 1265 wanbootfs_payload(const char *net, const char *cid, const char *nonce,
1264 1266 const char *bootconf, char **wanbootfs_imagep)
1265 1267 {
1266 1268 int ret = B_FALSE;
1267 1269
1268 1270 char *server_authentication;
1269 1271 char *client_authentication;
1270 1272 char *scf;
1271 1273
1272 1274 char *bootfs_dir = NULL;
1273 1275 char *bootfs_etc_dir = NULL;
1274 1276 char *bootfs_etc_inet_dir = NULL;
1275 1277 char *bootfs_dev_dir = NULL;
1276 1278
1277 1279 char *systemconf = NULL;
1278 1280 char *keystorepath = NULL;
1279 1281 char *certstorepath = NULL;
1280 1282 char *truststorepath = NULL;
1281 1283 char *bootconfpath = NULL;
1282 1284 char *systemconfpath = NULL;
1283 1285 char *urandompath = NULL;
1284 1286 char *noncepath = NULL;
1285 1287 char *hostspath = NULL;
1286 1288 char *etc_hostspath = NULL;
1287 1289 char *timestamppath = NULL;
1288 1290
1289 1291 boolean_t authenticate_client;
1290 1292 boolean_t authenticate_server;
1291 1293
1292 1294 struct stat sbuf;
1293 1295
1294 1296 /*
1295 1297 * Initialize SSL stuff.
1296 1298 */
1297 1299 sunw_crypto_init();
1298 1300
1299 1301 /*
1300 1302 * Get the security strategy values.
1301 1303 */
1302 1304 client_authentication = bootconf_get(&bc_handle,
1303 1305 BC_CLIENT_AUTHENTICATION);
1304 1306 authenticate_client = (client_authentication != NULL &&
1305 1307 strcmp(client_authentication, "yes") == 0);
1306 1308 server_authentication = bootconf_get(&bc_handle,
1307 1309 BC_SERVER_AUTHENTICATION);
1308 1310 authenticate_server = (server_authentication != NULL &&
1309 1311 strcmp(server_authentication, "yes") == 0);
1310 1312
1311 1313 /*
1312 1314 * Make a temporary directory structure for the wanboot file system.
1313 1315 */
1314 1316 if ((bootfs_dir = gen_tmppath("bootfs_dir", net, cid)) == NULL ||
1315 1317 (bootfs_etc_dir = make_path(bootfs_dir, "etc")) == NULL ||
1316 1318 (bootfs_etc_inet_dir = make_path(bootfs_etc_dir, "inet")) == NULL ||
1317 1319 (bootfs_dev_dir = make_path(bootfs_dir, "dev")) == NULL) {
1318 1320 goto cleanup;
1319 1321 }
1320 1322 if (mkdirp(bootfs_dir, 0700) ||
1321 1323 mkdirp(bootfs_etc_dir, 0700) ||
1322 1324 mkdirp(bootfs_etc_inet_dir, 0700) ||
1323 1325 mkdirp(bootfs_dev_dir, 0700)) {
1324 1326 print_status(500, "(error creating wanbootfs dir structure)");
1325 1327 goto cleanup;
1326 1328 }
1327 1329
1328 1330 if (authenticate_client) {
1329 1331 /*
1330 1332 * Add the client private key.
1331 1333 */
1332 1334 if ((keystorepath = make_path(bootfs_dir,
1333 1335 NB_CLIENT_KEY)) == NULL ||
1334 1336 netboot_ftw(NB_CLIENT_KEY, net, cid,
1335 1337 create_keystore, keystorepath) != WBCGI_FTW_CBOK) {
1336 1338 goto cleanup;
1337 1339 }
1338 1340
1339 1341 /*
1340 1342 * Add the client certificate.
1341 1343 */
1342 1344 if ((certstorepath = make_path(bootfs_dir,
1343 1345 NB_CLIENT_CERT)) == NULL ||
1344 1346 netboot_ftw(NB_CLIENT_CERT, net, cid,
1345 1347 copy_certstore, certstorepath) != WBCGI_FTW_CBOK) {
1346 1348 goto cleanup;
1347 1349 }
1348 1350 }
1349 1351
1350 1352 if (authenticate_client || authenticate_server) {
1351 1353 /*
1352 1354 * Add the trustfile; at least one truststore must exist.
1353 1355 */
1354 1356 if ((truststorepath = make_path(bootfs_dir,
1355 1357 NB_CA_CERT)) == NULL) {
1356 1358 goto cleanup;
1357 1359 }
1358 1360 if (netboot_ftw(NB_CA_CERT, net, cid,
1359 1361 noact_cb, NULL) != WBCGI_FTW_CBOK) {
1360 1362 print_status(500, "(truststore not found)");
1361 1363 }
1362 1364 if (netboot_ftw(NB_CA_CERT, net, cid,
1363 1365 build_trustfile, truststorepath) == WBCGI_FTW_CBERR) {
1364 1366 goto cleanup;
1365 1367 }
1366 1368
1367 1369 /*
1368 1370 * Create the /dev/urandom file.
1369 1371 */
1370 1372 if ((urandompath = make_path(bootfs_dev_dir,
1371 1373 "urandom")) == NULL ||
1372 1374 !create_urandom(urandompath)) {
1373 1375 goto cleanup;
1374 1376 }
1375 1377 }
1376 1378
1377 1379 /*
1378 1380 * Add the wanboot.conf(4) file.
1379 1381 */
1380 1382 if ((bootconfpath = make_path(bootfs_dir, NB_WANBOOT_CONF)) == NULL ||
1381 1383 !copy_file(bootconf, bootconfpath)) {
1382 1384 goto cleanup;
1383 1385 }
1384 1386
1385 1387 /*
1386 1388 * Add the system_conf file if present.
1387 1389 */
1388 1390 if ((scf = bootconf_get(&bc_handle, BC_SYSTEM_CONF)) != NULL) {
1389 1391 if (netboot_ftw(scf, net, cid,
1390 1392 set_pathname, &systemconf) != WBCGI_FTW_CBOK) {
1391 1393 print_status(500, "(system_conf file not found)");
1392 1394 goto cleanup;
1393 1395 }
1394 1396 if ((systemconfpath = make_path(bootfs_dir,
1395 1397 NB_SYSTEM_CONF)) == NULL ||
1396 1398 !copy_file(systemconf, systemconfpath)) {
1397 1399 goto cleanup;
1398 1400 }
1399 1401 }
1400 1402
1401 1403 /*
1402 1404 * Create the /nonce file.
1403 1405 */
1404 1406 if ((noncepath = make_path(bootfs_dir, "nonce")) == NULL ||
1405 1407 !create_nonce(noncepath, nonce)) {
1406 1408 goto cleanup;
1407 1409 }
1408 1410
1409 1411 /*
1410 1412 * Create an /etc/inet/hosts file by extracting hostnames from CN,
1411 1413 * URLs in bootconf and resolve-hosts in bootconf.
1412 1414 */
1413 1415 if ((hostspath = make_path(bootfs_etc_inet_dir, "hosts")) == NULL ||
1414 1416 !create_hostsfile(hostspath, net, cid)) {
1415 1417 goto cleanup;
1416 1418 }
1417 1419
1418 1420 /*
1419 1421 * We would like to create a symbolic link etc/hosts -> etc/inet/hosts,
1420 1422 * but unfortunately the HSFS support in the standalone doesn't handle
1421 1423 * symlinks.
1422 1424 */
1423 1425 if ((etc_hostspath = make_path(bootfs_etc_dir, "hosts")) == NULL ||
1424 1426 !copy_file(hostspath, etc_hostspath)) {
1425 1427 goto cleanup;
1426 1428 }
1427 1429
1428 1430 /*
1429 1431 * Create the /timestamp file.
1430 1432 */
1431 1433 if ((timestamppath = make_path(bootfs_dir, "timestamp")) == NULL ||
1432 1434 !create_timestamp(timestamppath, "timestamp")) {
1433 1435 goto cleanup;
1434 1436 }
1435 1437
1436 1438 /*
1437 1439 * Create an HSFS file system for the directory.
1438 1440 */
1439 1441 if ((*wanbootfs_imagep = gen_tmppath("wanbootfs", net, cid)) == NULL ||
1440 1442 !mkisofs(bootfs_dir, *wanbootfs_imagep)) {
1441 1443 goto cleanup;
1442 1444 }
1443 1445
1444 1446 ret = B_TRUE;
1445 1447 cleanup:
1446 1448 /*
1447 1449 * Clean up temporary files and directories.
1448 1450 */
1449 1451 if (keystorepath != NULL &&
1450 1452 WBCGI_FILE_EXISTS(keystorepath, sbuf)) {
1451 1453 (void) unlink(keystorepath);
1452 1454 }
1453 1455 if (certstorepath != NULL &&
1454 1456 WBCGI_FILE_EXISTS(certstorepath, sbuf)) {
1455 1457 (void) unlink(certstorepath);
1456 1458 }
1457 1459 if (truststorepath != NULL &&
1458 1460 WBCGI_FILE_EXISTS(truststorepath, sbuf)) {
1459 1461 (void) unlink(truststorepath);
1460 1462 }
1461 1463 if (bootconfpath != NULL &&
1462 1464 WBCGI_FILE_EXISTS(bootconfpath, sbuf)) {
1463 1465 (void) unlink(bootconfpath);
1464 1466 }
1465 1467 if (systemconfpath != NULL &&
1466 1468 WBCGI_FILE_EXISTS(systemconfpath, sbuf)) {
1467 1469 (void) unlink(systemconfpath);
1468 1470 }
1469 1471 if (urandompath != NULL &&
1470 1472 WBCGI_FILE_EXISTS(urandompath, sbuf)) {
1471 1473 (void) unlink(urandompath);
1472 1474 }
1473 1475 if (noncepath != NULL &&
1474 1476 WBCGI_FILE_EXISTS(noncepath, sbuf)) {
1475 1477 (void) unlink(noncepath);
1476 1478 }
1477 1479 if (hostspath != NULL &&
1478 1480 WBCGI_FILE_EXISTS(hostspath, sbuf)) {
1479 1481 (void) unlink(hostspath);
1480 1482 }
1481 1483 if (etc_hostspath != NULL &&
1482 1484 WBCGI_FILE_EXISTS(etc_hostspath, sbuf)) {
1483 1485 (void) unlink(etc_hostspath);
1484 1486 }
1485 1487 if (timestamppath != NULL &&
1486 1488 WBCGI_FILE_EXISTS(timestamppath, sbuf)) {
1487 1489 (void) unlink(timestamppath);
1488 1490 }
1489 1491
1490 1492 if (bootfs_etc_inet_dir != NULL &&
1491 1493 WBCGI_DIR_EXISTS(bootfs_etc_inet_dir, sbuf)) {
1492 1494 (void) rmdir(bootfs_etc_inet_dir);
1493 1495 }
1494 1496 if (bootfs_etc_dir != NULL &&
1495 1497 WBCGI_DIR_EXISTS(bootfs_etc_dir, sbuf)) {
1496 1498 (void) rmdir(bootfs_etc_dir);
1497 1499 }
1498 1500 if (bootfs_dev_dir != NULL &&
1499 1501 WBCGI_DIR_EXISTS(bootfs_dev_dir, sbuf)) {
1500 1502 (void) rmdir(bootfs_dev_dir);
1501 1503 }
1502 1504 if (bootfs_dir != NULL &&
1503 1505 WBCGI_DIR_EXISTS(bootfs_dir, sbuf)) {
1504 1506 (void) rmdir(bootfs_dir);
1505 1507 }
1506 1508
1507 1509 /*
1508 1510 * Free allocated memory.
1509 1511 */
1510 1512 free_path(&bootfs_dir);
1511 1513 free_path(&bootfs_etc_dir);
1512 1514 free_path(&bootfs_etc_inet_dir);
1513 1515 free_path(&bootfs_dev_dir);
1514 1516
1515 1517 free_path(&systemconf);
1516 1518 free_path(&keystorepath);
1517 1519 free_path(&certstorepath);
1518 1520 free_path(&truststorepath);
1519 1521 free_path(&bootconfpath);
1520 1522 free_path(&systemconfpath);
1521 1523 free_path(&urandompath);
1522 1524 free_path(&noncepath);
1523 1525 free_path(&hostspath);
1524 1526 free_path(&etc_hostspath);
1525 1527 free_path(×tamppath);
1526 1528
1527 1529 return (ret);
1528 1530 }
1529 1531
1530 1532 static boolean_t
1531 1533 miniroot_payload(const char *net, const char *cid, const char *docroot,
1532 1534 char **rootpathp, char **rootinfop, boolean_t *https_rootserverp)
1533 1535 {
1534 1536 boolean_t ret = B_FALSE;
1535 1537 char *root_server;
1536 1538 char *root_file;
1537 1539 url_t url;
1538 1540 struct stat sbuf;
1539 1541 char sizebuf[WBCGI_MAXBUF];
1540 1542 int chars;
1541 1543 int fd = -1;
1542 1544
1543 1545 if ((root_server = bootconf_get(&bc_handle, BC_ROOT_SERVER)) == NULL) {
1544 1546 print_status(500, "(root_server must be specified)");
1545 1547 goto cleanup;
1546 1548 }
1547 1549 if (url_parse(root_server, &url) != URL_PARSE_SUCCESS) {
1548 1550 print_status(500, "(root_server URL is invalid)");
1549 1551 }
1550 1552 *https_rootserverp = url.https;
1551 1553
1552 1554 if ((root_file = bootconf_get(&bc_handle, BC_ROOT_FILE)) == NULL) {
1553 1555 print_status(500, "(rootfile must be specified)");
1554 1556 goto cleanup;
1555 1557 }
1556 1558 if ((*rootpathp = make_path(docroot, root_file)) == NULL) {
1557 1559 goto cleanup;
1558 1560 }
1559 1561 if (!WBCGI_FILE_EXISTS(*rootpathp, sbuf)) {
1560 1562 print_status(500, "(root filesystem image missing)");
1561 1563 goto cleanup;
1562 1564 }
1563 1565
1564 1566 if ((*rootinfop = gen_tmppath("mrinfo", net, cid)) == NULL) {
1565 1567 goto cleanup;
1566 1568 }
1567 1569 if ((chars = snprintf(sizebuf, sizeof (sizebuf), "%ld",
1568 1570 sbuf.st_size)) < 0 || chars > sizeof (sizebuf) ||
1569 1571 (fd = open(*rootinfop,
1570 1572 O_RDWR|O_CREAT|O_EXCL, S_IRUSR|S_IWUSR)) == -1 ||
1571 1573 !write_buffer(fd, sizebuf, strlen(sizebuf))) {
1572 1574 print_status(500, "(error creating miniroot info file)");
1573 1575 goto cleanup;
1574 1576 }
1575 1577
1576 1578 ret = B_TRUE;
1577 1579 cleanup:
1578 1580 if (fd != -1) {
1579 1581 (void) close(fd);
1580 1582 }
1581 1583
1582 1584 return (ret);
1583 1585 }
1584 1586
1585 1587 static boolean_t
1586 1588 deliver_payload(const char *payload, const char *payload_hash)
1587 1589 {
1588 1590 int fd = fileno(stdout);
1589 1591 struct stat payload_buf, hash_buf;
1590 1592 int chars;
1591 1593 char main_header[WBCGI_MAXBUF];
1592 1594 char multi_header[WBCGI_MAXBUF];
1593 1595 char multi_header1[WBCGI_MAXBUF];
1594 1596 char multi_header2[WBCGI_MAXBUF];
1595 1597 char multi_end[WBCGI_MAXBUF];
1596 1598 size_t msglen;
1597 1599
1598 1600 if (!WBCGI_FILE_EXISTS(payload, payload_buf) ||
1599 1601 !WBCGI_FILE_EXISTS(payload_hash, hash_buf)) {
1600 1602 print_status(500, "(payload/hash file(s) missing)");
1601 1603 return (B_FALSE);
1602 1604 }
1603 1605
1604 1606 /*
1605 1607 * Multi-part header.
1606 1608 */
1607 1609 if ((chars = snprintf(multi_header, sizeof (multi_header),
1608 1610 "%s--%s%s%sapplication/octet-stream%s%s", WBCGI_CRNL,
1609 1611 WBCGI_WANBOOT_BNDTXT, WBCGI_CRNL, WBCGI_CONTENT_TYPE, WBCGI_CRNL,
1610 1612 WBCGI_CONTENT_LENGTH)) < 0 || chars > sizeof (multi_header)) {
1611 1613 print_status(500, "(error creating multi_header)");
1612 1614 return (B_FALSE);
1613 1615 }
1614 1616
1615 1617 /*
1616 1618 * Multi-part header for part one.
1617 1619 */
1618 1620 if ((chars = snprintf(multi_header1, sizeof (multi_header1),
1619 1621 "%s%ld%s%s", multi_header, payload_buf.st_size, WBCGI_CRNL,
1620 1622 WBCGI_CRNL)) < 0 || chars > sizeof (multi_header1)) {
1621 1623 print_status(500, "(error creating multi_header1)");
1622 1624 return (B_FALSE);
1623 1625 }
1624 1626
1625 1627 /*
1626 1628 * Multi-part header for part two.
1627 1629 */
1628 1630 if ((chars = snprintf(multi_header2, sizeof (multi_header2),
1629 1631 "%s%ld%s%s", multi_header, hash_buf.st_size, WBCGI_CRNL,
1630 1632 WBCGI_CRNL)) < 0 || chars > sizeof (multi_header2)) {
1631 1633 print_status(500, "(error creating multi_header2)");
1632 1634 return (B_FALSE);
1633 1635 }
1634 1636
1635 1637 /*
1636 1638 * End-of-parts Trailer.
1637 1639 */
1638 1640 if ((chars = snprintf(multi_end, sizeof (multi_end),
1639 1641 "%s--%s--%s", WBCGI_CRNL, WBCGI_WANBOOT_BNDTXT,
1640 1642 WBCGI_CRNL)) < 0 || chars > sizeof (multi_end)) {
1641 1643 print_status(500, "(error creating multi_end)");
1642 1644 return (B_FALSE);
1643 1645 }
1644 1646
1645 1647 /*
1646 1648 * Message header.
1647 1649 */
1648 1650 msglen = payload_buf.st_size + hash_buf.st_size +
1649 1651 strlen(multi_header1) + strlen(multi_header2) + strlen(multi_end);
1650 1652
1651 1653 if ((chars = snprintf(main_header, sizeof (main_header),
1652 1654 "%s%u%s%smultipart/mixed; boundary=%s%s%s", WBCGI_CONTENT_LENGTH,
1653 1655 msglen, WBCGI_CRNL, WBCGI_CONTENT_TYPE, WBCGI_WANBOOT_BNDTXT,
1654 1656 WBCGI_CRNL, WBCGI_CRNL)) < 0 || chars > sizeof (main_header)) {
1655 1657 print_status(500, "(error creating main_header)");
1656 1658 return (B_FALSE);
1657 1659 }
1658 1660
1659 1661 /*
1660 1662 * Write the message out. If things fall apart during this then
1661 1663 * there's no way to report the error back to the client.
1662 1664 */
1663 1665 if (!write_buffer(fd, main_header, strlen(main_header)) ||
1664 1666 !write_buffer(fd, multi_header1, strlen(multi_header1)) ||
1665 1667 !write_file(fd, payload, payload_buf.st_size) ||
1666 1668 !write_buffer(fd, multi_header2, strlen(multi_header2)) ||
1667 1669 !write_file(fd, payload_hash, hash_buf.st_size) ||
1668 1670 !write_buffer(fileno(stdout), multi_end, strlen(multi_end))) {
1669 1671 return (B_FALSE);
1670 1672 }
1671 1673
1672 1674 return (B_TRUE);
1673 1675 }
1674 1676
1675 1677
1676 1678 /*ARGSUSED*/
1677 1679 int
1678 1680 main(int argc, char **argv)
1679 1681 {
1680 1682 int ret = WBCGI_STATUS_ERR;
1681 1683 struct stat sbuf;
1682 1684 int content;
1683 1685 char *net;
1684 1686 char *cid;
1685 1687 char *nonce;
1686 1688 char *docroot;
1687 1689 char *payload;
1688 1690 char *signature_type;
1689 1691 char *encryption_type;
1690 1692 char *bootconf = NULL;
1691 1693 char *keyfile = NULL;
1692 1694 char *bootpath = NULL;
1693 1695 char *wanbootfs_image = NULL;
1694 1696 char *rootpath = NULL;
1695 1697 char *miniroot_info = NULL;
1696 1698 char *encr_payload = NULL;
1697 1699 char *payload_hash = NULL;
1698 1700 boolean_t https_rootserver;
1699 1701
1700 1702 /*
1701 1703 * Process the query string.
1702 1704 */
1703 1705 if (!get_request_info(&content, &net, &cid, &nonce, &docroot)) {
1704 1706 goto cleanup;
1705 1707 }
1706 1708
1707 1709 /*
1708 1710 * Sanity check that the netboot directory exists.
1709 1711 */
1710 1712 if (!WBCGI_DIR_EXISTS(NB_NETBOOT_ROOT, sbuf)) {
1711 1713 print_status(500, "(" NB_NETBOOT_ROOT " does not exist)");
1712 1714 goto cleanup;
1713 1715 }
1714 1716
1715 1717 /*
1716 1718 * Get absolute bootconf pathname.
1717 1719 */
1718 1720 if (netboot_ftw(NB_WANBOOT_CONF, net, cid,
1719 1721 set_pathname, &bootconf) != WBCGI_FTW_CBOK) {
1720 1722 print_status(500, "(wanboot.conf not found)");
1721 1723 goto cleanup;
1722 1724 }
1723 1725
1724 1726 /*
1725 1727 * Initialize bc_handle from the given wanboot.conf file.
1726 1728 */
1727 1729 if (bootconf_init(&bc_handle, bootconf) != BC_SUCCESS) {
1728 1730 char message[WBCGI_MAXBUF];
1729 1731 int chars;
1730 1732
1731 1733 chars = snprintf(message, sizeof (message),
1732 1734 "(wanboot.conf error: %s)", bootconf_errmsg(&bc_handle));
1733 1735 if (chars > 0 && chars < sizeof (message))
1734 1736 print_status(500, message);
1735 1737 else
1736 1738 print_status(500, "(wanboot.conf error)");
1737 1739 goto cleanup;
1738 1740 }
1739 1741
1740 1742 /*
1741 1743 * Get and check signature and encryption types,
1742 1744 * presence of helper utilities, keystore, etc.
1743 1745 */
1744 1746 if ((signature_type = bootconf_get(&bc_handle,
1745 1747 BC_SIGNATURE_TYPE)) != NULL) {
1746 1748 if (!WBCGI_FILE_EXISTS(WBCGI_HMAC_PATH, sbuf)) {
1747 1749 print_status(500, "(hmac utility not found)");
1748 1750 goto cleanup;
1749 1751 }
1750 1752 if (keyfile == NULL && netboot_ftw(NB_CLIENT_KEY, net, cid,
1751 1753 set_pathname, &keyfile) != WBCGI_FTW_CBOK) {
1752 1754 print_status(500, "(keystore not found)");
1753 1755 goto cleanup;
1754 1756 }
1755 1757 if (!check_key_type(keyfile, signature_type, WBKU_HASH_KEY)) {
1756 1758 print_status(500, "(hash key not found)");
1757 1759 goto cleanup;
1758 1760 }
1759 1761 }
1760 1762 if ((encryption_type = bootconf_get(&bc_handle,
1761 1763 BC_ENCRYPTION_TYPE)) != NULL) {
1762 1764 if (signature_type == NULL) {
1763 1765 print_status(500, "(encrypted but not signed)");
1764 1766 goto cleanup;
1765 1767 }
1766 1768 if (!WBCGI_FILE_EXISTS(WBCGI_ENCR_PATH, sbuf)) {
1767 1769 print_status(500, "(encr utility not found)");
1768 1770 goto cleanup;
1769 1771 }
1770 1772 if (keyfile == NULL && netboot_ftw(NB_CLIENT_KEY, net, cid,
1771 1773 set_pathname, &keyfile) != WBCGI_FTW_CBOK) {
1772 1774 print_status(500, "(keystore not found)");
1773 1775 goto cleanup;
1774 1776 }
1775 1777 if (!check_key_type(keyfile, encryption_type, WBKU_ENCR_KEY)) {
1776 1778 print_status(500, "(encr key not found)");
1777 1779 goto cleanup;
1778 1780 }
1779 1781 }
1780 1782
1781 1783 /*
1782 1784 * Determine/create our payload.
1783 1785 */
1784 1786 switch (content) {
1785 1787 case WBCGI_CONTENT_BOOTFILE:
1786 1788 if (!bootfile_payload(docroot, &bootpath)) {
1787 1789 goto cleanup;
1788 1790 }
1789 1791 payload = bootpath;
1790 1792
1791 1793 break;
1792 1794
1793 1795 case WBCGI_CONTENT_BOOTFS:
1794 1796 if (!wanbootfs_payload(net, cid, nonce,
1795 1797 bootconf, &wanbootfs_image)) {
1796 1798 goto cleanup;
1797 1799 }
1798 1800 payload = wanbootfs_image;
1799 1801
1800 1802 break;
1801 1803
1802 1804 case WBCGI_CONTENT_ROOTFS:
1803 1805 if (!miniroot_payload(net, cid, docroot,
1804 1806 &rootpath, &miniroot_info, &https_rootserver)) {
1805 1807 goto cleanup;
1806 1808 }
1807 1809 payload = rootpath;
1808 1810
1809 1811 break;
1810 1812 }
1811 1813
1812 1814 /*
1813 1815 * Encrypt the payload if necessary.
1814 1816 */
1815 1817 if (content != WBCGI_CONTENT_BOOTFILE &&
1816 1818 content != WBCGI_CONTENT_ROOTFS &&
1817 1819 encryption_type != NULL) {
1818 1820 if ((encr_payload = gen_tmppath("encr", net, cid)) == NULL) {
1819 1821 goto cleanup;
1820 1822 }
1821 1823
1822 1824 if (!encrypt_payload(payload, encr_payload, keyfile,
1823 1825 encryption_type)) {
1824 1826 goto cleanup;
1825 1827 }
1826 1828
1827 1829 payload = encr_payload;
1828 1830 }
1829 1831
1830 1832 /*
1831 1833 * Compute the hash (actual or null).
1832 1834 */
1833 1835 if ((payload_hash = gen_tmppath("hash", net, cid)) == NULL) {
1834 1836 goto cleanup;
1835 1837 }
1836 1838
1837 1839 if (signature_type != NULL &&
1838 1840 (content != WBCGI_CONTENT_ROOTFS || !https_rootserver)) {
1839 1841 if (!hash_payload(payload, payload_hash, keyfile)) {
1840 1842 goto cleanup;
1841 1843 }
1842 1844 } else {
1843 1845 if (!create_null_hash(payload_hash)) {
1844 1846 goto cleanup;
1845 1847 }
1846 1848 }
1847 1849
1848 1850 /*
1849 1851 * For the rootfs the actual payload transmitted is the file
1850 1852 * containing the size of the rootfs (as a string of ascii digits);
1851 1853 * point payload at this instead.
1852 1854 */
1853 1855 if (content == WBCGI_CONTENT_ROOTFS) {
1854 1856 payload = miniroot_info;
1855 1857 }
1856 1858
1857 1859 /*
1858 1860 * Finally, deliver the payload and hash as a multipart message.
1859 1861 */
1860 1862 if (!deliver_payload(payload, payload_hash)) {
1861 1863 goto cleanup;
1862 1864 }
1863 1865
1864 1866 ret = WBCGI_STATUS_OK;
1865 1867 cleanup:
1866 1868 /*
1867 1869 * Clean up temporary files.
1868 1870 */
1869 1871 if (wanbootfs_image != NULL &&
1870 1872 WBCGI_FILE_EXISTS(wanbootfs_image, sbuf)) {
1871 1873 (void) unlink(wanbootfs_image);
1872 1874 }
1873 1875 if (miniroot_info != NULL &&
1874 1876 WBCGI_FILE_EXISTS(miniroot_info, sbuf)) {
1875 1877 (void) unlink(miniroot_info);
1876 1878 }
1877 1879 if (encr_payload != NULL &&
1878 1880 WBCGI_FILE_EXISTS(encr_payload, sbuf)) {
1879 1881 (void) unlink(encr_payload);
1880 1882 }
1881 1883 if (payload_hash != NULL &&
1882 1884 WBCGI_FILE_EXISTS(payload_hash, sbuf)) {
1883 1885 (void) unlink(payload_hash);
1884 1886 }
1885 1887
1886 1888 /*
1887 1889 * Free up any allocated strings.
1888 1890 */
1889 1891 free_path(&bootconf);
1890 1892 free_path(&keyfile);
1891 1893 free_path(&bootpath);
1892 1894 free_path(&wanbootfs_image);
1893 1895 free_path(&rootpath);
1894 1896 free_path(&miniroot_info);
1895 1897 free_path(&encr_payload);
1896 1898 free_path(&payload_hash);
1897 1899
1898 1900 bootconf_end(&bc_handle);
1899 1901
1900 1902 return (ret);
1901 1903 }
|
↓ open down ↓ |
800 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX