int main(int argc, char **argv) { char *filename; FILE *fd; int left = (9*9)*9; int count=0; if (argc == 2) { filename = argv[1]; } else { filename = "fields.sud"; } bf_backups = malloc(sizeof(struct bf_backups)); if (!(fd = fopen(filename, "r"))) { printf("error opening file\n"); exit(1); } if(readfield(fd)) { printf("error reading field\n"); exit(1); } if (initialize()) exit(1); fill_all(); check_filled(); printfield(wfield, 1); bruteforced = 0; /* main loop */ while (left > 0) { check_validity(); solve_run(&count); check_validity(); left = get_left(); count++; } if (final_check()) { winprintf(wtext, "\n\rSolved successfully\n\r"); } else { winprintf(wtext, "\n\rThere are still some errors\n\r"); } printfield(wfield, 1); press_any_key(); endwin(); return(0); }
int constraint_generate(hflow_t *flow, hpoint_t *point) { int i; flow->status = HFLOW_ACCEPT; if (!check_validity(point)) { flow->status = HFLOW_REJECT; flow->point.id = -1; if (!quiet) { fprintf(stderr, "Rejecting point: {"); for (i = 0; i < point->n; ++i) { hval_t *val = &point->val[i]; switch (val->type) { case HVAL_INT: fprintf(stderr, "%ld", val->value.i); break; case HVAL_REAL: fprintf(stderr, "%lf", val->value.r); break; case HVAL_STR: fprintf(stderr, "%s", val->value.s); break; default: fprintf(stderr, "<INV>"); } if (i < point->n - 1) fprintf(stderr, ", "); } fprintf(stderr, "}\n"); } } return 0; }
// create a Waldo instance from a file description // the description is assumed to be an asciiart image // with at least one line and always the same number of columns Waldo::Waldo(std::string const & path) { std::ifstream ifs(path); // TODO: convert the file to a string picture_ = "I am waldo"; check_validity(); hide_waldo(); }
int is_in_cache(long int address, struct cache_model *cache, struct passed_args *args) { /* Function to check if the data stored at the given address is in the cache (external) */ struct address_separated *addr_sep = separate_address(address, args); long set_index = addr_sep->set_index; long line_tag = addr_sep->line_index; int is_valid = check_validity(cache, set_index, line_tag); free(addr_sep); return is_valid; }
/** * Reads the file according to required format and * saves each fo the paremeters in the game struct. * * @param file_num Number of file to load game from * @return Game struct with state as read from file */ Game* load_game(int file_num) { int i, j, valid = 1; char path_to_read[MAX_STR_LEN]; FILE *read_file; char game_name[MAX_STR_LEN]; Game* loaded_game; if (check_validity(sprintf(path_to_read, FILE_PATH, file_num))) { read_file = fopen(path_to_read, "r"); if (read_file == NULL ) { printf("ERROR: Could not open saved game %s\n", path_to_read); return NULL; } if (check_validity(fscanf(read_file, "%s\n", game_name))) { // Create game according to name loaded_game = check_game(game_name); // Reading which player's turn if (check_validity(fscanf(read_file, "%d\n", &(loaded_game->current_player)))) { if ((loaded_game->current_player == FIRST_PL_TURN) || (loaded_game->current_player == SECOND_PL_TURN)) { // Reading board cells, according to size determined by game creation for (i = 0; i < loaded_game->board->n && valid; i++) { for (j = 0; j < (loaded_game->board->m - 1) && valid; j++) { valid = check_validity(fscanf(read_file, "%d ", &(loaded_game->board->cells[i][j]))); } // Last one will have line break valid = check_validity(fscanf(read_file, "%d\n", &(loaded_game->board->cells[i][j]))); } if (valid) { fclose(read_file); loaded_game->won_game(loaded_game); return loaded_game; } } } } fclose(read_file); } return NULL; }
void flood(cv::Mat_<cv::Vec3b> &I, cv::Mat_<cv::Vec3b> &R, const int &x, const int &y){ std::queue< P > q; q.push(P(x, y)); color(I, R, x, y); while (!q.empty()) { P p = q.front(); q.pop(); int pX = p.first; int pY = p.second; int nX = pX + 1; int nY = pY; if(check_validity(I, nX, nY)){ color(I, R, nX, nY); q.push(P(nX, nY)); } nX = pX - 1; if(check_validity(I, nX, nY)){ color(I, R, nX, nY); q.push(P(nX, nY)); } nX = pX; nY = pY + 1; if(check_validity(I, nX, nY)){ color(I, R, nX, nY); q.push(P(nX, nY)); } nY = pY - 1; if(check_validity(I, nX, nY)){ color(I, R, nX, nY); q.push(P(nX, nY)); } } }
ColorEntity::ColorEntity( const char* name, const ParamArray& params) : Entity(g_class_uid, params) , impl(new Impl()) { set_name(name); extract_parameters(); extract_values(); check_validity(); }
/** * Returns whether the game file number file_num exists */ int file_exists(int file_num) { char path_to_read[MAX_STR_LEN]; FILE *read_file; if (check_validity(sprintf(path_to_read, FILE_PATH, file_num))) { read_file = fopen(path_to_read, "r"); if (read_file == NULL ) { return 0; } fclose(read_file); return 1; } return 0; }
ColorEntity::ColorEntity( const char* name, const ParamArray& params, const ColorValueArray& values) : Entity(g_class_uid, params) , impl(new Impl()) { set_name(name); extract_parameters(); impl->m_values = values; impl->m_alpha.push_back(1.0f); check_validity(); }
static gboolean update_connection (NMVpnPluginUiWidgetInterface *iface, NMConnection *connection, GError **error) { L2tpPluginUiWidget *self = L2TP_PLUGIN_UI_WIDGET (iface); L2tpPluginUiWidgetPrivate *priv = L2TP_PLUGIN_UI_WIDGET_GET_PRIVATE (self); NMSettingVPN *s_vpn; GtkWidget *widget; const char *str; gboolean valid = FALSE; if (!check_validity (self, error)) return FALSE; s_vpn = NM_SETTING_VPN (nm_setting_vpn_new ()); g_object_set (s_vpn, NM_SETTING_VPN_SERVICE_TYPE, NM_DBUS_SERVICE_L2TP, NULL); /* Gateway */ widget = glade_xml_get_widget (priv->xml, "gateway_entry"); str = gtk_entry_get_text (GTK_ENTRY (widget)); if (str && strlen (str)) nm_setting_vpn_add_data_item (s_vpn, NM_L2TP_KEY_GATEWAY, str); /* Username */ widget = glade_xml_get_widget (priv->xml, "user_entry"); str = gtk_entry_get_text (GTK_ENTRY (widget)); if (str && strlen (str)) nm_setting_vpn_add_data_item (s_vpn, NM_L2TP_KEY_USER, str); /* Domain */ widget = glade_xml_get_widget (priv->xml, "domain_entry"); str = gtk_entry_get_text (GTK_ENTRY (widget)); if (str && strlen (str)) nm_setting_vpn_add_data_item (s_vpn, NM_L2TP_KEY_DOMAIN, str); if (priv->advanced) g_hash_table_foreach (priv->advanced, hash_copy_advanced, s_vpn); nm_connection_add_setting (connection, NM_SETTING (s_vpn)); valid = TRUE; return valid; }
// Select the position of the cursor void do_action(void) { process_scancode(keyrows[7-(ycoord-'1')].columns[xcoord-'A'].scancode); sel=!sel; if (sel==0) { if (check_validity() == TRUE) { reorg_historic(1); print_board(); computer_play(); reorg_historic(2); //print_board(); new_cursor_position(); } } else { oldx=xcoord; oldy=ycoord; } }
/** * Saves required parameters of the game in required format * to a file, in order to allow retrieving. * * @param file_num Number of file to save game to * @param game Game struct that should contain current state */ int save_game(int file_num, Game* game) { char path_to_save[MAX_STR_LEN]; FILE *write_file; int i, j, valid = 1; if (file_num <= FILES_NUM) { if (check_validity(sprintf(path_to_save, FILE_PATH, file_num))) { write_file = fopen(path_to_save, "w"); if (write_file == NULL ) { printf("ERROR: Could not open saved game %s\n", path_to_save); return 0; } if (check_validity(fprintf(write_file, "%s", game->save_game_name)) && check_validity(fprintf(write_file, "\n%d\n", game->current_player))) { for (i = 0; i < game->board->n && valid; i++) { for (j = 0; j < (game->board->m - 1) && valid; j++) { if (game->board->cells[i][j] == WINNING_TURN) { valid = check_validity(fprintf(write_file, "%d ", game->current_player)); } else { valid = check_validity(fprintf(write_file, "%d ", game->board->cells[i][j])); } } if (game->board->cells[i][j] == WINNING_TURN) { valid = check_validity(fprintf(write_file, "%d\n", game->current_player)); } else { valid = check_validity(fprintf(write_file, "%d\n", game->board->cells[i][j])); } } if (valid) { fclose(write_file); return 1; } } fclose(write_file); } } return 0; }
static gboolean update_connection (NMVpnPluginUiWidgetInterface *iface, NMConnection *connection, GError **error) { OpenswanPluginUiWidget *self = OPENSWAN_PLUGIN_UI_WIDGET (iface); OpenswanPluginUiWidgetPrivate *priv = OPENSWAN_PLUGIN_UI_WIDGET_GET_PRIVATE (self); NMSettingVPN *s_vpn; GtkWidget *widget; char *str; if (!check_validity (self, error)) return FALSE; s_vpn = NM_SETTING_VPN (nm_setting_vpn_new ()); g_object_set (s_vpn, NM_SETTING_VPN_SERVICE_TYPE, NM_DBUS_SERVICE_OPENSWAN, NULL); /* Gateway */ widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "gateway_entry")); str = (char *) gtk_entry_get_text (GTK_ENTRY (widget)); if (str && strlen (str)) nm_setting_vpn_add_data_item (s_vpn, NM_OPENSWAN_RIGHT, str); /* Group name */ widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "group_entry")); str = (char *) gtk_entry_get_text (GTK_ENTRY (widget)); if (str && strlen (str)) nm_setting_vpn_add_data_item (s_vpn, NM_OPENSWAN_LEFTID, str); /* User name*/ widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "user_entry")); str = (char *) gtk_entry_get_text (GTK_ENTRY (widget)); if (str && strlen (str)) nm_setting_vpn_add_data_item (s_vpn, NM_OPENSWAN_LEFTXAUTHUSER, str); /* Phase 1 Algorithms: ike */ widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "phase1_entry")); str = (char *) gtk_entry_get_text (GTK_ENTRY (widget)); if (str && strlen (str)) nm_setting_vpn_add_data_item (s_vpn, NM_OPENSWAN_IKE, str); /* Phase 2 Algorithms: esp */ widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "phase2_entry")); str = (char *) gtk_entry_get_text (GTK_ENTRY (widget)); if (str && strlen (str)) nm_setting_vpn_add_data_item (s_vpn, NM_OPENSWAN_ESP, str); /* Domain entry */ widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "domain_entry")); str = (char *) gtk_entry_get_text (GTK_ENTRY (widget)); if (str && strlen (str)) nm_setting_vpn_add_data_item (s_vpn, NM_OPENSWAN_DOMAIN, str); save_one_password (s_vpn, priv->builder, "user_password_entry", "user_pass_type_combo", NM_OPENSWAN_XAUTH_PASSWORD, NM_OPENSWAN_XAUTH_PASSWORD_INPUT_MODES); save_one_password (s_vpn, priv->builder, "group_password_entry", "group_pass_type_combo", NM_OPENSWAN_PSK_VALUE, NM_OPENSWAN_PSK_INPUT_MODES); nm_connection_add_setting (connection, NM_SETTING (s_vpn)); return TRUE; }
int main (){ int pid = 0; command_t cmd = {NULL, 0, {NULL}}; char *commandline = (char *)NULL; char* username = NULL; config_t ag_config; int bg_cmd = AG_FALSE; char prompt[MAX_LINE_LEN]; /* Sets the username */ set_username (&username); /* Opens the syslog file */ openlog (username, LOG_PID, LOG_USER); /* Parses the config files for data */ parse_config (&ag_config, username); /* Initializes GNU Readline */ initialize_readline(&ag_config); /* * Main loop: * - print prompt * - read input and parse it * - either a built-in command ("cd", "?" or "exit) * - or a system command, in which case the program forks and executes it with execvp() */ if (ag_config.welcome_message != NULL && strlen (ag_config.welcome_message) > 0) { fprintf (stdout, "\n%s\n\n", ag_config.welcome_message); } while (AG_TRUE){ /* Set the prompt */ get_prompt(prompt, MAX_LINE_LEN, username); /* * Read a line of input * commandline should be deallocated with free() */ commandline = read_input (prompt); parse_command (commandline, &cmd); switch (get_cmd_code (cmd.name)){ case EMPTY_CMD: break; case CD_CMD: change_directory (cmd.argv[1], ag_config.loglevel); break; case HELP_CMD: print_help(&ag_config); break; case ENV_CMD: print_env (cmd.argv[1]); break; case EXIT_CMD: free (commandline); commandline = (char *)NULL; closelog (); return 0; case OTHER_CMD: /* Determines whether the command should run in the bg or not */ bg_cmd = runs_in_background (&cmd); pid = vfork(); if (pid == 0){ if (!check_validity (cmd, ag_config)){ if (ag_config.loglevel == 3) syslog (LOG_NOTICE, "Using command: %s.", cmd.name); execvp (cmd.argv[0], cmd.argv); fprintf (stderr, "%s: Could not execute command!\nType '?' for help.\n", cmd.name); if (ag_config.loglevel >= 2) syslog (LOG_NOTICE, "Could not execute: %s.", cmd.name); }else { fprintf (stdout, "Not allowed! \n"); if (ag_config.warnings >= 0) decrease_warnings (&ag_config); if (ag_config.loglevel >= 1) syslog (LOG_ERR, "Trying to use forbidden command: %s.", cmd.name); } _exit(EXIT_FAILURE); }else if (pid < 0){ fprintf (stderr, "Error! ... Negative PID. God knows what that means ...\n"); if (ag_config.loglevel >= 1) syslog (LOG_ERR, "Negative PID. Using command: %s.", cmd.name); }else { if (!bg_cmd) wait (0); } break; } free (commandline); commandline = (char *)NULL; } if (commandline) free (commandline); closelog(); return 0; }
static gboolean update_connection (NMVpnPluginUiWidgetInterface *iface, NMConnection *connection, GError **error) { StrongswanPluginUiWidget *self = STRONGSWAN_PLUGIN_UI_WIDGET (iface); StrongswanPluginUiWidgetPrivate *priv = STRONGSWAN_PLUGIN_UI_WIDGET_GET_PRIVATE (self); NMSettingVPN *settings; GtkWidget *widget; gboolean active; char *str; if (!check_validity (self, error)) return FALSE; settings = NM_SETTING_VPN (nm_setting_vpn_new ()); g_object_set (settings, NM_SETTING_VPN_SERVICE_TYPE, NM_DBUS_SERVICE_STRONGSWAN, NULL); widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "address-entry")); str = (char *) gtk_entry_get_text (GTK_ENTRY (widget)); if (str && strlen (str)) { nm_setting_vpn_add_data_item (settings, "address", str); } widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "certificate-button")); str = (char *) gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (widget)); if (str) { nm_setting_vpn_add_data_item (settings, "certificate", str); } widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "method-combo")); switch (gtk_combo_box_get_active (GTK_COMBO_BOX (widget))) { default: case 0: widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "userkey-button")); str = (char *) gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (widget)); if (str) { nm_setting_vpn_add_data_item (settings, "userkey", str); } widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "usercert-button")); str = (char *) gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (widget)); if (str) { nm_setting_vpn_add_data_item (settings, "usercert", str); } str = "key"; break; case 1: widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "usercert-button")); str = (char *) gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (widget)); if (str) { nm_setting_vpn_add_data_item (settings, "usercert", str); } str = "agent"; break; case 2: str = "smartcard"; break; case 3: widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "user-entry")); str = (char *) gtk_entry_get_text (GTK_ENTRY (widget)); if (str && strlen (str)) { nm_setting_vpn_add_data_item (settings, "user", str); } str = "eap"; break; case 4: widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "user-entry")); str = (char *) gtk_entry_get_text (GTK_ENTRY (widget)); if (str && strlen (str)) { nm_setting_vpn_add_data_item (settings, "user", str); } str = "psk"; break; } nm_setting_vpn_add_data_item (settings, "method", str); widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "virtual-check")); active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)); nm_setting_vpn_add_data_item (settings, "virtual", active ? "yes" : "no"); widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "encap-check")); active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)); nm_setting_vpn_add_data_item (settings, "encap", active ? "yes" : "no"); widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "ipcomp-check")); active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)); nm_setting_vpn_add_data_item (settings, "ipcomp", active ? "yes" : "no"); nm_setting_set_secret_flags (NM_SETTING (settings), "password", NM_SETTING_SECRET_FLAG_AGENT_OWNED, NULL); nm_connection_add_setting (connection, NM_SETTING (settings)); return TRUE; }
int main(int argc, char** argv) { R_RSA_PUBLIC_KEY public_key; R_RSA_PRIVATE_KEY private_key; int i, n, retval; bool is_valid; DATA_BLOCK signature, in, out; unsigned char signature_buf[256], buf[256], buf2[256]; FILE *f, *fpriv, *fpub; char cbuf[256]; RSA rsa_key; RSA *rsa_key_; BIO *bio_out=NULL; BIO *bio_err=NULL; char *certpath; bool b2o=false; // boinc key to openssl key ? bool kpriv=false; // private key ? if (argc == 1) { usage(); exit(1); } if (!strcmp(argv[1], "-genkey")) { if (argc < 5) { usage(); exit(1); } printf("creating keys in %s and %s\n", argv[3], argv[4]); n = atoi(argv[2]); srand(random_int()); RSA* rp = RSA_generate_key(n, 65537, 0, 0); openssl_to_keys(rp, n, private_key, public_key); fpriv = fopen(argv[3], "w"); if (!fpriv) die("fopen"); fpub = fopen(argv[4], "w"); if (!fpub) die("fopen"); print_key_hex(fpriv, (KEY*)&private_key, sizeof(private_key)); print_key_hex(fpub, (KEY*)&public_key, sizeof(public_key)); } else if (!strcmp(argv[1], "-sign")) { if (argc < 4) { usage(); exit(1); } fpriv = fopen(argv[3], "r"); if (!fpriv) die("fopen"); retval = scan_key_hex(fpriv, (KEY*)&private_key, sizeof(private_key)); if (retval) die("scan_key_hex\n"); signature.data = signature_buf; signature.len = 256; retval = sign_file(argv[2], private_key, signature); print_hex_data(stdout, signature); } else if (!strcmp(argv[1], "-sign_string")) { if (argc < 4) { usage(); exit(1); } fpriv = fopen(argv[3], "r"); if (!fpriv) die("fopen"); retval = scan_key_hex(fpriv, (KEY*)&private_key, sizeof(private_key)); if (retval) die("scan_key_hex\n"); generate_signature(argv[2], cbuf, private_key); puts(cbuf); } else if (!strcmp(argv[1], "-verify")) { if (argc < 5) { usage(); exit(1); } fpub = fopen(argv[4], "r"); if (!fpub) die("fopen"); retval = scan_key_hex(fpub, (KEY*)&public_key, sizeof(public_key)); if (retval) die("read_public_key"); f = fopen(argv[3], "r"); signature.data = signature_buf; signature.len = 256; retval = scan_hex_data(f, signature); if (retval) die("scan_hex_data"); retval = verify_file(argv[2], public_key, signature, is_valid); if (retval) die("verify_file"); if (is_valid) { printf("file is valid\n"); } else { printf("file is invalid\n"); return 1; } } else if (!strcmp(argv[1], "-test_crypt")) { if (argc < 4) { usage(); exit(1); } fpriv = fopen(argv[2], "r"); if (!fpriv) die("fopen"); retval = scan_key_hex(fpriv, (KEY*)&private_key, sizeof(private_key)); if (retval) die("scan_key_hex\n"); fpub = fopen(argv[3], "r"); if (!fpub) die("fopen"); retval = scan_key_hex(fpub, (KEY*)&public_key, sizeof(public_key)); if (retval) die("read_public_key"); strcpy((char*)buf2, "encryption test successful"); in.data = buf2; in.len = strlen((char*)in.data); out.data = buf; encrypt_private(private_key, in, out); in = out; out.data = buf2; decrypt_public(public_key, in, out); printf("out: %s\n", out.data); } else if (!strcmp(argv[1], "-cert_verify")) { if (argc < 6) die("usage: crypt_prog -cert_verify file signature_file certificate_dir ca_dir \n"); f = fopen(argv[3], "r"); signature.data = signature_buf; signature.len = 256; retval = scan_hex_data(f, signature); if (retval) die("cannot scan_hex_data"); certpath = check_validity(argv[4], argv[2], signature.data, argv[5]); if (certpath == NULL) { die("signature cannot be verfied.\n\n"); } else { printf("siganture verified using certificate '%s'.\n\n", certpath); free(certpath); } // this converts, but an executable signed with sign_executable, // and signature converted to OpenSSL format cannot be verified with // OpenSSL } else if (!strcmp(argv[1], "-convsig")) { if (argc < 5) { usage(); exit(1); } if (strcmp(argv[2], "b2o") == 0) { b2o = true; } else if (strcmp(argv[2], "o2b") == 0) { b2o = false; } else { die("either 'o2b' or 'b2o' must be defined for -convsig\n"); } if (b2o) { f = fopen(argv[3], "r"); signature.data = signature_buf; signature.len = 256; retval = scan_hex_data(f, signature); fclose(f); f = fopen(argv[4], "w+"); print_raw_data(f, signature); fclose(f); } else { f = fopen(argv[3], "r"); signature.data = signature_buf; signature.len = 256; retval = scan_raw_data(f, signature); fclose(f); f = fopen(argv[4], "w+"); print_hex_data(f, signature); fclose(f); } } else if (!strcmp(argv[1], "-convkey")) { if (argc < 6) { usage(); exit(1); } if (strcmp(argv[2], "b2o") == 0) { b2o = true; } else if (strcmp(argv[2], "o2b") == 0) { b2o = false; } else { die("either 'o2b' or 'b2o' must be defined for -convkey\n"); } if (strcmp(argv[3], "pub") == 0) { kpriv = false; } else if (strcmp(argv[3], "priv") == 0) { kpriv = true; } else { die("either 'pub' or 'priv' must be defined for -convkey\n"); } OpenSSL_add_all_algorithms(); ERR_load_crypto_strings(); ENGINE_load_builtin_engines(); if (bio_err == NULL) { bio_err = BIO_new_fp(stdout, BIO_NOCLOSE); } //enc=EVP_get_cipherbyname("des"); //if (enc == NULL) // die("could not get cypher.\n"); // no encription yet. bio_out=BIO_new(BIO_s_file()); if (BIO_write_filename(bio_out,argv[5]) <= 0) { perror(argv[5]); die("could not create output file.\n"); } if (b2o) { rsa_key_ = RSA_new(); if (kpriv) { fpriv = fopen(argv[4], "r"); if (!fpriv) { die("fopen"); } scan_key_hex(fpriv, (KEY*)&private_key, sizeof(private_key)); fclose(fpriv); private_to_openssl(private_key, &rsa_key); //i = PEM_write_bio_RSAPrivateKey(bio_out, &rsa_key, // enc, NULL, 0, pass_cb, NULL); // no encryption yet. //i = PEM_write_bio_RSAPrivateKey(bio_out, &rsa_key, // NULL, NULL, 0, pass_cb, NULL); fpriv = fopen(argv[5], "w+"); PEM_write_RSAPrivateKey(fpriv, &rsa_key, NULL, NULL, 0, 0, NULL); fclose(fpriv); //if (i == 0) { // ERR_print_errors(bio_err); // die("could not write key file.\n"); //} } else { fpub = fopen(argv[4], "r"); if (!fpub) { die("fopen"); } scan_key_hex(fpub, (KEY*)&public_key, sizeof(public_key)); fclose(fpub); fpub = fopen(argv[5], "w+"); if (!fpub) { die("fopen"); } public_to_openssl(public_key, rsa_key_); i = PEM_write_RSA_PUBKEY(fpub, rsa_key_); if (i == 0) { ERR_print_errors(bio_err); die("could not write key file.\n"); } fclose(fpub); } } else { // o2b rsa_key_ = (RSA *)calloc(1, sizeof(RSA)); memset(rsa_key_, 0, sizeof(RSA)); if (rsa_key_ == NULL) { die("could not allocate memory for RSA structure.\n"); } if (kpriv) { fpriv = fopen (argv[4], "r"); rsa_key_ = PEM_read_RSAPrivateKey(fpriv, NULL, NULL, NULL); fclose(fpriv); if (rsa_key_ == NULL) { ERR_print_errors(bio_err); die("could not load private key.\n"); } openssl_to_private(rsa_key_, &private_key); fpriv = fopen(argv[5], "w"); if (!fpriv) { die("fopen"); } print_key_hex(fpriv, (KEY*)&private_key, sizeof(private_key)); } else { fpub = fopen (argv[4], "r"); rsa_key_ = PEM_read_RSA_PUBKEY(fpub, NULL, NULL, NULL); fclose(fpub); if (rsa_key_ == NULL) { ERR_print_errors(bio_err); die("could not load public key.\n"); } openssl_to_keys(rsa_key_, 1024, private_key, public_key); //openssl_to_public(rsa_key_, &public_key); public_to_openssl(public_key, rsa_key_); // fpub = fopen(argv[5], "w"); if (!fpub) { die("fopen"); } print_key_hex(fpub, (KEY*)&public_key, sizeof(public_key)); } } } else { usage(); exit(1); } return 0; }
void PointByPointVCorrection::exec() { // Get the input workspace and output workspace MatrixWorkspace_const_sptr inputWS1 = getProperty("InputW1"); MatrixWorkspace_const_sptr inputWS2 = getProperty("InputW2"); MatrixWorkspace_sptr outputWS= getProperty("OutputWorkspace"); // Check that everything is OK. check_validity(inputWS1,inputWS2,outputWS); // Now do the normalisation const int size=static_cast<int>(inputWS1->readX(0).size()); const int nHist=static_cast<int>(inputWS1->getNumberHistograms()); Progress prog(this,0.0,1.0,nHist); PARALLEL_FOR3(inputWS1,inputWS2,outputWS) for (int i=0;i<nHist;i++) //Looping on all histograms { PARALLEL_START_INTERUPT_REGION const MantidVec& X=inputWS1->readX(i); outputWS->setX( i, inputWS1->refX(i) ); const MantidVec& Y1=inputWS1->readY(i); const MantidVec& Y2=inputWS2->readY(i); const MantidVec& E1=inputWS1->readE(i); const MantidVec& E2=inputWS2->readE(i); MantidVec& resultY=outputWS->dataY(i); MantidVec& resultE=outputWS->dataE(i); // Work on the Y data MantidVec binwidths(size); //MantidVec for bin widths MantidVec errors(size-1); //MantidVec for temporary errors std::adjacent_difference(X.begin(),X.end(),binwidths.begin()); //Calculate the binwidths std::transform(binwidths.begin()+1,binwidths.end(),Y2.begin(),resultY.begin(),VectorHelper::DividesNonNull<double>()); std::transform(Y1.begin(),Y1.end(),resultY.begin(),resultY.begin(),std::multiplies<double>()); // Now resultY contains the A_i=s_i/v_i*Dlam_i // Calculate the errors squared related to A_i at this point for (int j=0;j<size-1;j++) { double r=0.0; if (std::abs(Y1[j])>1e-7) r+=std::pow(E1[j]/Y1[j],2); if (std::abs(Y2[j])>1e-7) r+=std::pow(E2[j]/Y2[j],2); errors[j]=r; // This are the errors^2 of S_i/v_i*Dlam_i if (errors[j]>DBL_MAX || errors[j]<-DBL_MAX) errors[j]=0; } // Calculate the normaliser double factor1=std::accumulate(Y1.begin(),Y1.end(),0.0); double factor2=std::accumulate(resultY.begin(),resultY.end(),0.0); double factor=factor1/factor2; // Now propagate the error bars due to the normaliser double error2_factor1=std::inner_product(E1.begin(),E1.end(),E1.begin(),0.0); double error2_factor2=0; for (int j=0;j<size-1;j++) { double test=std::abs(std::pow(resultY[j],2)); if (test>DBL_MAX) test=0; error2_factor2+=errors[j]*test/factor2/factor2; } double error2_factor=(error2_factor1/factor1/factor1+error2_factor2); // Calculate the normalized Y values // NOTE: Previously, we had been using std::transform with std::bind2nd(std::multiplies<double>(),factor) // here, but that seemed to have strange effects in Windows Debug builds which caused the unit tests // to sometimes fail. Maybe this is some compiler bug to do with using bind2nd within the parrallel macros. for( auto rY = resultY.begin(); rY != resultY.end(); ++rY ) { *rY *= factor; // Now result is s_i/v_i*Dlam_i*(sum_i s_i)/(sum_i S_i/v_i*Dlam_i) } //Finally get the normalized errors for (int j=0;j<size-1;j++) resultE[j]=resultY[j]*sqrt(errors[j]+error2_factor); // Check that any masking matches, print a warning if not check_masks(inputWS1,inputWS2,i); prog.report(); PARALLEL_END_INTERUPT_REGION } PARALLEL_CHECK_INTERUPT_REGION outputWS->setYUnitLabel("Counts normalised to a vanadium"); outputWS->isDistribution(false); }
// Authenticates the user. int authenticate(int sock, char * ip_address){ // Extracting the enviroment variable int BLOCK_TIME; const char * env_var = getenv("BLOCK_TIME"); if(env_var == NULL) BLOCK_TIME = 60; // In case was not set else BLOCK_TIME = atoi(env_var); time_t time_sec; time(&time_sec); fprintf(stderr, "%s attempts connection\n", ip_address); // Assume IP_BAN_DB was created before. // Check the ip against database of IP adresses. IP_DBRec * ip_db_array = (IP_DBRec *) malloc(sizeof(IP_DBRec) * MAX_IP_DB_REC_N); memset(ip_db_array, 0, sizeof(IP_DBRec) * MAX_IP_DB_REC_N); load_ip_db( (char *) ip_db_array); // db loaded int position; // If ip not found in db, create a new record, write it to db. if((position = find_position_in_IPDB(ip_db_array, ip_address)) == -1){ create_IP_DBRec(ip_address); load_ip_db( (char *) ip_db_array); position = find_position_in_IPDB(ip_db_array, ip_address); } int offset = position * sizeof(IP_DBRec); // Check if user is still banned. time(&time_sec); if((time_sec - ip_db_array[position].ban_time) < BLOCK_TIME){ fprintf(stdout, "%s attempts connection. Still banned\n", ip_address); free(ip_db_array); close(sock); return -1; } // Reset ban time ip_db_array[position].ban_time = 0; // Load the database of passwords and usernames UsersDB * db = (UsersDB *) malloc(sizeof(UsersDBRec) * N_USERS); memset(db, 0, sizeof(UsersDB)); FILE * db_file = fopen(DATABASE_NAME, "rb"); fread(db, sizeof(UsersDBRec), N_USERS, db_file); // Attempt validation of user. Check for number of tries. int attempts = 0; int position_in_users_db; // Give the user few attempts while(attempts < MAX_FAILS){ if((position_in_users_db = check_validity(sock, db)) == -1){ send(sock, "NO\n", 3, 0); attempts++; }else{ return position_in_users_db; } } // Ban user's ip adress time(&time_sec); ip_db_array[position].ban_time = time_sec; fprintf(stderr, "%s banned at %lu\n", ip_address, ip_db_array[position].ban_time); update_IPRec_in_dbfile(ip_db_array + position, offset); close(sock); return -1; }
/** * Returns whether this action is valid or not. * * @note This value is now calculated each time the function is called. */ bool valid(){ return check_validity()==OK; }
static gboolean update_connection (NMVpnEditor *editor, NMConnection *connection, GError **error) { VpncEditor *self = VPNC_EDITOR (editor); VpncEditorPrivate *priv = VPNC_EDITOR_GET_PRIVATE (self); NMSettingConnection *s_con; NMSettingVpn *s_vpn; GtkWidget *widget; char *str; guint32 port; GtkTreeModel *model; GtkTreeIter iter; if (!check_validity (self, error)) return FALSE; s_con = nm_connection_get_setting_connection (connection); s_vpn = NM_SETTING_VPN (nm_setting_vpn_new ()); g_object_set (s_vpn, NM_SETTING_VPN_SERVICE_TYPE, NM_DBUS_SERVICE_VPNC, NULL); /* Interface name */ widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "interface_name_entry")); str = (char *) gtk_entry_get_text (GTK_ENTRY (widget)); if (str && strlen (str)) g_object_set (G_OBJECT (s_con), NM_SETTING_CONNECTION_INTERFACE_NAME, str, NULL); /* Gateway */ widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "gateway_entry")); str = (char *) gtk_entry_get_text (GTK_ENTRY (widget)); if (str && strlen (str)) nm_setting_vpn_add_data_item (s_vpn, NM_VPNC_KEY_GATEWAY, str); /* Group name */ widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "group_entry")); str = (char *) gtk_entry_get_text (GTK_ENTRY (widget)); if (str && strlen (str)) nm_setting_vpn_add_data_item (s_vpn, NM_VPNC_KEY_ID, str); widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "user_entry")); str = (char *) gtk_entry_get_text (GTK_ENTRY (widget)); if (str && strlen (str)) nm_setting_vpn_add_data_item (s_vpn, NM_VPNC_KEY_XAUTH_USER, str); widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "domain_entry")); str = (char *) gtk_entry_get_text (GTK_ENTRY (widget)); if (str && strlen (str)) nm_setting_vpn_add_data_item (s_vpn, NM_VPNC_KEY_DOMAIN, str); widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "vendor_combo")); model = gtk_combo_box_get_model (GTK_COMBO_BOX (widget)); if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (widget), &iter)) { const char *vendor = NULL; gtk_tree_model_get (model, &iter, 1, &vendor, -1); nm_setting_vpn_add_data_item (s_vpn, NM_VPNC_KEY_VENDOR, vendor); } else nm_setting_vpn_add_data_item (s_vpn, NM_VPNC_KEY_VENDOR, NM_VPNC_VENDOR_CISCO); /* Application version */ widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "application_version_entry")); str = (char *) gtk_entry_get_text (GTK_ENTRY (widget)); if (str && strlen (str)) nm_setting_vpn_add_data_item (s_vpn, NM_VPNC_KEY_APP_VERSION, str); widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "encryption_combo")); switch (gtk_combo_box_get_active (GTK_COMBO_BOX (widget))) { case ENC_TYPE_WEAK: nm_setting_vpn_add_data_item (s_vpn, NM_VPNC_KEY_SINGLE_DES, "yes"); break; case ENC_TYPE_NONE: nm_setting_vpn_add_data_item (s_vpn, NM_VPNC_KEY_NO_ENCRYPTION, "yes"); break; case ENC_TYPE_SECURE: default: break; } widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "natt_combo")); model = gtk_combo_box_get_model (GTK_COMBO_BOX (widget)); if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (widget), &iter)) { const char *mode = NULL; gtk_tree_model_get (model, &iter, 1, &mode, -1); nm_setting_vpn_add_data_item (s_vpn, NM_VPNC_KEY_NAT_TRAVERSAL_MODE, mode); } else nm_setting_vpn_add_data_item (s_vpn, NM_VPNC_KEY_NAT_TRAVERSAL_MODE, NM_VPNC_NATT_MODE_NATT); widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "dhgroup_combo")); model = gtk_combo_box_get_model (GTK_COMBO_BOX (widget)); if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (widget), &iter)) { const char *dhgroup = NULL; gtk_tree_model_get (model, &iter, 1, &dhgroup, -1); nm_setting_vpn_add_data_item (s_vpn, NM_VPNC_KEY_DHGROUP, dhgroup); } else nm_setting_vpn_add_data_item (s_vpn, NM_VPNC_KEY_DHGROUP, NM_VPNC_DHGROUP_DH2); widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "pfsecrecy_combo")); model = gtk_combo_box_get_model (GTK_COMBO_BOX (widget)); if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (widget), &iter)) { const char *pfs = NULL; gtk_tree_model_get (model, &iter, 1, &pfs, -1); nm_setting_vpn_add_data_item (s_vpn, NM_VPNC_KEY_PERFECT_FORWARD, pfs); } else nm_setting_vpn_add_data_item (s_vpn, NM_VPNC_KEY_PERFECT_FORWARD, NM_VPNC_PFS_SERVER); /* Local port */ widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "local_port_spinbutton")); port = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (widget)); nm_setting_vpn_add_data_item (s_vpn, NM_VPNC_KEY_LOCAL_PORT, g_strdup_printf ("%d", port)); widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "disable_dpd_checkbutton")); if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget))) { nm_setting_vpn_add_data_item (s_vpn, NM_VPNC_KEY_DPD_IDLE_TIMEOUT, "0"); } else { /* If DPD was disabled and now the user wishes to enable it, just * don't pass the DPD_IDLE_TIMEOUT option to vpnc and thus use the * default DPD idle time. Otherwise keep the original DPD idle timeout. */ if (priv->orig_dpd_timeout >= 10) { char *tmp = g_strdup_printf ("%d", priv->orig_dpd_timeout); nm_setting_vpn_add_data_item (s_vpn, NM_VPNC_KEY_DPD_IDLE_TIMEOUT, tmp); g_free (tmp); } } /* User password */ save_one_password (s_vpn, priv->builder, "user_password_entry", NM_VPNC_KEY_XAUTH_PASSWORD, NM_VPNC_KEY_XAUTH_PASSWORD_TYPE); /* Group password */ save_one_password (s_vpn, priv->builder, "group_password_entry", NM_VPNC_KEY_SECRET, NM_VPNC_KEY_SECRET_TYPE); /* hybrid auth */ widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "hybrid_checkbutton")); if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget))) nm_setting_vpn_add_data_item (s_vpn, NM_VPNC_KEY_AUTHMODE, "hybrid"); widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "ca_file_chooser")); str = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (widget)); if (str && strlen (str)) nm_setting_vpn_add_data_item (s_vpn, NM_VPNC_KEY_CA_FILE, str); nm_connection_add_setting (connection, NM_SETTING (s_vpn)); return TRUE; }
void load_cfile_sim() { long line_count = 0; FILE * fp; /* the following variable is used for checking whether we have a newick string in the species&tree tag, in the case of 1 species. For species trees we do not accept a tree, whereas for network we require a newick string. The program always reads a line. If that line is a tree it is processed, otherwise this variable is set such that we do not read another line */ long line_not_processed = 0; fp = xopen(opt_simulate,"r"); while (line_not_processed || getnextline(fp)) { int valid = 0; char * token; char * value; long token_len; line_not_processed = 0; ++line_count; token_len = get_token(line,&token,&value); if (!token_len) continue; if (token_len < 0) fatal("Invalid syntax when parsing file %s on line %ld", opt_simulate, line_count); if (token_len == 4) { if (!strncasecmp(token,"seed",4)) { if (!get_long(value,&opt_seed)) fatal("Option 'seed' expects one integer (line %ld)", line_count); if (opt_seed == -1) opt_seed = (long)time(NULL); valid = 1; } else if (!strncasecmp(token,"arch",4)) { char * temp; if (!get_string(value,&temp)) fatal("Option %s expects a string (line %ld)", token, line_count); if (!strcmp(temp,"cpu")) opt_arch = PLL_ATTRIB_ARCH_CPU; else if (!strcasecmp(temp,"sse")) opt_arch = PLL_ATTRIB_ARCH_SSE; else if (!strcasecmp(temp,"avx")) opt_arch = PLL_ATTRIB_ARCH_AVX; else if (!strcasecmp(temp,"avx2")) opt_arch = PLL_ATTRIB_ARCH_AVX2; else fatal("Invalid instruction set (%s) (line %ld)", temp, line_count); free(temp); valid = 1; } } else if (token_len == 5) { if (!strncasecmp(token,"clock",5)) { if (!parse_clock(value)) fatal("Option 'clock' expects values '1', '2 a' or '3 a' (line %ld)", line_count); valid = 1; } else if (!strncasecmp(token,"model",5)) { if (!get_long(value,&opt_model) || opt_model < 0) fatal("Option 'model' expects value '%d' or '%d' (line %ld)", BPP_DNA_MODEL_JC69, BPP_DNA_MODEL_GTR, line_count); valid = 1; } } else if (token_len == 6) { if (!strncasecmp(token,"qrates",6)) { if (!parse_qrates(value)) fatal("Option 'qrates' expects one switch and 6 values (line %ld)", line_count); valid = 1; } } else if (token_len == 7) { if (!strncasecmp(token,"seqfile",7)) { if (!get_string(value, &opt_msafile)) fatal("Option '%s' expects a string (line %ld)", token, line_count); valid = 1; } else if (!strncasecmp(token,"diploid",7)) { if (!parse_diploid(value)) fatal("Option %s expects values 0 or 1 for each species (line %ld)", token,line_count); valid = 1; } } else if (token_len == 8) { if (!strncasecmp(token,"treefile",8)) { if (!get_string(value, &opt_treefile)) fatal("Option 'treefile' expects a string (line %ld)", line_count); valid = 1; } else if (!strncasecmp(token,"imapfile",8)) { if (!get_string(value, &opt_mapfile)) fatal("Option 'imapfile' expects a string (line %ld)", line_count); valid = 1; } } else if (token_len == 9) { if (!strncasecmp(token,"basefreqs",9)) { if (!parse_basefreqs(value)) fatal("Option 'basefreqs' expects one switch and 4 values (line %ld)", line_count); valid = 1; } else if (!strncasecmp(token,"migration",9)) { if (!get_long(value,&opt_migration)) fatal("Option 'migration' expects one integer (line %ld)", line_count); parse_migration_matrix(fp, line_count); valid = 1; } } else if (token_len == 10) { if (!strncasecmp(token,"concatfile",10)) { if (!get_string(value,&opt_concatfile)) fatal("Option 'concatfile' expects a string (line %ld)", line_count); valid = 1; } } else if (token_len == 11) { if (!strncasecmp(token,"loci&length",11)) { if (!parse_loci_and_lengths(value)) fatal("Option 'loci&length' expects two positive integer values (line %ld)", line_count); valid = 1; } } else if (token_len == 12) { if (!strncasecmp(token,"species&tree",12)) { /* TODO: Currently only the old BPP format is allowed. Make it also accept only the tree in newick format, i.e. one line instead of 3 */ long spcount = 0; if (!parse_speciesandtree(value,&spcount)) fatal("Erroneous format of 'species&tree' (line %ld)", line_count); if (!getnextline(fp)) fatal("Incomplete 'species&tree' record (line %ld)", line_count); ++line_count; if (!readandvalidatecount(line,spcount)) fatal("Erroneous enumeration of species sequences in 'species&tree' " "tag (line %ld).\nExpected number of species is %ld.\n", line_count, spcount); if (spcount > 1) { if (!getnextline(fp)) fatal("Incomplete 'species&tree' record (line %ld)", line_count); ++line_count; if (!get_tree_string_with_thetas(line,&opt_streenewick)) fatal("Expected newick tree string in 'species&tree' (line %ld) ", "with ending ';' character", line_count); } else if (spcount == 1) { /* TODO: This is an ugly hack to account for the case where we have 1 species and a network */ int reached_eof = 0; if (!getnextline(fp)) reached_eof = 1; ++line_count; line_not_processed = 1; if (!reached_eof && starts_with_opar(line)) { if (!get_string(line,&opt_streenewick)) fatal("Expected newick string in 'species&tree' (line %ld)", line_count); line_not_processed = 0; } else { opt_streenewick = (char *)xmalloc((size_t)(strlen(opt_reorder)+2) * sizeof(char)); strcpy(opt_streenewick, opt_reorder); opt_streenewick[strlen(opt_reorder)] = ';'; opt_streenewick[strlen(opt_reorder)+1] = '\0'; } if (reached_eof) break; } valid = 1; } } else if (token_len == 13) { if (!strncasecmp(token,"modelparafile",13)) { if (!get_string(value,&opt_modelparafile)) fatal("Option 'modelparafile' expects a string (line %ld)", line_count); valid = 1; } } else if (token_len == 14) { if (!strncasecmp(token,"alpha_siterate",14)) { if (!parse_siterate(value)) fatal("Erroneous format of 'alpha_siterate' (line %ld)", line_count); valid = 1; } } else if (token_len == 15) { if (!strncasecmp(token,"alpha_locusrate",15)) { if (!get_double(value, &opt_locusrate_alpha)) fatal("Option 'alpha_locusrate' expects one value (line %ld)", line_count); if (opt_locusrate_alpha < 0) fatal("Option 'alpha_locusrate' expects a non-negative value (line %ld)", line_count); if (opt_locusrate_alpha == 0) opt_est_locusrate = 0; else opt_est_locusrate = 1; valid = 1; } } if (!valid) fatal("Invalid syntax when parsing file %s on line %ld", opt_simulate, line_count); } check_validity(); #if 0 if (opt_diploid) update_sp_seqcount(); #endif fclose(fp); }