static void compare_checksums(char *file) { char name[128]; char sum[40]; char sum2[40]; FILE *F = fopen(file, "r"); if (!F) { printf("Could not open %s.\n", file); return; } while (!feof(F)) { int num = fscanf(F, "%100[KQRBNP|v|rtbwz|.]: %32[0-9|a-f]\n", name, sum); if (num != 2 || strlen(sum) != 32) { printf("Could not completely parse %s.\n", file); break; } FILE *G = fopen(name, "rb"); if (!G) { printf("Tablebase file %s not found.\n", name); } else { fclose(G); print_checksum(name, sum2); if (strcmp(sum, sum2) == 0) printf("%s: OK!\n", name); else printf("%s: FAIL!\n", name); } } fclose(F); }
void _saveregs flip_a_ems_page(struct task_struct *task_ptr) { if (!tasking) { print_checksum(); printf("flip\n"); } _DX = task_ptr->ems_handle; _CX = task_ptr->mapped_pages; _SI = (unsigned int) (emm_page_mapping); _AX = 0x5000; geninterrupt(0x67); if (!tasking) print_checksum(); }
int main(void) { crc32_gentab(); crc32(g_1.f1, sizeof(char)); crc32(g_1.f2, sizeof(int)); print_checksum(crc32_context ^ 0xFFFFFFFFUL); return 0; }
int main(int argc, char **argv) { int i; int val, longindex; int only_print = 0; int compare = 0; numthreads = 1; do { val = getopt_long(argc, argv, "t:pc", options, &longindex); switch (val) { case 't': numthreads = atoi(optarg); break; case 'p': only_print = 1; break; case 'c': compare = 1; break; } } while (val != EOF); if (optind >= argc) { printf("No tablebase specified.\n"); exit(0); } if (numthreads < 1) numthreads = 1; else if (numthreads > MAX_THREADS) numthreads = MAX_THREADS; total_work = (numthreads == 1) ? 1 : 100 + 10 * numthreads; init_threads(0); if (!compare) { if (!only_print) for (i = optind; i < argc; i++) verify_checksum(argv[i]); else for (i = optind; i < argc; i++) { char sum[40]; printf("%s: ", argv[i]); print_checksum(argv[i], sum); puts(sum); } } else { for (i = optind; i < argc; i++) compare_checksums(argv[i]); } return 0; }
inline void Density::symmetrize_density_matrix() { PROFILE("sirius::Density::symmetrize_density_matrix"); auto& sym = unit_cell_.symmetry(); int ndm = ctx_.num_mag_comp(); mdarray<double_complex, 4> dm(unit_cell_.max_mt_basis_size(), unit_cell_.max_mt_basis_size(), ndm, unit_cell_.num_atoms()); dm.zero(); int lmax = unit_cell_.lmax(); int lmmax = Utils::lmmax(lmax); mdarray<double, 2> rotm(lmmax, lmmax); double alpha = 1.0 / double(sym.num_mag_sym()); for (int i = 0; i < sym.num_mag_sym(); i++) { int pr = sym.magnetic_group_symmetry(i).spg_op.proper; auto eang = sym.magnetic_group_symmetry(i).spg_op.euler_angles; int isym = sym.magnetic_group_symmetry(i).isym; SHT::rotation_matrix(lmax, eang, pr, rotm); auto spin_rot_su2 = SHT::rotation_matrix_su2(sym.magnetic_group_symmetry(i).spin_rotation); for (int ia = 0; ia < unit_cell_.num_atoms(); ia++) { auto& atom_type = unit_cell_.atom(ia).type(); int ja = sym.sym_table(ia, isym); for (int xi1 = 0; xi1 < unit_cell_.atom(ia).mt_basis_size(); xi1++) { int l1 = atom_type.indexb(xi1).l; int lm1 = atom_type.indexb(xi1).lm; int o1 = atom_type.indexb(xi1).order; for (int xi2 = 0; xi2 < unit_cell_.atom(ia).mt_basis_size(); xi2++) { int l2 = atom_type.indexb(xi2).l; int lm2 = atom_type.indexb(xi2).lm; int o2 = atom_type.indexb(xi2).order; std::array<double_complex, 3> dm_rot_spatial = {0, 0, 0}; for (int j = 0; j < ndm; j++) { for (int m3 = -l1; m3 <= l1; m3++) { int lm3 = Utils::lm_by_l_m(l1, m3); int xi3 = atom_type.indexb().index_by_lm_order(lm3, o1); for (int m4 = -l2; m4 <= l2; m4++) { int lm4 = Utils::lm_by_l_m(l2, m4); int xi4 = atom_type.indexb().index_by_lm_order(lm4, o2); dm_rot_spatial[j] += density_matrix_(xi3, xi4, j, ja) * rotm(lm1, lm3) * rotm(lm2, lm4) * alpha; } } } /* magnetic symmetrization */ if (ndm == 1) { dm(xi1, xi2, 0, ia) += dm_rot_spatial[0]; } else { double_complex spin_dm[2][2] = { {dm_rot_spatial[0], dm_rot_spatial[2]}, {std::conj(dm_rot_spatial[2]), dm_rot_spatial[1]} }; /* spin blocks of density matrix are: uu, dd, ud the mapping from linear index (0, 1, 2) of density matrix components is: for the first spin index: k & 1, i.e. (0, 1, 2) -> (0, 1, 0) for the second spin index: min(k, 1), i.e. (0, 1, 2) -> (0, 1, 1) */ for (int k = 0; k < ndm; k++) { for (int is = 0; is < 2; is++) { for (int js = 0; js < 2; js++) { dm(xi1, xi2, k, ia) += spin_rot_su2(k & 1, is) * spin_dm[is][js] * std::conj(spin_rot_su2(std::min(k, 1), js)); } } } } } } } } dm >> density_matrix_; if (ctx_.control().print_checksum_ && ctx_.comm().rank() == 0) { auto cs = dm.checksum(); print_checksum("density_matrix", cs); //for (int ia = 0; ia < unit_cell_.num_atoms(); ia++) { // auto cs = mdarray<double_complex, 1>(&dm(0, 0, 0, ia), dm.size(0) * dm.size(1) * dm.size(2)).checksum(); // DUMP("checksum(density_matrix(%i)): %20.14f %20.14f", ia, cs.real(), cs.imag()); //} } }
/* Dump one block to FP */ int _keybox_dump_blob (KEYBOXBLOB blob, FILE *fp) { const byte *buffer; size_t length; int type, i; ulong n, nkeys, keyinfolen; ulong nuids, uidinfolen; ulong nsigs, siginfolen; ulong rawdata_off, rawdata_len; ulong nserial; ulong unhashed; const byte *p; buffer = _keybox_get_blob_image (blob, &length); if (length < 32) { fprintf (fp, "[blob too short]\n"); return -1; } n = get32( buffer ); if (n > length) fprintf (fp, "[blob larger than length - output truncated]\n"); else length = n; /* ignore the rest */ fprintf (fp, "Length: %lu\n", n ); type = buffer[4]; switch (type) { case KEYBOX_BLOBTYPE_EMPTY: fprintf (fp, "Type: Empty\n"); return 0; case KEYBOX_BLOBTYPE_HEADER: fprintf (fp, "Type: Header\n"); return dump_header_blob (buffer, length, fp); case KEYBOX_BLOBTYPE_PGP: fprintf (fp, "Type: OpenPGP\n"); break; case KEYBOX_BLOBTYPE_X509: fprintf (fp, "Type: X.509\n"); break; default: fprintf (fp, "Type: %d\n", type); fprintf (fp, "[can't dump this blob type]\n"); return 0; } fprintf (fp, "Version: %d\n", buffer[5]); if (length < 40) { fprintf (fp, "[blob too short]\n"); return -1; } n = get16 (buffer + 6); fprintf( fp, "Blob-Flags: %04lX", n); if (n) { int any = 0; fputs (" (", fp); if ((n & 1)) { fputs ("secret", fp); any++; } if ((n & 2)) { if (any) putc (',', fp); fputs ("ephemeral", fp); any++; } putc (')', fp); } putc ('\n', fp); rawdata_off = get32 (buffer + 8); rawdata_len = get32 (buffer + 12); fprintf( fp, "Data-Offset: %lu\n", rawdata_off ); fprintf( fp, "Data-Length: %lu\n", rawdata_len ); if (rawdata_off > length || rawdata_len > length || rawdata_off+rawdata_len > length || rawdata_len + 4 > length || rawdata_off+rawdata_len + 4 > length) fprintf (fp, "[Error: raw data larger than blob]\n"); unhashed = length - rawdata_off - rawdata_len; fprintf (fp, "Unhashed: %lu\n", unhashed); nkeys = get16 (buffer + 16); fprintf (fp, "Key-Count: %lu\n", nkeys ); if (!nkeys) fprintf (fp, "[Error: no keys]\n"); if (nkeys > 1 && type == KEYBOX_BLOBTYPE_X509) fprintf (fp, "[Error: only one key allowed for X509]\n"); keyinfolen = get16 (buffer + 18 ); fprintf (fp, "Key-Info-Length: %lu\n", keyinfolen); /* fixme: check bounds */ p = buffer + 20; for (n=0; n < nkeys; n++, p += keyinfolen) { ulong kidoff, kflags; fprintf (fp, "Key-Fpr[%lu]: ", n ); for (i=0; i < 20; i++ ) fprintf (fp, "%02X", p[i]); kidoff = get32 (p + 20); fprintf (fp, "\nKey-Kid-Off[%lu]: %lu\n", n, kidoff ); fprintf (fp, "Key-Kid[%lu]: ", n ); /* fixme: check bounds */ for (i=0; i < 8; i++ ) fprintf (fp, "%02X", buffer[kidoff+i] ); kflags = get16 (p + 24 ); fprintf( fp, "\nKey-Flags[%lu]: %04lX\n", n, kflags); } /* serial number */ fputs ("Serial-No: ", fp); nserial = get16 (p); p += 2; if (!nserial) fputs ("none", fp); else { for (; nserial; nserial--, p++) fprintf (fp, "%02X", *p); } putc ('\n', fp); /* user IDs */ nuids = get16 (p); fprintf (fp, "Uid-Count: %lu\n", nuids ); uidinfolen = get16 (p + 2); fprintf (fp, "Uid-Info-Length: %lu\n", uidinfolen); /* fixme: check bounds */ p += 4; for (n=0; n < nuids; n++, p += uidinfolen) { ulong uidoff, uidlen, uflags; uidoff = get32( p ); uidlen = get32( p+4 ); if (type == KEYBOX_BLOBTYPE_X509 && !n) { fprintf (fp, "Issuer-Off: %lu\n", uidoff ); fprintf (fp, "Issuer-Len: %lu\n", uidlen ); fprintf (fp, "Issuer: \""); } else if (type == KEYBOX_BLOBTYPE_X509 && n == 1) { fprintf (fp, "Subject-Off: %lu\n", uidoff ); fprintf (fp, "Subject-Len: %lu\n", uidlen ); fprintf (fp, "Subject: \""); } else { fprintf (fp, "Uid-Off[%lu]: %lu\n", n, uidoff ); fprintf (fp, "Uid-Len[%lu]: %lu\n", n, uidlen ); fprintf (fp, "Uid[%lu]: \"", n ); } print_string (fp, buffer+uidoff, uidlen, '\"'); fputs ("\"\n", fp); uflags = get16 (p + 8); if (type == KEYBOX_BLOBTYPE_X509 && !n) { fprintf (fp, "Issuer-Flags: %04lX\n", uflags ); fprintf (fp, "Issuer-Validity: %d\n", p[10] ); } else if (type == KEYBOX_BLOBTYPE_X509 && n == 1) { fprintf (fp, "Subject-Flags: %04lX\n", uflags ); fprintf (fp, "Subject-Validity: %d\n", p[10] ); } else { fprintf (fp, "Uid-Flags[%lu]: %04lX\n", n, uflags ); fprintf (fp, "Uid-Validity[%lu]: %d\n", n, p[10] ); } } nsigs = get16 (p); fprintf (fp, "Sig-Count: %lu\n", nsigs ); siginfolen = get16 (p + 2); fprintf (fp, "Sig-Info-Length: %lu\n", siginfolen ); /* fixme: check bounds */ p += 4; { int in_range = 0; ulong first = 0; for (n=0; n < nsigs; n++, p += siginfolen) { ulong sflags; sflags = get32 (p); if (!in_range && !sflags) { in_range = 1; first = n; continue; } if (in_range && !sflags) continue; if (in_range) { fprintf (fp, "Sig-Expire[%lu-%lu]: [not checked]\n", first, n-1); in_range = 0; } fprintf (fp, "Sig-Expire[%lu]: ", n ); if (!sflags) fputs ("[not checked]", fp); else if (sflags == 1 ) fputs ("[missing key]", fp); else if (sflags == 2 ) fputs ("[bad signature]", fp); else if (sflags < 0x10000000) fprintf (fp, "[bad flag %0lx]", sflags); else if (sflags == (ulong)(-1)) fputs ("[good - does not expire]", fp ); else fprintf (fp, "[good - expires at %lu]", sflags); putc ('\n', fp ); } if (in_range) { fprintf (fp, "Sig-Expire[%lu-%lu]: [not checked]\n", first, n-1); in_range = 0; } } fprintf (fp, "Ownertrust: %d\n", p[0] ); fprintf (fp, "All-Validity: %d\n", p[1] ); p += 4; n = get32 (p); p += 4; fprintf (fp, "Recheck-After: %lu\n", n ); n = get32 (p ); p += 4; fprintf( fp, "Latest-Timestamp: %lu\n", n ); n = get32 (p ); p += 4; fprintf (fp, "Created-At: %lu\n", n ); n = get32 (p ); p += 4; fprintf (fp, "Reserved-Space: %lu\n", n ); if (n >= 4 && unhashed >= 24) { n = get32 ( buffer + length - unhashed); fprintf (fp, "Storage-Flags: %08lx\n", n ); } print_checksum (buffer, length, unhashed, fp); return 0; }