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