static void __init of_selftest_match_node(void) { struct device_node *np; const struct of_device_id *match; int i; for (i = 0; i < ARRAY_SIZE(match_node_tests); i++) { np = of_find_node_by_path(match_node_tests[i].path); if (!np) { selftest(0, "missing testcase node %s\n", match_node_tests[i].path); continue; } match = of_match_node(match_node_table, np); if (!match) { selftest(0, "%s didn't match anything\n", match_node_tests[i].path); continue; } if (strcmp(match->data, match_node_tests[i].data) != 0) { selftest(0, "%s got wrong match. expected %s, got %s\n", match_node_tests[i].path, match_node_tests[i].data, (const char *)match->data); continue; } selftest(1, "passed"); } }
static void run() { MBED_HOSTTEST_TIMEOUT(40); MBED_HOSTTEST_SELECT(default); MBED_HOSTTEST_DESCRIPTION(mbed TLS selftest program); MBED_HOSTTEST_START("MBEDTLS_SELFTEST"); MBED_HOSTTEST_RESULT(selftest(0, NULL) == 0); }
static void __init of_selftest_property_match_string(void) { struct device_node *np; int rc; np = of_find_node_by_path("/testcase-data/phandle-tests/consumer-a"); if (!np) { pr_err("No testcase data in device tree\n"); return; } rc = of_property_match_string(np, "phandle-list-names", "first"); selftest(rc == 0, "first expected:0 got:%i\n", rc); rc = of_property_match_string(np, "phandle-list-names", "second"); selftest(rc == 1, "second expected:0 got:%i\n", rc); rc = of_property_match_string(np, "phandle-list-names", "third"); selftest(rc == 2, "third expected:0 got:%i\n", rc); rc = of_property_match_string(np, "phandle-list-names", "fourth"); selftest(rc == -ENODATA, "unmatched string; rc=%i", rc); rc = of_property_match_string(np, "missing-property", "blah"); selftest(rc == -EINVAL, "missing property; rc=%i", rc); rc = of_property_match_string(np, "empty-property", "blah"); selftest(rc == -ENODATA, "empty property; rc=%i", rc); rc = of_property_match_string(np, "unterminated-string", "blah"); selftest(rc == -EILSEQ, "unterminated string; rc=%i", rc); }
static gcry_err_code_t salsa20_do_setkey (SALSA20_context_t *ctx, const byte *key, unsigned int keylen) { static int initialized; static const char *selftest_failed; if (!initialized ) { initialized = 1; selftest_failed = selftest (); if (selftest_failed) log_error ("SALSA20 selftest failed (%s)\n", selftest_failed ); } if (selftest_failed) return GPG_ERR_SELFTEST_FAILED; if (keylen != SALSA20_MIN_KEY_SIZE && keylen != SALSA20_MAX_KEY_SIZE) return GPG_ERR_INV_KEYLEN; /* These constants are the little endian encoding of the string "expand 32-byte k". For the 128 bit variant, the "32" in that string will be fixed up to "16". */ ctx->input[0] = 0x61707865; /* "apxe" */ ctx->input[5] = 0x3320646e; /* "3 dn" */ ctx->input[10] = 0x79622d32; /* "yb-2" */ ctx->input[15] = 0x6b206574; /* "k et" */ ctx->input[1] = LE_READ_UINT32(key + 0); ctx->input[2] = LE_READ_UINT32(key + 4); ctx->input[3] = LE_READ_UINT32(key + 8); ctx->input[4] = LE_READ_UINT32(key + 12); if (keylen == SALSA20_MAX_KEY_SIZE) /* 256 bits */ { ctx->input[11] = LE_READ_UINT32(key + 16); ctx->input[12] = LE_READ_UINT32(key + 20); ctx->input[13] = LE_READ_UINT32(key + 24); ctx->input[14] = LE_READ_UINT32(key + 28); } else /* 128 bits */ { ctx->input[11] = ctx->input[1]; ctx->input[12] = ctx->input[2]; ctx->input[13] = ctx->input[3]; ctx->input[14] = ctx->input[4]; ctx->input[5] -= 0x02000000; /* Change to "1 dn". */ ctx->input[10] += 0x00000004; /* Change to "yb-6". */ } /* We default to a zero nonce. */ salsa20_setiv (ctx, NULL, 0); return 0; }
static void run() { /* Use 115200 bps for consistency with other examples */ Serial pc(USBTX, USBRX); pc.baud(115200); MBED_HOSTTEST_TIMEOUT(40); MBED_HOSTTEST_SELECT(default); MBED_HOSTTEST_DESCRIPTION(mbed TLS selftest program); MBED_HOSTTEST_START("MBEDTLS_SELFTEST"); MBED_HOSTTEST_RESULT(selftest(0, NULL) == 0); }
static gcry_err_code_t camellia_setkey(void *c, const byte *key, unsigned keylen) { CAMELLIA_context *ctx=c; static int initialized=0; static const char *selftest_failed=NULL; #if defined(USE_AESNI_AVX) || defined(USE_AESNI_AVX2) unsigned int hwf = _gcry_get_hw_features (); #endif if(keylen!=16 && keylen!=24 && keylen!=32) return GPG_ERR_INV_KEYLEN; if(!initialized) { initialized=1; selftest_failed=selftest(); if(selftest_failed) log_error("%s\n",selftest_failed); } if(selftest_failed) return GPG_ERR_SELFTEST_FAILED; #ifdef USE_AESNI_AVX ctx->use_aesni_avx = (hwf & HWF_INTEL_AESNI) && (hwf & HWF_INTEL_AVX); #endif #ifdef USE_AESNI_AVX2 ctx->use_aesni_avx2 = (hwf & HWF_INTEL_AESNI) && (hwf & HWF_INTEL_AVX2); #endif ctx->keybitlength=keylen*8; if (0) { } #ifdef USE_AESNI_AVX else if (ctx->use_aesni_avx) _gcry_camellia_aesni_avx_keygen(ctx, key, keylen); else #endif { Camellia_Ekeygen(ctx->keybitlength,key,ctx->keytable); _gcry_burn_stack ((19+34+34)*sizeof(u32)+2*sizeof(void*) /* camellia_setup256 */ +(4+32)*sizeof(u32)+2*sizeof(void*) /* camellia_setup192 */ +0+sizeof(int)+2*sizeof(void*) /* Camellia_Ekeygen */ +3*2*sizeof(void*) /* Function calls. */ ); } return 0; }
/** * Initializes LIS2DH12, and puts it in sleep mode. * */ lis2dh12_ret_t lis2dh12_init(void) { lis2dh12_ret_t err_code = LIS2DH12_RET_OK; /* Initialize SPI */ if (false == spi_isInitialized()){ spi_init(); } /** Reboot memory - causes FIFO to fail - maybe delay is needed before enabling axes? **/ //err_code |= lis2dh12_reset(); /* Start Selftest */ err_code |= selftest(); return err_code; }
static gcry_err_code_t salsa20_do_setkey (SALSA20_context_t *ctx, const byte *key, unsigned int keylen) { static int initialized; static const char *selftest_failed; if (!initialized ) { initialized = 1; selftest_failed = selftest (); if (selftest_failed) log_error ("SALSA20 selftest failed (%s)\n", selftest_failed ); } if (selftest_failed) return GPG_ERR_SELFTEST_FAILED; if (keylen != SALSA20_MIN_KEY_SIZE && keylen != SALSA20_MAX_KEY_SIZE) return GPG_ERR_INV_KEYLEN; /* Default ops. */ ctx->keysetup = salsa20_keysetup; ctx->ivsetup = salsa20_ivsetup; ctx->core = salsa20_core; #ifdef USE_ARM_NEON_ASM ctx->use_neon = (_gcry_get_hw_features () & HWF_ARM_NEON) != 0; if (ctx->use_neon) { /* Use ARM NEON ops instead. */ ctx->keysetup = salsa20_keysetup_neon; ctx->ivsetup = salsa20_ivsetup_neon; ctx->core = salsa20_core_neon; } #endif ctx->keysetup (ctx, key, keylen); /* We default to a zero nonce. */ salsa20_setiv (ctx, NULL, 0); return 0; }
static gcry_err_code_t do_arcfour_setkey (void *context, const byte *key, unsigned int keylen) { static int initialized; static const char* selftest_failed; int i, j; byte karr[256]; ARCFOUR_context *ctx = (ARCFOUR_context *) context; if (!initialized ) { initialized = 1; selftest_failed = selftest(); if( selftest_failed ) log_error ("ARCFOUR selftest failed (%s)\n", selftest_failed ); } if( selftest_failed ) return GPG_ERR_SELFTEST_FAILED; if( keylen < 40/8 ) /* we want at least 40 bits */ return GPG_ERR_INV_KEYLEN; ctx->idx_i = ctx->idx_j = 0; for (i=0; i < 256; i++ ) ctx->sbox[i] = i; for (i=j=0; i < 256; i++,j++ ) { if (j >= keylen) j = 0; karr[i] = key[j]; } for (i=j=0; i < 256; i++ ) { int t; j = (j + ctx->sbox[i] + karr[i]) & 255; t = ctx->sbox[i]; ctx->sbox[i] = ctx->sbox[j]; ctx->sbox[j] = t; } wipememory( karr, sizeof(karr) ); return GPG_ERR_NO_ERROR; }
void *thread_selftest (void *p) { thread_param_t *thread_param = (thread_param_t *) p; hashcat_ctx_t *hashcat_ctx = thread_param->hashcat_ctx; opencl_ctx_t *opencl_ctx = hashcat_ctx->opencl_ctx; if (opencl_ctx->enabled == false) return NULL; user_options_t *user_options = hashcat_ctx->user_options; if (user_options->self_test_disable == true) return NULL; hc_device_param_t *device_param = opencl_ctx->devices_param + thread_param->tid; if (device_param->skipped == true) return NULL; const int rc_selftest = selftest (hashcat_ctx, device_param); if (user_options->benchmark == true) { device_param->st_status = ST_STATUS_IGNORED; } else { if (rc_selftest == 0) { device_param->st_status = ST_STATUS_PASSED; } else { device_param->st_status = ST_STATUS_FAILED; } } return NULL; }
int main (int argc, char **argv) { const char *pgm; int last_argc = -1; const char *key; size_t keylen; FILE *fp; hmac256_context_t hd; const unsigned char *digest; char buffer[4096]; size_t n, dlen, idx; int use_stdin = 0; int use_binary = 0; assert (sizeof (u32) == 4); #ifdef __WIN32 setmode (fileno (stdin), O_BINARY); #endif if (argc) { pgm = strrchr (*argv, '/'); if (pgm) pgm++; else pgm = *argv; argc--; argv++; } else pgm = "?"; while (argc && last_argc != argc ) { last_argc = argc; if (!strcmp (*argv, "--")) { argc--; argv++; break; } else if (!strcmp (*argv, "--version")) { fputs ("hmac256 (Libgcrypt) " VERSION "\n" "Copyright (C) 2008 Free Software Foundation, Inc.\n" "License LGPLv2.1+: GNU LGPL version 2.1 or later " "<http://gnu.org/licenses/old-licenses/lgpl-2.1.html>\n" "This is free software: you are free to change and " "redistribute it.\n" "There is NO WARRANTY, to the extent permitted by law.\n", stdout); exit (0); } else if (!strcmp (*argv, "--binary")) { argc--; argv++; use_binary = 1; } } if (argc < 1) { fprintf (stderr, "usage: %s [--binary] key [filename]\n", pgm); exit (1); } #ifdef __WIN32 if (use_binary) setmode (fileno (stdout), O_BINARY); #endif key = *argv; argc--, argv++; keylen = strlen (key); use_stdin = !argc; if (selftest ()) { fprintf (stderr, "%s: fatal error: self-test failed\n", pgm); exit (2); } for (; argc || use_stdin; argv++, argc--) { const char *fname = use_stdin? "-" : *argv; fp = use_stdin? stdin : fopen (fname, "rb"); if (!fp) { fprintf (stderr, "%s: can't open `%s': %s\n", pgm, fname, strerror (errno)); exit (1); } hd = _gcry_hmac256_new (key, keylen); if (!hd) { fprintf (stderr, "%s: can't allocate context: %s\n", pgm, strerror (errno)); exit (1); } while ( (n = fread (buffer, 1, sizeof buffer, fp))) _gcry_hmac256_update (hd, buffer, n); if (ferror (fp)) { fprintf (stderr, "%s: error reading `%s': %s\n", pgm, fname, strerror (errno)); exit (1); } if (!use_stdin) fclose (fp); digest = _gcry_hmac256_finalize (hd, &dlen); if (!digest) { fprintf (stderr, "%s: error computing HMAC: %s\n", pgm, strerror (errno)); exit (1); } if (use_binary) { if (fwrite (digest, dlen, 1, stdout) != 1) { fprintf (stderr, "%s: error writing output: %s\n", pgm, strerror (errno)); exit (1); } if (use_stdin) break; } else { for (idx=0; idx < dlen; idx++) printf ("%02x", digest[idx]); _gcry_hmac256_release (hd); if (use_stdin) { putchar ('\n'); break; } printf (" %s\n", fname); } } return 0; }
int main(int argc, char *argv[]) { int fd; int count = 0; unsigned int addr = 0; unsigned char data[32] = {0}; int ret; spi_rdwr sopt; if (argc != 2 && argc != 4) { usage(); return 0; } fd = open("/dev/spidev0.0", O_RDWR); if (fd == -1) { printf("dpll file open failed.\n"); return -1; } if (argc == 2 && argv[1][0] == 't') { selftest(fd); } else if (argc == 4 && argv[1][0] == 'r') { sopt.cs = 0; sscanf(argv[2], "%hx", &sopt.addr); sscanf(argv[3], "%hd", &sopt.len); printf("read %d bytes at 0x%04x:", sopt.len, (unsigned short)sopt.addr); if (read(fd, &sopt, 0) == sopt.len) { pdata(sopt.buff, sopt.len); printf(" done\n"); } else { printf(" error\n"); } } else if (argc == 4 && argv[1][0] == 'w') { sopt.cs = 0; sscanf(argv[2], "%hx", &sopt.addr); sopt.len = strlen(argv[3]); if (count % 2 != 0) { printf("error: unaligned byte:hex\n"); } else { int i; char *cp; unsigned char tmp; cp = argv[3]; for(i = 0; *cp; i++, cp++) { tmp = *cp - '0'; if(tmp > 9) tmp -= ('A' - '0') - 10; if(tmp > 15) tmp -= ('a' - 'A'); if(tmp > 15) { printf("Hex conversion error on %c, mark as 0.\n", *cp); tmp = 0; } if((i % 2) == 0) sopt.buff[i / 2] = (tmp << 4); else sopt.buff[i / 2] |= tmp; } sopt.len >>= 1; printf("write %d bytes at 0x%04x:", sopt.len, (unsigned short)sopt.addr); pdata(sopt.buff, sopt.len); if (write(fd, &sopt, 0) == sopt.len) printf(" done\n"); else printf(" error\n"); } }
static void __init of_selftest_parse_phandle_with_args(void) { struct device_node *np; struct of_phandle_args args; int i, rc; np = of_find_node_by_path("/testcase-data/phandle-tests/consumer-a"); if (!np) { pr_err("missing testcase data\n"); return; } rc = of_count_phandle_with_args(np, "phandle-list", "#phandle-cells"); selftest(rc == 7, "of_count_phandle_with_args() returned %i, expected 7\n", rc); for (i = 0; i < 8; i++) { bool passed = true; rc = of_parse_phandle_with_args(np, "phandle-list", "#phandle-cells", i, &args); /* Test the values from tests-phandle.dtsi */ switch (i) { case 0: passed &= !rc; passed &= (args.args_count == 1); passed &= (args.args[0] == (i + 1)); break; case 1: passed &= !rc; passed &= (args.args_count == 2); passed &= (args.args[0] == (i + 1)); passed &= (args.args[1] == 0); break; case 2: passed &= (rc == -ENOENT); break; case 3: passed &= !rc; passed &= (args.args_count == 3); passed &= (args.args[0] == (i + 1)); passed &= (args.args[1] == 4); passed &= (args.args[2] == 3); break; case 4: passed &= !rc; passed &= (args.args_count == 2); passed &= (args.args[0] == (i + 1)); passed &= (args.args[1] == 100); break; case 5: passed &= !rc; passed &= (args.args_count == 0); break; case 6: passed &= !rc; passed &= (args.args_count == 1); passed &= (args.args[0] == (i + 1)); break; case 7: passed &= (rc == -ENOENT); break; default: passed = false; } selftest(passed, "index %i - data error on node %s rc=%i\n", i, args.np->full_name, rc); } /* Check for missing list property */ rc = of_parse_phandle_with_args(np, "phandle-list-missing", "#phandle-cells", 0, &args); selftest(rc == -ENOENT, "expected:%i got:%i\n", -ENOENT, rc); rc = of_count_phandle_with_args(np, "phandle-list-missing", "#phandle-cells"); selftest(rc == -ENOENT, "expected:%i got:%i\n", -ENOENT, rc); /* Check for missing cells property */ rc = of_parse_phandle_with_args(np, "phandle-list", "#phandle-cells-missing", 0, &args); selftest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc); rc = of_count_phandle_with_args(np, "phandle-list", "#phandle-cells-missing"); selftest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc); /* Check for bad phandle in list */ rc = of_parse_phandle_with_args(np, "phandle-list-bad-phandle", "#phandle-cells", 0, &args); selftest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc); rc = of_count_phandle_with_args(np, "phandle-list-bad-phandle", "#phandle-cells"); selftest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc); /* Check for incorrectly formed argument list */ rc = of_parse_phandle_with_args(np, "phandle-list-bad-args", "#phandle-cells", 1, &args); selftest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc); rc = of_count_phandle_with_args(np, "phandle-list-bad-args", "#phandle-cells"); selftest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc); }
static void __init of_selftest_parse_interrupts_extended(void) { struct device_node *np; struct of_phandle_args args; int i, rc; np = of_find_node_by_path("/testcase-data/interrupts/interrupts-extended0"); if (!np) { pr_err("missing testcase data\n"); return; } for (i = 0; i < 7; i++) { bool passed = true; rc = of_irq_parse_one(np, i, &args); /* Test the values from tests-phandle.dtsi */ switch (i) { case 0: passed &= !rc; passed &= (args.args_count == 1); passed &= (args.args[0] == 1); break; case 1: passed &= !rc; passed &= (args.args_count == 3); passed &= (args.args[0] == 2); passed &= (args.args[1] == 3); passed &= (args.args[2] == 4); break; case 2: passed &= !rc; passed &= (args.args_count == 2); passed &= (args.args[0] == 5); passed &= (args.args[1] == 6); break; case 3: passed &= !rc; passed &= (args.args_count == 1); passed &= (args.args[0] == 9); break; case 4: passed &= !rc; passed &= (args.args_count == 3); passed &= (args.args[0] == 10); passed &= (args.args[1] == 11); passed &= (args.args[2] == 12); break; case 5: passed &= !rc; passed &= (args.args_count == 2); passed &= (args.args[0] == 13); passed &= (args.args[1] == 14); break; case 6: passed &= !rc; passed &= (args.args_count == 1); passed &= (args.args[0] == 15); break; default: passed = false; } selftest(passed, "index %i - data error on node %s rc=%i\n", i, args.np->full_name, rc); } of_node_put(np); }
int main(int argc, char* argv[]) { int c; struct snapraid_option opt; char conf[PATH_MAX]; struct snapraid_state state; int operation; block_off_t blockstart; block_off_t blockcount; int ret; tommy_list filterlist_file; tommy_list filterlist_disk; int filter_missing; int filter_error; int plan; int olderthan; char* e; const char* command; const char* import_timestamp; const char* import_content; const char* log_file; int lock; const char* gen_conf; const char* run; int speedtest; int period; time_t t; struct tm* tm; int i; /* defaults */ config(conf, sizeof(conf), argv[0]); memset(&opt, 0, sizeof(opt)); opt.io_error_limit = 100; blockstart = 0; blockcount = 0; tommy_list_init(&filterlist_file); tommy_list_init(&filterlist_disk); period = 1000; filter_missing = 0; filter_error = 0; plan = SCRUB_AUTO; olderthan = SCRUB_AUTO; import_timestamp = 0; import_content = 0; log_file = 0; lock = 0; gen_conf = 0; speedtest = 0; run = 0; opterr = 0; while ((c = #if HAVE_GETOPT_LONG getopt_long(argc, argv, OPTIONS, long_options, 0)) #else getopt(argc, argv, OPTIONS)) #endif != EOF) { switch (c) { case 'c' : pathimport(conf, sizeof(conf), optarg); break; case 'f' : { struct snapraid_filter* filter = filter_alloc_file(1, optarg); if (!filter) { /* LCOV_EXCL_START */ log_fatal("Invalid filter specification '%s'\n", optarg); log_fatal("Filters using relative paths are not supported. Ensure to add an initial slash\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } tommy_list_insert_tail(&filterlist_file, &filter->node, filter); } break; case 'd' : { struct snapraid_filter* filter = filter_alloc_disk(1, optarg); if (!filter) { /* LCOV_EXCL_START */ log_fatal("Invalid filter specification '%s'\n", optarg); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } tommy_list_insert_tail(&filterlist_disk, &filter->node, filter); } break; case 'm' : filter_missing = 1; opt.expected_missing = 1; break; case 'e' : /* when processing only error, we filter both files and blocks */ /* and we apply fixes only to synced ones */ filter_error = 1; opt.badonly = 1; opt.syncedonly = 1; break; case 'p' : if (strcmp(optarg, "bad") == 0) { plan = SCRUB_BAD; } else if (strcmp(optarg, "new") == 0) { plan = SCRUB_NEW; } else if (strcmp(optarg, "full") == 0) { plan = SCRUB_FULL; } else { plan = strtoul(optarg, &e, 10); if (!e || *e || plan > 100) { /* LCOV_EXCL_START */ log_fatal("Invalid plan/percentage '%s'\n", optarg); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } } break; case 'o' : olderthan = strtoul(optarg, &e, 10); if (!e || *e || olderthan > 1000) { /* LCOV_EXCL_START */ log_fatal("Invalid number of days '%s'\n", optarg); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } break; case 'S' : blockstart = strtoul(optarg, &e, 0); if (!e || *e) { /* LCOV_EXCL_START */ log_fatal("Invalid start position '%s'\n", optarg); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } break; case 'B' : blockcount = strtoul(optarg, &e, 0); if (!e || *e) { /* LCOV_EXCL_START */ log_fatal("Invalid count number '%s'\n", optarg); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } break; case 'L' : opt.io_error_limit = strtoul(optarg, &e, 0); if (!e || *e) { /* LCOV_EXCL_START */ log_fatal("Invalid error limit number '%s'\n", optarg); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } break; case 'i' : if (import_timestamp) { /* LCOV_EXCL_START */ log_fatal("Import directory '%s' already specified as '%s'\n", optarg, import_timestamp); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } import_timestamp = optarg; break; case OPT_TEST_IMPORT_CONTENT : if (import_content) { /* LCOV_EXCL_START */ log_fatal("Import directory '%s' already specified as '%s'\n", optarg, import_content); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } import_content = optarg; break; case 'l' : if (log_file) { /* LCOV_EXCL_START */ log_fatal("Log file '%s' already specified as '%s'\n", optarg, log_file); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } log_file = optarg; break; case 'Z' : opt.force_zero = 1; break; case 'E' : opt.force_empty = 1; break; case 'U' : opt.force_uuid = 1; break; case 'D' : opt.force_device = 1; break; case 'N' : opt.force_nocopy = 1; break; case 'F' : opt.force_full = 1; break; case 'a' : opt.auditonly = 1; break; case 'h' : opt.prehash = 1; break; case 'v' : ++msg_level; break; case 'q' : --msg_level; break; case 'G' : opt.gui = 1; break; case 'H' : usage(); exit(EXIT_SUCCESS); case 'V' : version(); exit(EXIT_SUCCESS); case 'T' : speedtest = 1; break; case 'C' : gen_conf = optarg; break; case OPT_TEST_KILL_AFTER_SYNC : opt.kill_after_sync = 1; break; case OPT_TEST_EXPECT_UNRECOVERABLE : opt.expect_unrecoverable = 1; break; case OPT_TEST_EXPECT_RECOVERABLE : opt.expect_recoverable = 1; break; case OPT_TEST_SKIP_SELF : opt.skip_self = 1; break; case OPT_TEST_SKIP_SIGN : opt.skip_sign = 1; break; case OPT_TEST_SKIP_FALLOCATE : opt.skip_fallocate = 1; break; case OPT_TEST_SKIP_SEQUENTIAL : opt.skip_sequential = 1; break; case OPT_TEST_SKIP_DEVICE : opt.skip_device = 1; period = 50; /* reduce period of the speed test */ break; case OPT_TEST_SKIP_CONTENT_CHECK : opt.skip_content_check = 1; break; case OPT_TEST_SKIP_PARITY_ACCESS : opt.skip_parity_access = 1; break; case OPT_TEST_SKIP_DISK_ACCESS : opt.skip_disk_access = 1; break; case OPT_TEST_FORCE_MURMUR3 : opt.force_murmur3 = 1; break; case OPT_TEST_FORCE_SPOOKY2 : opt.force_spooky2 = 1; break; case OPT_TEST_SKIP_LOCK : opt.skip_lock = 1; break; case OPT_TEST_FORCE_ORDER_PHYSICAL : opt.force_order = SORT_PHYSICAL; break; case OPT_TEST_FORCE_ORDER_INODE : opt.force_order = SORT_INODE; break; case OPT_TEST_FORCE_ORDER_ALPHA : opt.force_order = SORT_ALPHA; break; case OPT_TEST_FORCE_ORDER_DIR : opt.force_order = SORT_DIR; break; case OPT_TEST_FORCE_SCRUB_AT : opt.force_scrub_at = atoi(optarg); break; case OPT_TEST_FORCE_SCRUB_EVEN : opt.force_scrub_even = 1; break; case OPT_TEST_FORCE_CONTENT_WRITE : opt.force_content_write = 1; break; case OPT_TEST_EXPECT_FAILURE : /* invert the exit codes */ exit_success = 1; exit_failure = 0; break; case OPT_TEST_EXPECT_NEED_SYNC : /* invert the exit codes */ exit_success = 1; exit_sync_needed = 0; break; case OPT_TEST_RUN : run = optarg; break; case OPT_TEST_FORCE_SCAN_WINFIND : opt.force_scan_winfind = 1; break; case OPT_TEST_FORCE_PROGRESS : opt.force_progress = 1; break; case OPT_TEST_FORCE_AUTOSAVE_AT : opt.force_autosave_at = atoi(optarg); break; case OPT_TEST_FAKE_DEVICE : opt.fake_device = 1; break; case OPT_NO_WARNINGS : opt.no_warnings = 1; break; default : /* LCOV_EXCL_START */ log_fatal("Unknown option '%c'\n", (char)c); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } } os_init(opt.force_scan_winfind); raid_init(); crc32c_init(); if (speedtest != 0) { speed(period); os_done(); exit(EXIT_SUCCESS); } if (gen_conf != 0) { generate_configuration(gen_conf); os_done(); exit(EXIT_SUCCESS); } if (optind + 1 != argc) { /* LCOV_EXCL_START */ usage(); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } command = argv[optind]; if (strcmp(command, "diff") == 0) { operation = OPERATION_DIFF; } else if (strcmp(argv[optind], "sync") == 0) { operation = OPERATION_SYNC; } else if (strcmp(argv[optind], "check") == 0) { operation = OPERATION_CHECK; } else if (strcmp(argv[optind], "fix") == 0) { operation = OPERATION_FIX; } else if (strcmp(argv[optind], "test-dry") == 0) { operation = OPERATION_DRY; } else if (strcmp(argv[optind], "dup") == 0) { operation = OPERATION_DUP; } else if (strcmp(argv[optind], "list") == 0) { operation = OPERATION_LIST; } else if (strcmp(argv[optind], "pool") == 0) { operation = OPERATION_POOL; } else if (strcmp(argv[optind], "rehash") == 0) { operation = OPERATION_REHASH; } else if (strcmp(argv[optind], "scrub") == 0) { operation = OPERATION_SCRUB; } else if (strcmp(argv[optind], "status") == 0) { operation = OPERATION_STATUS; } else if (strcmp(argv[optind], "test-rewrite") == 0) { operation = OPERATION_REWRITE; } else if (strcmp(argv[optind], "test-read") == 0) { operation = OPERATION_READ; } else if (strcmp(argv[optind], "test-nano") == 0) { operation = OPERATION_NANO; } else if (strcmp(argv[optind], "up") == 0) { operation = OPERATION_SPINUP; } else if (strcmp(argv[optind], "down") == 0) { operation = OPERATION_SPINDOWN; } else if (strcmp(argv[optind], "devices") == 0) { operation = OPERATION_DEVICES; } else if (strcmp(argv[optind], "smart") == 0) { operation = OPERATION_SMART; } else { /* LCOV_EXCL_START */ log_fatal("Unknown command '%s'\n", argv[optind]); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } /* check options compatibility */ switch (operation) { case OPERATION_CHECK : break; default : if (opt.auditonly) { /* LCOV_EXCL_START */ log_fatal("You cannot use -a, --audit-only with the '%s' command\n", command); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } } switch (operation) { case OPERATION_FIX : break; default : if (opt.force_device) { /* LCOV_EXCL_START */ log_fatal("You cannot use -D, --force-device with the '%s' command\n", command); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } } switch (operation) { case OPERATION_SYNC : case OPERATION_CHECK : case OPERATION_FIX : break; default : if (opt.force_nocopy) { /* LCOV_EXCL_START */ log_fatal("You cannot use -N, --force-nocopy with the '%s' command\n", command); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } } switch (operation) { case OPERATION_SYNC : break; default : if (opt.prehash) { /* LCOV_EXCL_START */ log_fatal("You cannot use -h, --pre-hash with the '%s' command\n", command); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (opt.force_full) { /* LCOV_EXCL_START */ log_fatal("You cannot use -F, --force-full with the '%s' command\n", command); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } } if (opt.force_full && opt.force_nocopy) { /* LCOV_EXCL_START */ log_fatal("You cannot use the -F, --force-full and -N, --force-nocopy options at the same time\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (opt.prehash && opt.force_nocopy) { /* LCOV_EXCL_START */ log_fatal("You cannot use the -h, --pre-hash and -N, --force-nocopy options at the same time\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } switch (operation) { case OPERATION_CHECK : case OPERATION_FIX : case OPERATION_DRY : break; default : if (!tommy_list_empty(&filterlist_file)) { /* LCOV_EXCL_START */ log_fatal("You cannot use -f, --filter with the '%s' command\n", command); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (!tommy_list_empty(&filterlist_disk)) { /* LCOV_EXCL_START */ log_fatal("You cannot use -d, --filter-disk with the '%s' command\n", command); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (filter_missing != 0) { /* LCOV_EXCL_START */ log_fatal("You cannot use -m, --filter-missing with the '%s' command\n", command); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } if (filter_error != 0) { /* LCOV_EXCL_START */ log_fatal("You cannot use -e, --filter-error with the '%s' command\n", command); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } } /* errors must be always fixed on all disks */ /* becasue we don't keep the information on what disk is the error */ if (filter_error != 0 && !tommy_list_empty(&filterlist_disk)) { /* LCOV_EXCL_START */ log_fatal("You cannot use -e, --filter-error and -d, --filter-disk at the same time\n"); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } switch (operation) { case OPERATION_CHECK : case OPERATION_FIX : break; default : if (import_timestamp != 0 || import_content != 0) { /* LCOV_EXCL_START */ log_fatal("You cannot import with the '%s' command\n", command); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } } switch (operation) { case OPERATION_LIST : case OPERATION_DUP : case OPERATION_STATUS : case OPERATION_REWRITE : case OPERATION_READ : case OPERATION_REHASH : case OPERATION_SPINUP : /* we want to do it in different threads to avoid blocking */ /* avoid to check and access data disks if not needed */ opt.skip_disk_access = 1; break; } switch (operation) { case OPERATION_DIFF : case OPERATION_LIST : case OPERATION_DUP : case OPERATION_POOL : case OPERATION_STATUS : case OPERATION_REWRITE : case OPERATION_READ : case OPERATION_REHASH : case OPERATION_NANO : case OPERATION_SPINUP : /* we want to do it in different threads to avoid blocking */ /* avoid to check and access parity disks if not needed */ opt.skip_parity_access = 1; break; } switch (operation) { case OPERATION_FIX : case OPERATION_CHECK : /* avoid to stop processing if a content file is not accessible */ opt.skip_content_access = 1; break; } switch (operation) { case OPERATION_DIFF : case OPERATION_LIST : case OPERATION_DUP : case OPERATION_POOL : case OPERATION_NANO : case OPERATION_SPINUP : case OPERATION_SPINDOWN : case OPERATION_DEVICES : case OPERATION_SMART : opt.skip_self = 1; break; } switch (operation) { case OPERATION_DEVICES : case OPERATION_SMART : /* we may need to use these commands during operations */ opt.skip_lock = 1; break; } /* open the log file */ log_open(log_file); /* print generic info into the log */ t = time(0); tm = localtime(&t); log_tag("version:%s\n", PACKAGE_VERSION); log_tag("unixtime:%" PRIi64 "\n", (int64_t)t); if (tm) { char datetime[64]; strftime(datetime, sizeof(datetime), "%Y-%m-%d %H:%M:%S", tm); log_tag("time:%s\n", datetime); } log_tag("command:%s\n", command); for (i = 0; i < argc; ++i) log_tag("argv:%u:%s\n", i, argv[i]); log_flush(); if (!opt.skip_self) selftest(); state_init(&state); /* read the configuration file */ state_config(&state, conf, command, &opt, &filterlist_disk); /* set the raid mode */ raid_mode(state.raid_mode); #if HAVE_LOCKFILE /* create the lock file */ if (!opt.skip_lock && state.lockfile[0]) { lock = lock_lock(state.lockfile); if (lock == -1) { /* LCOV_EXCL_START */ if (errno != EWOULDBLOCK) { log_fatal("Error creating the lock file '%s'. %s.\n", state.lockfile, strerror(errno)); } else { log_fatal("The lock file '%s' is already locked!\n", state.lockfile); log_fatal("SnapRAID is already in use!\n"); } exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } } #else (void)lock; #endif if (operation == OPERATION_DIFF) { state_read(&state); ret = state_diff(&state); /* abort if sync needed */ if (ret > 0) exit(EXIT_SYNC_NEEDED); } else if (operation == OPERATION_SYNC) { /* in the next state read ensures to clear all the past hashes in case */ /* we are reading from an incomplete sync */ /* The undeterminated hash are only for CHG/DELETED blocks for which we don't */ /* know if the previous interrupted sync was able to update or not the parity. */ /* The sync process instead needs to trust this information because it's used */ /* to avoid to recompute the parity if all the input are equals as before. */ /* In these cases we don't know if the old state is still the one */ /* stored inside the parity, because after an aborted sync, the parity */ /* may be or may be not have been updated with the data that may be now */ /* deleted. Then we reset the hash to a bogus value. */ /* An example for CHG blocks is: */ /* - One file is added creating a CHG block with ZERO state */ /* - Sync aborted after updating the parity to the new state, */ /* but without saving the content file representing this new BLK state. */ /* - File is now deleted after the aborted sync */ /* - Sync again, deleting the blocks overt the CHG ones */ /* with the hash of CHG blocks not represeting the real parity state */ /* An example for DELETED blocks is: */ /* - One file is deleted creating DELETED blocks */ /* - Sync aborted after, updating the parity to the new state, */ /* but without saving the content file representing this new EMPTY state. */ /* - Another file is added again over the DELETE ones */ /* with the hash of DELETED blocks not represeting the real parity state */ state.clear_past_hash = 1; state_read(&state); state_scan(&state); /* refresh the size info before the content write */ state_refresh(&state); memory(); /* intercept signals while operating */ signal_init(); /* save the new state before the sync */ /* this allow to recover the case of the changes in the array after an aborted sync. */ /* for example, think at this case: */ /* - add some files at the array */ /* - run a sync command, it will recompute the parity adding the new files */ /* - abort the sync command before it stores the new content file */ /* - delete the not yet synced files from the array */ /* - run a new sync command */ /* the new sync command has now way to know that the parity file was modified */ /* because the files triggering these changes are now deleted */ /* and they aren't listed in the content file */ if (state.need_write) state_write(&state); /* run a test command if required */ if (run != 0) { ret = system(run); /* ignore error */ if (ret != 0) { /* LCOV_EXCL_START */ log_fatal("Error in running command '%s'.\n", run); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } } /* waits some time to ensure that any concurrent modification done at the files, */ /* using the same mtime read by the scan process, will be read by sync. */ /* Note that any later modification done, potentially not read by sync, will have */ /* a different mtime, and it will be syncronized at the next sync. */ /* The worst case is the FAT filesystem with a two seconds resolution for mtime. */ /* If you don't use FAT, the wait is not needed, because most filesystems have now */ /* at least microseconds resolution, but better to be safe. */ if (!opt.skip_self) sleep(2); ret = state_sync(&state, blockstart, blockcount); /* save the new state if required */ if (!opt.kill_after_sync && (state.need_write || state.opt.force_content_write)) state_write(&state); /* abort if required */ if (ret != 0) { /* LCOV_EXCL_START */ exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } } else if (operation == OPERATION_DRY) { state_read(&state); /* filter */ state_skip(&state); state_filter(&state, &filterlist_file, &filterlist_disk, filter_missing, filter_error); memory(); /* intercept signals while operating */ signal_init(); state_dry(&state, blockstart, blockcount); } else if (operation == OPERATION_REHASH) { state_read(&state); /* intercept signals while operating */ signal_init(); state_rehash(&state); /* save the new state if required */ if (state.need_write) state_write(&state); } else if (operation == OPERATION_SCRUB) { state_read(&state); memory(); /* intercept signals while operating */ signal_init(); ret = state_scrub(&state, plan, olderthan); /* save the new state if required */ if (state.need_write || state.opt.force_content_write) state_write(&state); /* abort if required */ if (ret != 0) { /* LCOV_EXCL_START */ exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } } else if (operation == OPERATION_REWRITE) { state_read(&state); /* intercept signals while operating */ signal_init(); state_write(&state); memory(); } else if (operation == OPERATION_READ) { state_read(&state); memory(); } else if (operation == OPERATION_NANO) { state_read(&state); state_nano(&state); /* intercept signals while operating */ signal_init(); state_write(&state); memory(); } else if (operation == OPERATION_SPINUP) { state_device(&state, DEVICE_UP); } else if (operation == OPERATION_SPINDOWN) { state_device(&state, DEVICE_DOWN); } else if (operation == OPERATION_DEVICES) { state_device(&state, DEVICE_LIST); } else if (operation == OPERATION_SMART) { state_device(&state, DEVICE_SMART); } else if (operation == OPERATION_STATUS) { state_read(&state); memory(); state_status(&state); } else if (operation == OPERATION_DUP) { state_read(&state); state_dup(&state); } else if (operation == OPERATION_LIST) { state_read(&state); state_list(&state); } else if (operation == OPERATION_POOL) { state_read(&state); state_pool(&state); } else { state_read(&state); /* if we are also trying to recover */ if (!state.opt.auditonly) { /* import the user specified dirs */ if (import_timestamp != 0) state_search(&state, import_timestamp); if (import_content != 0) state_import(&state, import_content); /* import from all the array */ if (!state.opt.force_nocopy) state_search_array(&state); } /* filter */ state_skip(&state); state_filter(&state, &filterlist_file, &filterlist_disk, filter_missing, filter_error); memory(); /* intercept signals while operating */ signal_init(); if (operation == OPERATION_CHECK) { ret = state_check(&state, 0, blockstart, blockcount); } else { /* it's fix */ ret = state_check(&state, 1, blockstart, blockcount); } /* abort if required */ if (ret != 0) { /* LCOV_EXCL_START */ exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } } /* close log file */ log_close(log_file); #if HAVE_LOCKFILE if (!opt.skip_lock && state.lockfile[0]) { if (lock_unlock(lock) == -1) { /* LCOV_EXCL_START */ log_fatal("Error closing the lock file '%s'. %s.\n", state.lockfile, strerror(errno)); exit(EXIT_FAILURE); /* LCOV_EXCL_STOP */ } } #endif state_done(&state); tommy_list_foreach(&filterlist_file, (tommy_foreach_func*)filter_free); tommy_list_foreach(&filterlist_disk, (tommy_foreach_func*)filter_free); os_done(); return EXIT_SUCCESS; }
void menu(void) { char command; while(1) { command = getch(); switch(command) { case 'I': case 'i': init(); break; case 'R': case 'r': reset(); break; case 'T': case 't': selftest(); break; case 'A': case 'a': data(); break; case 'S': case 's': stream(); break; case 'P': case 'p': poweron(); break; case 'D': case 'd': powerdown(); break; case 'V': case 'v': version(); break; case 'M': case 'm': asim_command(); break; case 'X': case 'x': xteds(); break; case 'O': case 'o': timeattone(); break; case 'C': case 'c': cancel(); break; case 'Q': case 'q': endwin(); _exit(0); case 'W': case 'w': rawmodetoggle(); break; default: wprintw(w_out,"Bad Command\n"); } } }
void run(char *s) { int i, n; if (strncmp(s, "selftest", 8) == 0) { selftest(); return; } if (setjmp(stop_return)) return; init(); while (1) { n = scan(s); p1 = pop(); check_stack(); if (n == 0) break; // if debug mode then print the source text if (equaln(get_binding(symbol(TRACE)), 1)) { for (i = 0; i < n; i++) if (s[i] != '\r') printchar(s[i]); if (s[n - 1] != '\n') // n is not zero, see above printchar('\n'); } s += n; push(p1); top_level_eval(); p2 = pop(); check_stack(); if (p2 == symbol(NIL)) continue; // print string w/o quotes if (isstr(p2)) { printstr(p2->u.str); printstr("\n"); continue; } //if (equaln(get_binding(symbol(TTY)), 1) || test_flag) // tty mode? printline(p2); //else { // display(p2); //} } }
int main() { return selftest(0, NULL); }
static gcry_err_code_t do_twofish_setkey (TWOFISH_context *ctx, const byte *key, const unsigned keylen) { int i, j, k; /* Temporaries for CALC_K. */ u32 x, y; /* The S vector used to key the S-boxes, split up into individual bytes. * 128-bit keys use only sa through sh; 256-bit use all of them. */ byte sa = 0, sb = 0, sc = 0, sd = 0, se = 0, sf = 0, sg = 0, sh = 0; byte si = 0, sj = 0, sk = 0, sl = 0, sm = 0, sn = 0, so = 0, sp = 0; /* Temporary for CALC_S. */ byte tmp; /* Flags for self-test. */ static int initialized = 0; static const char *selftest_failed=0; /* Check key length. */ if( ( ( keylen - 16 ) | 16 ) != 16 ) return GPG_ERR_INV_KEYLEN; /* Do self-test if necessary. */ if (!initialized) { initialized = 1; selftest_failed = selftest (); if( selftest_failed ) log_error("%s\n", selftest_failed ); } if( selftest_failed ) return GPG_ERR_SELFTEST_FAILED; /* Compute the first two words of the S vector. The magic numbers are * the entries of the RS matrix, preprocessed through poly_to_exp. The * numbers in the comments are the original (polynomial form) matrix * entries. */ CALC_S (sa, sb, sc, sd, 0, 0x00, 0x2D, 0x01, 0x2D); /* 01 A4 02 A4 */ CALC_S (sa, sb, sc, sd, 1, 0x2D, 0xA4, 0x44, 0x8A); /* A4 56 A1 55 */ CALC_S (sa, sb, sc, sd, 2, 0x8A, 0xD5, 0xBF, 0xD1); /* 55 82 FC 87 */ CALC_S (sa, sb, sc, sd, 3, 0xD1, 0x7F, 0x3D, 0x99); /* 87 F3 C1 5A */ CALC_S (sa, sb, sc, sd, 4, 0x99, 0x46, 0x66, 0x96); /* 5A 1E 47 58 */ CALC_S (sa, sb, sc, sd, 5, 0x96, 0x3C, 0x5B, 0xED); /* 58 C6 AE DB */ CALC_S (sa, sb, sc, sd, 6, 0xED, 0x37, 0x4F, 0xE0); /* DB 68 3D 9E */ CALC_S (sa, sb, sc, sd, 7, 0xE0, 0xD0, 0x8C, 0x17); /* 9E E5 19 03 */ CALC_S (se, sf, sg, sh, 8, 0x00, 0x2D, 0x01, 0x2D); /* 01 A4 02 A4 */ CALC_S (se, sf, sg, sh, 9, 0x2D, 0xA4, 0x44, 0x8A); /* A4 56 A1 55 */ CALC_S (se, sf, sg, sh, 10, 0x8A, 0xD5, 0xBF, 0xD1); /* 55 82 FC 87 */ CALC_S (se, sf, sg, sh, 11, 0xD1, 0x7F, 0x3D, 0x99); /* 87 F3 C1 5A */ CALC_S (se, sf, sg, sh, 12, 0x99, 0x46, 0x66, 0x96); /* 5A 1E 47 58 */ CALC_S (se, sf, sg, sh, 13, 0x96, 0x3C, 0x5B, 0xED); /* 58 C6 AE DB */ CALC_S (se, sf, sg, sh, 14, 0xED, 0x37, 0x4F, 0xE0); /* DB 68 3D 9E */ CALC_S (se, sf, sg, sh, 15, 0xE0, 0xD0, 0x8C, 0x17); /* 9E E5 19 03 */ if (keylen == 32) /* 256-bit key */ { /* Calculate the remaining two words of the S vector */ CALC_S (si, sj, sk, sl, 16, 0x00, 0x2D, 0x01, 0x2D); /* 01 A4 02 A4 */ CALC_S (si, sj, sk, sl, 17, 0x2D, 0xA4, 0x44, 0x8A); /* A4 56 A1 55 */ CALC_S (si, sj, sk, sl, 18, 0x8A, 0xD5, 0xBF, 0xD1); /* 55 82 FC 87 */ CALC_S (si, sj, sk, sl, 19, 0xD1, 0x7F, 0x3D, 0x99); /* 87 F3 C1 5A */ CALC_S (si, sj, sk, sl, 20, 0x99, 0x46, 0x66, 0x96); /* 5A 1E 47 58 */ CALC_S (si, sj, sk, sl, 21, 0x96, 0x3C, 0x5B, 0xED); /* 58 C6 AE DB */ CALC_S (si, sj, sk, sl, 22, 0xED, 0x37, 0x4F, 0xE0); /* DB 68 3D 9E */ CALC_S (si, sj, sk, sl, 23, 0xE0, 0xD0, 0x8C, 0x17); /* 9E E5 19 03 */ CALC_S (sm, sn, so, sp, 24, 0x00, 0x2D, 0x01, 0x2D); /* 01 A4 02 A4 */ CALC_S (sm, sn, so, sp, 25, 0x2D, 0xA4, 0x44, 0x8A); /* A4 56 A1 55 */ CALC_S (sm, sn, so, sp, 26, 0x8A, 0xD5, 0xBF, 0xD1); /* 55 82 FC 87 */ CALC_S (sm, sn, so, sp, 27, 0xD1, 0x7F, 0x3D, 0x99); /* 87 F3 C1 5A */ CALC_S (sm, sn, so, sp, 28, 0x99, 0x46, 0x66, 0x96); /* 5A 1E 47 58 */ CALC_S (sm, sn, so, sp, 29, 0x96, 0x3C, 0x5B, 0xED); /* 58 C6 AE DB */ CALC_S (sm, sn, so, sp, 30, 0xED, 0x37, 0x4F, 0xE0); /* DB 68 3D 9E */ CALC_S (sm, sn, so, sp, 31, 0xE0, 0xD0, 0x8C, 0x17); /* 9E E5 19 03 */ /* Compute the S-boxes. */ for(i=j=0,k=1; i < 256; i++, j += 2, k += 2 ) { CALC_SB256_2( i, calc_sb_tbl[j], calc_sb_tbl[k] ); } /* Calculate whitening and round subkeys. The constants are * indices of subkeys, preprocessed through q0 and q1. */ CALC_K256 (w, 0, 0xA9, 0x75, 0x67, 0xF3); CALC_K256 (w, 2, 0xB3, 0xC6, 0xE8, 0xF4); CALC_K256 (w, 4, 0x04, 0xDB, 0xFD, 0x7B); CALC_K256 (w, 6, 0xA3, 0xFB, 0x76, 0xC8); CALC_K256 (k, 0, 0x9A, 0x4A, 0x92, 0xD3); CALC_K256 (k, 2, 0x80, 0xE6, 0x78, 0x6B); CALC_K256 (k, 4, 0xE4, 0x45, 0xDD, 0x7D); CALC_K256 (k, 6, 0xD1, 0xE8, 0x38, 0x4B); CALC_K256 (k, 8, 0x0D, 0xD6, 0xC6, 0x32); CALC_K256 (k, 10, 0x35, 0xD8, 0x98, 0xFD); CALC_K256 (k, 12, 0x18, 0x37, 0xF7, 0x71); CALC_K256 (k, 14, 0xEC, 0xF1, 0x6C, 0xE1); CALC_K256 (k, 16, 0x43, 0x30, 0x75, 0x0F); CALC_K256 (k, 18, 0x37, 0xF8, 0x26, 0x1B); CALC_K256 (k, 20, 0xFA, 0x87, 0x13, 0xFA); CALC_K256 (k, 22, 0x94, 0x06, 0x48, 0x3F); CALC_K256 (k, 24, 0xF2, 0x5E, 0xD0, 0xBA); CALC_K256 (k, 26, 0x8B, 0xAE, 0x30, 0x5B); CALC_K256 (k, 28, 0x84, 0x8A, 0x54, 0x00); CALC_K256 (k, 30, 0xDF, 0xBC, 0x23, 0x9D); } else { /* Compute the S-boxes. */ for(i=j=0,k=1; i < 256; i++, j += 2, k += 2 ) { CALC_SB_2( i, calc_sb_tbl[j], calc_sb_tbl[k] ); } /* Calculate whitening and round subkeys. The constants are * indices of subkeys, preprocessed through q0 and q1. */ CALC_K (w, 0, 0xA9, 0x75, 0x67, 0xF3); CALC_K (w, 2, 0xB3, 0xC6, 0xE8, 0xF4); CALC_K (w, 4, 0x04, 0xDB, 0xFD, 0x7B); CALC_K (w, 6, 0xA3, 0xFB, 0x76, 0xC8); CALC_K (k, 0, 0x9A, 0x4A, 0x92, 0xD3); CALC_K (k, 2, 0x80, 0xE6, 0x78, 0x6B); CALC_K (k, 4, 0xE4, 0x45, 0xDD, 0x7D); CALC_K (k, 6, 0xD1, 0xE8, 0x38, 0x4B); CALC_K (k, 8, 0x0D, 0xD6, 0xC6, 0x32); CALC_K (k, 10, 0x35, 0xD8, 0x98, 0xFD); CALC_K (k, 12, 0x18, 0x37, 0xF7, 0x71); CALC_K (k, 14, 0xEC, 0xF1, 0x6C, 0xE1); CALC_K (k, 16, 0x43, 0x30, 0x75, 0x0F); CALC_K (k, 18, 0x37, 0xF8, 0x26, 0x1B); CALC_K (k, 20, 0xFA, 0x87, 0x13, 0xFA); CALC_K (k, 22, 0x94, 0x06, 0x48, 0x3F); CALC_K (k, 24, 0xF2, 0x5E, 0xD0, 0xBA); CALC_K (k, 26, 0x8B, 0xAE, 0x30, 0x5B); CALC_K (k, 28, 0x84, 0x8A, 0x54, 0x00); CALC_K (k, 30, 0xDF, 0xBC, 0x23, 0x9D); } return 0; }
int main(int argc, char* argv[]) { if (argc != 6) { cerr << "[usage] <sentencesText.buf> <patterns.csv> <stopwords.txt> <stopwordsFromText.txt> <final.csv>" << endl; return -1; } selftest(); loadSentences(argv[1]); loadPattern(argv[2]); loadStopwords(argv[3], argv[4]); int corpusTokensN = 0; for (size_t sentenceID = 0; sentenceID < sentences.size(); ++ sentenceID) { const string &text = sentences[sentenceID]; string alpha = text; for (size_t i = 0; i < alpha.size(); ++ i) { if (isalpha(alpha[i])) { alpha[i] = tolower(alpha[i]); } else { if (alpha[i] != '\'') { alpha[i] = ' '; } } } corpusTokensN += splitBy(alpha, ' ').size(); string outsideText = alpha; if (sentenceID > 0) { outsideText += " " + sentences[sentenceID - 1]; } if (sentenceID + 1 < sentences.size()) { outsideText += " " + sentences[sentenceID + 1]; } for (size_t i = 0; i < outsideText.size(); ++ i) { if (isalpha(outsideText[i])) { outsideText[i] = tolower(outsideText[i]); } else { outsideText[i] = ' '; } } vector<string> outside = splitBy(outsideText, ' '); unordered_map<string, int> outsideCnt; FOR (token, outside) { ++ outsideCnt[*token]; } vector< pair<int, int> > positions; tree.search(" " + alpha + " ", positions); unordered_map<string, int> patternCnt; FOR (pos, positions) { int st = pos->first; int ed = pos->second - 2; string pattern = alpha.substr(st, ed - st); ++ patternCnt[pattern]; } FOR (pos, positions) { int st = pos->first; int ed = pos->second - 2; string pattern = alpha.substr(st, ed - st); vector<string> tokens = splitBy(pattern, ' '); unordered_map<string, int> tokenCnt; int delta = patternCnt[pattern]; for (size_t i = 0; i < tokens.size(); ++ i) { tokenCnt[tokens[i]] += delta; } for (size_t i = 0; i < tokens.size(); ++ i) { if (outsideCnt[tokens[i]] > tokenCnt[tokens[i]]) { f[pattern][i] += 1; sumOutside[pattern][i] += outsideCnt[tokens[i]] - tokenCnt[tokens[i]]; } } total[pattern] += 1; if (st > 0 && ed < (int)text.size()) { if (text[st - 1] == '(' && text[ed] == ')') { parenthesis[pattern] += 1; } if (text[st - 1] == '"' && text[ed] == '"') { quote[pattern] += 1; } } bool found = false; for (int i = st; i < ed && !found; ++ i) { found |= text[i] == '-'; } dash[pattern] += found; bool valid = true; for (int i = st; i < ed && valid; ++ i) { if (isalpha(alpha[i]) && (i == st || alpha[i - 1] == ' ')) { if (text[i] < 'A' && text[i] > 'Z') { valid = false; } } } capital[pattern] += valid; }
VOIDPTRFUNC CP_jREPL2(){ //fprintf(stdout, "\nStack in CP_jREPL2:\n"); //printJStack(__FILE__,__LINE__,__FUNCTION__); DEBUGCODE(PRINT_STACK->state, printJStack(__FILE__,__LINE__,__FUNCTION__)); OBJ result = RETVAL; #ifdef DEBUG if( (SP <= 5) || PRINT_INCLUDE->state){ printIndent(indentLevelForInclude); #else if( (SP <= 5)) { #endif js_print(stdout, result, 1); // P rint printf("\n"); } // L oop OBJ inputStream = ARG(0); TAILCALL1((VOIDPTRFUNC)CP_jREPL, inputStream); } int main() { initSymbolTable(); initializeWellKnownObjects(); initJStack(); #ifdef DEBUG initDebugOptions(); initGlobalEnvironment(); setupInitialEnvironment(); setupBuiltinSyntax(); selftest(); #endif printf("hello friend...\n"); initGlobalEnvironment(); setupInitialEnvironment(); printf("Welcome to (JS)cheme\n"); if( setjmp(whereEverythingWasFine) ){ #ifdef DEBUG indentLevel = 0; indentLevelForInclude = 0; #endif // reset Stack index SP = 0; AP = 0; BP = 0; prompt_on(); printf("back in wonderland\n"); } printf("...starting a REPL for you.\n"); OBJ inputStream = newFileStream(stdin); #ifdef DEBUG if(CONTINUATION_PASSING->state){ CP_setupBuiltinSyntax(); enterTrampoline1(inputStream); }else{ setupBuiltinSyntax(); jREPL(inputStream); } #else //jREPL(inputStream); CP_setupBuiltinSyntax(); enterTrampoline1(inputStream); #endif return 0; }
static void __init of_selftest_property_string(void) { const char *strings[4]; struct device_node *np; int rc; pr_info("start\n"); np = of_find_node_by_path("/testcase-data/phandle-tests/consumer-a"); if (!np) { pr_err("No testcase data in device tree\n"); return; } rc = of_property_match_string(np, "phandle-list-names", "first"); selftest(rc == 0, "first expected:0 got:%i\n", rc); rc = of_property_match_string(np, "phandle-list-names", "second"); selftest(rc == 1, "second expected:0 got:%i\n", rc); rc = of_property_match_string(np, "phandle-list-names", "third"); selftest(rc == 2, "third expected:0 got:%i\n", rc); rc = of_property_match_string(np, "phandle-list-names", "fourth"); selftest(rc == -ENODATA, "unmatched string; rc=%i\n", rc); rc = of_property_match_string(np, "missing-property", "blah"); selftest(rc == -EINVAL, "missing property; rc=%i\n", rc); rc = of_property_match_string(np, "empty-property", "blah"); selftest(rc == -ENODATA, "empty property; rc=%i\n", rc); rc = of_property_match_string(np, "unterminated-string", "blah"); selftest(rc == -EILSEQ, "unterminated string; rc=%i\n", rc); /* of_property_count_strings() tests */ rc = of_property_count_strings(np, "string-property"); selftest(rc == 1, "Incorrect string count; rc=%i\n", rc); rc = of_property_count_strings(np, "phandle-list-names"); selftest(rc == 3, "Incorrect string count; rc=%i\n", rc); rc = of_property_count_strings(np, "unterminated-string"); selftest(rc == -EILSEQ, "unterminated string; rc=%i\n", rc); rc = of_property_count_strings(np, "unterminated-string-list"); selftest(rc == -EILSEQ, "unterminated string array; rc=%i\n", rc); /* of_property_read_string_index() tests */ rc = of_property_read_string_index(np, "string-property", 0, strings); selftest(rc == 0 && !strcmp(strings[0], "foobar"), "of_property_read_string_index() failure; rc=%i\n", rc); strings[0] = NULL; rc = of_property_read_string_index(np, "string-property", 1, strings); selftest(rc == -ENODATA && strings[0] == NULL, "of_property_read_string_index() failure; rc=%i\n", rc); rc = of_property_read_string_index(np, "phandle-list-names", 0, strings); selftest(rc == 0 && !strcmp(strings[0], "first"), "of_property_read_string_index() failure; rc=%i\n", rc); rc = of_property_read_string_index(np, "phandle-list-names", 1, strings); selftest(rc == 0 && !strcmp(strings[0], "second"), "of_property_read_string_index() failure; rc=%i\n", rc); rc = of_property_read_string_index(np, "phandle-list-names", 2, strings); selftest(rc == 0 && !strcmp(strings[0], "third"), "of_property_read_string_index() failure; rc=%i\n", rc); strings[0] = NULL; rc = of_property_read_string_index(np, "phandle-list-names", 3, strings); selftest(rc == -ENODATA && strings[0] == NULL, "of_property_read_string_index() failure; rc=%i\n", rc); strings[0] = NULL; rc = of_property_read_string_index(np, "unterminated-string", 0, strings); selftest(rc == -EILSEQ && strings[0] == NULL, "of_property_read_string_index() failure; rc=%i\n", rc); rc = of_property_read_string_index(np, "unterminated-string-list", 0, strings); selftest(rc == 0 && !strcmp(strings[0], "first"), "of_property_read_string_index() failure; rc=%i\n", rc); strings[0] = NULL; rc = of_property_read_string_index(np, "unterminated-string-list", 2, strings); /* should fail */ selftest(rc == -EILSEQ && strings[0] == NULL, "of_property_read_string_index() failure; rc=%i\n", rc); strings[1] = NULL; /* of_property_read_string_array() tests */ rc = of_property_read_string_array(np, "string-property", strings, 4); selftest(rc == 1, "Incorrect string count; rc=%i\n", rc); rc = of_property_read_string_array(np, "phandle-list-names", strings, 4); selftest(rc == 3, "Incorrect string count; rc=%i\n", rc); rc = of_property_read_string_array(np, "unterminated-string", strings, 4); selftest(rc == -EILSEQ, "unterminated string; rc=%i\n", rc); /* -- An incorrectly formed string should cause a failure */ rc = of_property_read_string_array(np, "unterminated-string-list", strings, 4); selftest(rc == -EILSEQ, "unterminated string array; rc=%i\n", rc); /* -- parsing the correctly formed strings should still work: */ strings[2] = NULL; rc = of_property_read_string_array(np, "unterminated-string-list", strings, 2); selftest(rc == 2 && strings[2] == NULL, "of_property_read_string_array() failure; rc=%i\n", rc); strings[1] = NULL; rc = of_property_read_string_array(np, "phandle-list-names", strings, 1); selftest(rc == 1 && strings[1] == NULL, "Overwrote end of string array; rc=%i, str='%s'\n", rc, strings[1]); }
/** * * Selftest * - Find right RM for this boot * * Check RM set by rm_uuid file * OK-> OPENPTS_SELFTEST_SUCCESS * NG -> next * Check RM set by newrm_uuid file * OK -> OPENPTS_SELFTEST_RENEWED * NG -> next * Check RM set by oldrm_uuid file * OK -> OPENPTS_SELFTEST_FALLBACK * NG -> OPENPTS_SELFTEST_FAILED * * * Return * OPENPTS_SELFTEST_SUCCESS stable:-) * OPENPTS_SELFTEST_RENEWED update/reboot -> success * OPENPTS_SELFTEST_FALLBACK * OPENPTS_SELFTEST_FAILED * PTS_FATAL something wrong:-( */ int selftest(OPENPTS_CONFIG *conf, int prop_count, OPENPTS_PROPERTY *prop_start, OPENPTS_PROPERTY *prop_end) { int rc = PTS_INTERNAL_ERROR; int result; OPENPTS_CONTEXT *ctx; int i; OPENPTS_PROPERTY *prop; char * ir_filename; DEBUG_CAL("selftest() start\n"); /* Step 1 - Generate IR --------------------------------------------------*/ /* new CTX for generation */ ctx = newPtsContext(conf); if (ctx == NULL) { LOG(LOG_ERR, "newPtsContext() fail. no memory?"); return PTS_FATAL; } /* copy properties */ prop = prop_start; for (i = 0; i < prop_count; i++) { if (prop == NULL) { LOG(LOG_ERR, "prop == NULL"); rc = PTS_FATAL; goto free; } addProperty(ctx, prop->name, prop->value); prop = prop->next; } /* additional properties from the pts config file */ addPropertiesFromConfig(conf, ctx); /* set dummy nonce for IR gen */ ctx->nonce->nonce_length = 20; ctx->nonce->nonce = xmalloc_assert(20); if (ctx->nonce->nonce == NULL) { LOG(LOG_ERR, "no memory"); rc = PTS_FATAL; goto free; } memset(ctx->nonce->nonce, 0x5A, 20); /* set dummy target uuid */ ctx->str_uuid = smalloc("SELFTEST"); if (ctx->str_uuid == NULL) { LOG(LOG_ERR, "no memory"); rc = PTS_FATAL; goto free; } /* gen IR */ rc = genIr(ctx, NULL); if (rc != PTS_SUCCESS) { LOG(LOG_ERR, "selftest() - genIR failed\n"); rc = PTS_FATAL; goto free; } /* hold the IR filename */ ir_filename = ctx->ir_filename; ctx->ir_filename = NULL; /* free CTX */ freePtsContext(ctx); ctx = NULL; DEBUG("selftest() - generate IR - done (ir file = %s)\n", ir_filename); /* Step 2 - Validate IR --------------------------------------------------*/ /* Keep conf but reset some flags in conf */ #ifdef CONFIG_AUTO_RM_UPDATE /* clear ARU */ conf->update_exist = 0; #endif /* new CTX for validation */ ctx = newPtsContext(conf); if (ctx == NULL) { LOG(LOG_ERR, "newPtsContext() fail. no memory?"); return PTS_FATAL; } /* set generated IR */ ctx->ir_filename = ir_filename; /* setup RMs */ rc = getRmSetDir(conf); if (rc != PTS_SUCCESS) { LOG(LOG_ERR, "selftest() - getRmSetDir() failed\n"); LOG(LOG_TODO, "conf->rm_uuid->filename %s\n", conf->rm_uuid->filename); LOG(LOG_TODO, "conf->rm_uuid->str %s\n", conf->rm_uuid->str); rc = PTS_FATAL; goto free; } /* load RMs */ for (i = 0; i < conf->rm_num; i++) { rc = readRmFile(ctx, conf->rm_filename[i], i); if (rc < 0) { LOG(LOG_ERR, "readRmFile fail\n"); rc = PTS_FATAL; goto free; } } /* verify */ DEBUG("selftest() - validate IR - start\n"); // TODO 2011-01-21 SM just use same conf ctx->target_conf = ctx->conf; // Disable Quote // 2011-01-28 SM, If FSM did not covers all PCRs Quote validation will fail? // iml_mode = ctx->conf->iml_mode; // ir_without_quote = ctx->conf->ir_without_quote; // ctx->conf->iml_mode = 1; // ctx->conf->ir_without_quote = 1; result = validateIr(ctx); /* ir.c */ /* check RM integrity status */ DEBUG("selftest() - validate IR - done (rc = %d)\n", result); if ((result != OPENPTS_RESULT_VALID) && (getVerbosity() > 0)) { ERROR(NLS(MS_OPENPTS, OPENPTS_COLLECTOR_SELFTEST_FAILED_4, "The self test has failed")); printReason(ctx, 0); } if (result != OPENPTS_RESULT_VALID) { addReason(ctx, -1, NLS(MS_OPENPTS, OPENPTS_COLLECTOR_SELFTEST_FAILED, "[SELFTEST] The self test failed")); if ((conf->newrm_uuid != NULL) && (conf->newrm_uuid->uuid != NULL)) { /* New RM exist (for reboot after the update), Try the new RM */ /* chenge the UUID */ // TODO add exchange func conf->rm_uuid->uuid = conf->newrm_uuid->uuid; conf->rm_uuid->str = conf->newrm_uuid->str; conf->rm_uuid->time = conf->newrm_uuid->time; // del newrm conf->newrm_uuid->uuid = NULL; conf->newrm_uuid->str = NULL; conf->newrm_uuid->time = NULL; // TODO free /* try selftest again */ DEBUG("selftest again UUID=%s\n", conf->rm_uuid->str); rc = selftest(conf, prop_count, prop_start, prop_end); if (rc == OPENPTS_SELFTEST_SUCCESS) { /* Update the RM UUID by NEWRM_UUID */ DEBUG("use UUID=%s\n", conf->rm_uuid->str); /* update rm_uuid */ rc = writeOpenptsUuidFile(conf->rm_uuid, 1); if (rc != PTS_SUCCESS) { LOG(LOG_ERR, "writeOpenptsUuidFile fail\n"); rc = PTS_FATAL; goto free; } /* delete newrm_uuid */ rc = remove(conf->newrm_uuid->filename); if (rc != 0) { LOG(LOG_ERR, "remove(%s) fail\n", conf->newrm_uuid->filename); rc = PTS_FATAL; goto free; } rc = OPENPTS_SELFTEST_RENEWED; } else { /* fail */ LOG(LOG_ERR, "2nd selftest with NEWRM also fail\n"); addReason(ctx, -1, NLS(MS_OPENPTS, OPENPTS_COLLECTOR_SELFTEST_FAILED_2, "[SELFTEST] The self test using both current and new UUIDs has failed")); printReason(ctx, 0); rc = OPENPTS_SELFTEST_FAILED; } } else { /* Missing NEWRM */ printReason(ctx, 0); rc = OPENPTS_SELFTEST_FAILED; } } else { /* valid :-) */ rc = OPENPTS_SELFTEST_SUCCESS; } /* leaving lots of temp 100K+ files lying around quickly fills up certain filesystems, i.e. on AIX /tmp is typically small, so we unlink them after use */ if (NULL != conf->ir_filename) { unlink(conf->ir_filename); } free: /* free */ freePtsContext(ctx); if (rc == PTS_FATAL) { ERROR(NLS(MS_OPENPTS, OPENPTS_COLLECTOR_SELFTEST_FAILED_3, "The self test has failed. See log for details.")); } return rc; }