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;
}
