1 /* $NetBSD: save.c,v 1.15 2021/04/12 09:12:28 mrg Exp $ */ 2 3 /*- 4 * Copyright (c) 1991, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * The game adventure was originally written in Fortran by Will Crowther 8 * and Don Woods. It was later translated to C and enhanced by Jim 9 * Gillogly. This code is derived from software contributed to Berkeley 10 * by Jim Gillogly at The Rand Corporation. 11 * 12 * Redistribution and use in source and binary forms, with or without 13 * modification, are permitted provided that the following conditions 14 * are met: 15 * 1. Redistributions of source code must retain the above copyright 16 * notice, this list of conditions and the following disclaimer. 17 * 2. Redistributions in binary form must reproduce the above copyright 18 * notice, this list of conditions and the following disclaimer in the 19 * documentation and/or other materials provided with the distribution. 20 * 3. Neither the name of the University nor the names of its contributors 21 * may be used to endorse or promote products derived from this software 22 * without specific prior written permission. 23 * 24 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 27 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 34 * SUCH DAMAGE. 35 */ 36 37 #include <sys/cdefs.h> 38 #ifndef lint 39 #if 0 40 static char sccsid[] = "@(#)save.c 8.1 (Berkeley) 5/31/93"; 41 #else 42 __RCSID("$NetBSD: save.c,v 1.15 2021/04/12 09:12:28 mrg Exp $"); 43 #endif 44 #endif /* not lint */ 45 46 #include <sys/types.h> 47 #include <sys/time.h> 48 #include <stdbool.h> 49 #include <stdio.h> 50 #include <stdlib.h> 51 #include <err.h> 52 #include <assert.h> 53 54 #include "hdr.h" 55 #include "extern.h" 56 57 struct savefile { 58 FILE *f; 59 const char *name; 60 bool warned; 61 size_t bintextpos; 62 uint32_t key; 63 struct crcstate crc; 64 unsigned char pad[8]; 65 unsigned padpos; 66 }; 67 68 #define BINTEXT_WIDTH 60 69 #define FORMAT_VERSION 2 70 #define FORMAT_VERSION_NOSUM 1 71 static const char header[] = "Adventure save file\n"; 72 73 //////////////////////////////////////////////////////////// 74 // base16 output encoding 75 76 /* 77 * Map 16 plain values into 90 coded values and back. 78 */ 79 80 static const char coding[91] = 81 "Db.GOyT]7a6zpF(c*5H9oK~0[WVAg&kR)ml,2^q-1Y3v+" 82 "X/=JirZL$C>_N?:}B{dfnsxU<@MQ%8|P!4h`ESt;euwIj" 83 ; 84 85 static int 86 readletter(char letter, unsigned char *ret) 87 { 88 const char *s; 89 90 s = strchr(coding, letter); 91 if (s == NULL) { 92 return 1; 93 } 94 *ret = (s - coding) % 16; 95 return 0; 96 } 97 98 static char 99 writeletter(unsigned char nibble) 100 { 101 unsigned code; 102 103 assert(nibble < 16); 104 do { 105 code = (16 * (random() % 6)) + nibble; 106 } while (code >= 90); 107 return coding[code]; 108 } 109 110 //////////////////////////////////////////////////////////// 111 // savefile 112 113 /* 114 * Open a savefile. 115 */ 116 static struct savefile * 117 savefile_open(const char *name, bool forwrite) 118 { 119 struct savefile *sf; 120 121 sf = malloc(sizeof(*sf)); 122 if (sf == NULL) { 123 return NULL; 124 } 125 sf->f = fopen(name, forwrite ? "w" : "r"); 126 if (sf->f == NULL) { 127 free(sf); 128 fprintf(stderr, 129 "Hmm. The name \"%s\" appears to be magically blocked.\n", 130 name); 131 return NULL; 132 } 133 sf->name = name; 134 sf->warned = false; 135 sf->bintextpos = 0; 136 sf->key = 0; 137 crc_start(&sf->crc); 138 memset(sf->pad, 0, sizeof(sf->pad)); 139 sf->padpos = 0; 140 return sf; 141 } 142 143 /* 144 * Raw read. 145 */ 146 static int 147 savefile_rawread(struct savefile *sf, void *data, size_t len) 148 { 149 size_t result; 150 151 result = fread(data, 1, len, sf->f); 152 if (result != len || ferror(sf->f)) { 153 fprintf(stderr, "Oops: error reading %s.\n", sf->name); 154 sf->warned = true; 155 return 1; 156 } 157 return 0; 158 } 159 160 /* 161 * Raw write. 162 */ 163 static int 164 savefile_rawwrite(struct savefile *sf, const void *data, size_t len) 165 { 166 size_t result; 167 168 result = fwrite(data, 1, len, sf->f); 169 if (result != len || ferror(sf->f)) { 170 fprintf(stderr, "Oops: error writing %s.\n", sf->name); 171 sf->warned = true; 172 return 1; 173 } 174 return 0; 175 } 176 177 /* 178 * Close a savefile. 179 */ 180 static int 181 savefile_close(struct savefile *sf) 182 { 183 int ret; 184 185 if (sf->bintextpos > 0) { 186 savefile_rawwrite(sf, "\n", 1); 187 } 188 189 ret = 0; 190 if (fclose(sf->f)) { 191 if (!sf->warned) { 192 fprintf(stderr, "Oops: error on %s.\n", sf->name); 193 } 194 ret = 1; 195 } 196 free(sf); 197 return ret; 198 } 199 200 /* 201 * Read encoded binary data, discarding any whitespace that appears. 202 */ 203 static int 204 savefile_bintextread(struct savefile *sf, void *data, size_t len) 205 { 206 size_t pos; 207 unsigned char *udata; 208 int ch; 209 210 udata = data; 211 pos = 0; 212 while (pos < len) { 213 ch = fgetc(sf->f); 214 if (ch == EOF || ferror(sf->f)) { 215 fprintf(stderr, "Oops: error reading %s.\n", sf->name); 216 sf->warned = true; 217 return 1; 218 } 219 if (ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n') { 220 continue; 221 } 222 udata[pos++] = ch; 223 } 224 return 0; 225 } 226 227 /* 228 * Read binary data, decoding from text using readletter(). 229 */ 230 static int 231 savefile_binread(struct savefile *sf, void *data, size_t len) 232 { 233 unsigned char buf[64]; 234 unsigned char *udata; 235 unsigned char val1, val2; 236 size_t pos, amt, i; 237 238 udata = data; 239 pos = 0; 240 while (pos < len) { 241 amt = len - pos; 242 if (amt > sizeof(buf) / 2) { 243 amt = sizeof(buf) / 2; 244 } 245 if (savefile_bintextread(sf, buf, amt*2)) { 246 return 1; 247 } 248 for (i=0; i<amt; i++) { 249 if (readletter(buf[i*2], &val1)) { 250 return 1; 251 } 252 if (readletter(buf[i*2 + 1], &val2)) { 253 return 1; 254 } 255 udata[pos++] = val1 * 16 + val2; 256 } 257 } 258 return 0; 259 } 260 261 /* 262 * Write encoded binary data, inserting newlines to get a neatly 263 * formatted block. 264 */ 265 static int 266 savefile_bintextwrite(struct savefile *sf, const void *data, size_t len) 267 { 268 size_t pos, amt; 269 const unsigned char *udata; 270 271 udata = data; 272 pos = 0; 273 while (pos < len) { 274 amt = BINTEXT_WIDTH - sf->bintextpos; 275 if (amt > len - pos) { 276 amt = len - pos; 277 } 278 if (savefile_rawwrite(sf, udata + pos, amt)) { 279 return 1; 280 } 281 pos += amt; 282 sf->bintextpos += amt; 283 if (sf->bintextpos >= BINTEXT_WIDTH) { 284 savefile_rawwrite(sf, "\n", 1); 285 sf->bintextpos = 0; 286 } 287 } 288 return 0; 289 } 290 291 /* 292 * Write binary data, encoding as text using writeletter(). 293 */ 294 static int 295 savefile_binwrite(struct savefile *sf, const void *data, size_t len) 296 { 297 unsigned char buf[64]; 298 const unsigned char *udata; 299 size_t pos, bpos; 300 unsigned char byte; 301 302 udata = data; 303 pos = 0; 304 bpos = 0; 305 while (pos < len) { 306 byte = udata[pos++]; 307 buf[bpos++] = writeletter(byte >> 4); 308 buf[bpos++] = writeletter(byte & 0xf); 309 if (bpos >= sizeof(buf)) { 310 if (savefile_bintextwrite(sf, buf, bpos)) { 311 return 1; 312 } 313 bpos = 0; 314 } 315 } 316 if (savefile_bintextwrite(sf, buf, bpos)) { 317 return 1; 318 } 319 return 0; 320 } 321 322 /* 323 * Lightweight "encryption" for save files. This is not meant to 324 * be secure and wouldn't be even if we didn't write the decrypt 325 * key to the beginning of the save file; it's just meant to be 326 * enough to discourage casual cheating. 327 */ 328 329 /* 330 * Make cheesy hash of buf[0..buflen]. Note: buf and outhash may overlap. 331 */ 332 static void 333 hash(const void *data, size_t datalen, unsigned char *out, size_t outlen) 334 { 335 const unsigned char *udata; 336 size_t i; 337 uint64_t val; 338 const unsigned char *uval; 339 size_t valpos; 340 341 udata = data; 342 val = 0; 343 for (i=0; i<datalen; i++) { 344 val = val ^ 0xbadc0ffee; 345 val = (val << 4) | (val >> 60); 346 val += udata[i] ^ 0xbeefU; 347 } 348 349 uval = (unsigned char *)&val; 350 valpos = 0; 351 for (i=0; i<outlen; i++) { 352 out[i] = uval[valpos++]; 353 if (valpos >= sizeof(val)) { 354 valpos = 0; 355 } 356 } 357 } 358 359 /* 360 * Set the "encryption" key. 361 */ 362 static void 363 savefile_key(struct savefile *sf, uint32_t key) 364 { 365 sf->key = 0; 366 crc_start(&sf->crc); 367 hash(&sf->key, sizeof(sf->key), sf->pad, sizeof(sf->pad)); 368 sf->padpos = 0; 369 } 370 371 /* 372 * Get an "encryption" pad byte. This forms a stream "cipher" that we 373 * xor with the plaintext save data. 374 */ 375 static unsigned char 376 savefile_getpad(struct savefile *sf) 377 { 378 unsigned char ret; 379 380 ret = sf->pad[sf->padpos++]; 381 if (sf->padpos >= sizeof(sf->pad)) { 382 hash(sf->pad, sizeof(sf->pad), sf->pad, sizeof(sf->pad)); 383 sf->padpos = 0; 384 } 385 return ret; 386 } 387 388 /* 389 * Read "encrypted" data. 390 */ 391 static int 392 savefile_cread(struct savefile *sf, void *data, size_t len) 393 { 394 char buf[64]; 395 unsigned char *udata; 396 size_t pos, amt, i; 397 unsigned char ch; 398 399 udata = data; 400 pos = 0; 401 while (pos < len) { 402 amt = len - pos; 403 if (amt > sizeof(buf)) { 404 amt = sizeof(buf); 405 } 406 if (savefile_binread(sf, buf, amt)) { 407 return 1; 408 } 409 for (i=0; i<amt; i++) { 410 ch = buf[i]; 411 ch ^= savefile_getpad(sf); 412 udata[pos + i] = ch; 413 } 414 pos += amt; 415 } 416 crc_add(&sf->crc, data, len); 417 return 0; 418 } 419 420 /* 421 * Write "encrypted" data. 422 */ 423 static int 424 savefile_cwrite(struct savefile *sf, const void *data, size_t len) 425 { 426 char buf[64]; 427 const unsigned char *udata; 428 size_t pos, amt, i; 429 unsigned char ch; 430 431 udata = data; 432 pos = 0; 433 while (pos < len) { 434 amt = len - pos; 435 if (amt > sizeof(buf)) { 436 amt = sizeof(buf); 437 } 438 for (i=0; i<amt; i++) { 439 ch = udata[pos + i]; 440 ch ^= savefile_getpad(sf); 441 buf[i] = ch; 442 } 443 if (savefile_binwrite(sf, buf, amt)) { 444 return 1; 445 } 446 pos += amt; 447 } 448 crc_add(&sf->crc, data, len); 449 return 0; 450 } 451 452 //////////////////////////////////////////////////////////// 453 // compat for old save files 454 455 struct compat_saveinfo { 456 void *address; 457 size_t width; 458 }; 459 460 static const struct compat_saveinfo compat_savearray[] = 461 { 462 {&abbnum, sizeof(abbnum)}, 463 {&attack, sizeof(attack)}, 464 {&blklin, sizeof(blklin)}, 465 {&bonus, sizeof(bonus)}, 466 {&chloc, sizeof(chloc)}, 467 {&chloc2, sizeof(chloc2)}, 468 {&clock1, sizeof(clock1)}, 469 {&clock2, sizeof(clock2)}, 470 {&closed, sizeof(closed)}, 471 {&isclosing, sizeof(isclosing)}, 472 {&daltloc, sizeof(daltloc)}, 473 {&demo, sizeof(demo)}, 474 {&detail, sizeof(detail)}, 475 {&dflag, sizeof(dflag)}, 476 {&dkill, sizeof(dkill)}, 477 {&dtotal, sizeof(dtotal)}, 478 {&foobar, sizeof(foobar)}, 479 {&gaveup, sizeof(gaveup)}, 480 {&holding, sizeof(holding)}, 481 {&iwest, sizeof(iwest)}, 482 {&k, sizeof(k)}, 483 {&k2, sizeof(k2)}, 484 {&knfloc, sizeof(knfloc)}, 485 {&kq, sizeof(kq)}, 486 {&latency, sizeof(latency)}, 487 {&limit, sizeof(limit)}, 488 {&lmwarn, sizeof(lmwarn)}, 489 {&loc, sizeof(loc)}, 490 {&maxdie, sizeof(maxdie)}, 491 {&maxscore, sizeof(maxscore)}, 492 {&newloc, sizeof(newloc)}, 493 {&numdie, sizeof(numdie)}, 494 {&obj, sizeof(obj)}, 495 {&oldloc2, sizeof(oldloc2)}, 496 {&oldloc, sizeof(oldloc)}, 497 {&panic, sizeof(panic)}, 498 {&saveday, sizeof(saveday)}, 499 {&savet, sizeof(savet)}, 500 {&scoring, sizeof(scoring)}, 501 {&spk, sizeof(spk)}, 502 {&stick, sizeof(stick)}, 503 {&tally, sizeof(tally)}, 504 {&tally2, sizeof(tally2)}, 505 {&tkk, sizeof(tkk)}, 506 {&turns, sizeof(turns)}, 507 {&verb, sizeof(verb)}, 508 {&wd1, sizeof(wd1)}, 509 {&wd2, sizeof(wd2)}, 510 {&wasdark, sizeof(wasdark)}, 511 {&yea, sizeof(yea)}, 512 {atloc, sizeof(atloc)}, 513 {dloc, sizeof(dloc)}, 514 {dseen, sizeof(dseen)}, 515 {fixed, sizeof(fixed)}, 516 {hinted, sizeof(hinted)}, 517 {links, sizeof(links)}, 518 {odloc, sizeof(odloc)}, 519 {place, sizeof(place)}, 520 {prop, sizeof(prop)}, 521 {tk, sizeof(tk)}, 522 523 {NULL, 0} 524 }; 525 526 static int 527 compat_restore(const char *infile) 528 { 529 FILE *in; 530 const struct compat_saveinfo *p; 531 char *s; 532 long sum, cksum = 0; 533 size_t i; 534 struct crcstate crc; 535 536 if ((in = fopen(infile, "rb")) == NULL) { 537 fprintf(stderr, 538 "Hmm. The file \"%s\" appears to be magically blocked.\n", 539 infile); 540 return 1; 541 } 542 fread(&sum, sizeof(sum), 1, in); /* Get the seed */ 543 srandom((int) sum); 544 for (p = compat_savearray; p->address != NULL; p++) { 545 fread(p->address, p->width, 1, in); 546 for (s = p->address, i = 0; i < p->width; i++, s++) 547 *s = (*s ^ random()) & 0xFF; /* Lightly decrypt */ 548 } 549 fclose(in); 550 551 crc_start(&crc); /* See if she cheated */ 552 for (p = compat_savearray; p->address != NULL; p++) 553 crc_add(&crc, p->address, p->width); 554 cksum = crc_get(&crc); 555 if (sum != cksum) /* Tsk tsk */ 556 return 2; /* Altered the file */ 557 /* We successfully restored, so this really was a save file */ 558 559 /* 560 * The above code loads these from disk even though they're 561 * pointers. Null them out and hope we don't crash on them 562 * later; that's better than having them be garbage. 563 */ 564 tkk = NULL; 565 wd1 = NULL; 566 wd2 = NULL; 567 568 return 0; 569 } 570 571 //////////////////////////////////////////////////////////// 572 // save + restore 573 574 static int *const save_ints[] = { 575 &abbnum, 576 &attack, 577 &blklin, 578 &bonus, 579 &chloc, 580 &chloc2, 581 &clock1, 582 &clock2, 583 &closed, 584 &isclosing, 585 &daltloc, 586 &demo, 587 &detail, 588 &dflag, 589 &dkill, 590 &dtotal, 591 &foobar, 592 &gaveup, 593 &holding, 594 &iwest, 595 &k, 596 &k2, 597 &knfloc, 598 &kq, 599 &latency, 600 &limit, 601 &lmwarn, 602 &loc, 603 &maxdie, 604 &maxscore, 605 &newloc, 606 &numdie, 607 &obj, 608 &oldloc2, 609 &oldloc, 610 &panic, 611 &saveday, 612 &savet, 613 &scoring, 614 &spk, 615 &stick, 616 &tally, 617 &tally2, 618 &turns, 619 &verb, 620 &wasdark, 621 &yea, 622 }; 623 static const unsigned num_save_ints = __arraycount(save_ints); 624 625 #define INTARRAY(sym) { sym, __arraycount(sym) } 626 627 static const struct { 628 int *ptr; 629 unsigned num; 630 } save_intarrays[] = { 631 INTARRAY(atloc), 632 INTARRAY(dseen), 633 INTARRAY(dloc), 634 INTARRAY(odloc), 635 INTARRAY(fixed), 636 INTARRAY(hinted), 637 INTARRAY(links), 638 INTARRAY(place), 639 INTARRAY(prop), 640 INTARRAY(tk), 641 }; 642 static const unsigned num_save_intarrays = __arraycount(save_intarrays); 643 644 #undef INTARRAY 645 646 #if 0 647 static const struct { 648 void *ptr; 649 size_t len; 650 } save_blobs[] = { 651 { &wd1, sizeof(wd1) }, 652 { &wd2, sizeof(wd2) }, 653 { &tkk, sizeof(tkk) }, 654 }; 655 static const unsigned num_save_blobs = __arraycount(save_blobs); 656 #endif 657 658 /* 659 * Write out a save file. Returns nonzero on error. 660 */ 661 int 662 save(const char *outfile) 663 { 664 struct savefile *sf; 665 struct timespec now; 666 uint32_t key, writeable_key; 667 uint32_t version; 668 unsigned i, j, n; 669 uint32_t val, sum; 670 671 sf = savefile_open(outfile, true); 672 if (sf == NULL) { 673 return 1; 674 } 675 676 if (savefile_rawwrite(sf, header, strlen(header))) { 677 savefile_close(sf); 678 return 1; 679 } 680 681 version = htonl(FORMAT_VERSION); 682 if (savefile_binwrite(sf, &version, sizeof(version))) { 683 savefile_close(sf); 684 return 1; 685 } 686 687 clock_gettime(CLOCK_REALTIME, &now); 688 key = (uint32_t)(now.tv_sec & 0xffffffff) ^ (uint32_t)(now.tv_nsec); 689 690 writeable_key = htonl(key); 691 if (savefile_binwrite(sf, &writeable_key, sizeof(writeable_key))) { 692 savefile_close(sf); 693 return 1; 694 } 695 696 /* other parts of the code may depend on us doing this here */ 697 srandom(key); 698 699 savefile_key(sf, key); 700 701 /* 702 * Integers 703 */ 704 for (i=0; i<num_save_ints; i++) { 705 val = *(save_ints[i]); 706 val = htonl(val); 707 if (savefile_cwrite(sf, &val, sizeof(val))) { 708 savefile_close(sf); 709 return 1; 710 } 711 } 712 713 /* 714 * Arrays of integers 715 */ 716 for (i=0; i<num_save_intarrays; i++) { 717 n = save_intarrays[i].num; 718 for (j=0; j<n; j++) { 719 val = save_intarrays[i].ptr[j]; 720 val = htonl(val); 721 if (savefile_cwrite(sf, &val, sizeof(val))) { 722 savefile_close(sf); 723 return 1; 724 } 725 } 726 } 727 728 #if 0 729 /* 730 * Blobs 731 */ 732 for (i=0; i<num_save_blobs; i++) { 733 if (savefile_cwrite(sf, save_blobs[i].ptr, save_blobs[i].len)) { 734 savefile_close(sf); 735 return 1; 736 } 737 } 738 #endif 739 740 sum = htonl(crc_get(&sf->crc)); 741 if (savefile_binwrite(sf, &sum, sizeof(&sum))) { 742 savefile_close(sf); 743 return 1; 744 } 745 savefile_close(sf); 746 return 0; 747 } 748 749 /* 750 * Read in a save file. Returns nonzero on error. 751 */ 752 int 753 restore(const char *infile) 754 { 755 struct savefile *sf; 756 char buf[sizeof(header)]; 757 size_t headersize = strlen(header); 758 uint32_t version, key, sum; 759 unsigned i, j, n; 760 uint32_t val; 761 bool skipsum = false; 762 763 sf = savefile_open(infile, false); 764 if (sf == NULL) { 765 return 1; 766 } 767 768 if (savefile_rawread(sf, buf, headersize)) { 769 savefile_close(sf); 770 return 1; 771 } 772 buf[headersize] = 0; 773 if (strcmp(buf, header) != 0) { 774 savefile_close(sf); 775 fprintf(stderr, "Oh dear, that isn't one of my save files.\n"); 776 fprintf(stderr, 777 "Trying the Olde Waye; this myte notte Worke.\n"); 778 return compat_restore(infile); 779 } 780 781 if (savefile_binread(sf, &version, sizeof(version))) { 782 savefile_close(sf); 783 return 1; 784 } 785 version = ntohl(version); 786 switch (version) { 787 case FORMAT_VERSION: 788 break; 789 case FORMAT_VERSION_NOSUM: 790 skipsum = true; 791 break; 792 default: 793 savefile_close(sf); 794 fprintf(stderr, 795 "Oh dear, that file must be from the future. I don't know" 796 " how to read it!\n"); 797 return 1; 798 } 799 800 if (savefile_binread(sf, &key, sizeof(key))) { 801 savefile_close(sf); 802 return 1; 803 } 804 key = ntohl(key); 805 savefile_key(sf, key); 806 807 /* other parts of the code may depend on us doing this here */ 808 srandom(key); 809 810 /* 811 * Integers 812 */ 813 for (i=0; i<num_save_ints; i++) { 814 if (savefile_cread(sf, &val, sizeof(val))) { 815 savefile_close(sf); 816 return 1; 817 } 818 val = ntohl(val); 819 *(save_ints[i]) = val; 820 } 821 822 /* 823 * Arrays of integers 824 */ 825 for (i=0; i<num_save_intarrays; i++) { 826 n = save_intarrays[i].num; 827 for (j=0; j<n; j++) { 828 if (savefile_cread(sf, &val, sizeof(val))) { 829 savefile_close(sf); 830 return 1; 831 } 832 val = ntohl(val); 833 save_intarrays[i].ptr[j] = val; 834 } 835 } 836 837 #if 0 838 /* 839 * Blobs 840 */ 841 for (i=0; i<num_save_blobs; i++) { 842 if (savefile_cread(sf, save_blobs[i].ptr, save_blobs[i].len)) { 843 savefile_close(sf); 844 return 1; 845 } 846 } 847 #endif 848 849 if (savefile_binread(sf, &sum, sizeof(&sum))) { 850 savefile_close(sf); 851 return 1; 852 } 853 sum = ntohl(sum); 854 /* See if she cheated */ 855 if (!skipsum && sum != crc_get(&sf->crc)) { 856 /* Tsk tsk, altered the file */ 857 savefile_close(sf); 858 return 2; 859 } 860 savefile_close(sf); 861 862 /* Load theoretically invalidates these */ 863 tkk = NULL; 864 wd1 = NULL; 865 wd2 = NULL; 866 867 return 0; 868 } 869
Indexes created Sat Sep 20 22:09:52 GMT 2025