FILE *
fake_popen(const char * command, const char * type)
{
FILE * f = NULL;
char tmppath[MAX_PATH];
char tmpfile[MAX_PATH];
DWORD ret;
if (type == NULL) return NULL;
pipe_type = NUL;
if (pipe_filename != NULL)
free(pipe_filename);
/* Random temp file name in %TEMP% */
ret = GetTempPath(sizeof(tmppath), tmppath);
if ((ret == 0) || (ret > sizeof(tmppath)))
return NULL;
ret = GetTempFileName(tmppath, "gpp", 0, tmpfile);
if (ret == 0)
return NULL;
pipe_filename = strdup(tmpfile);
if (*type == 'r') {
char * cmd;
int rc;
pipe_type = *type;
/* Execute command with redirection of stdout to temporary file. */
cmd = (char *) malloc(strlen(command) + strlen(pipe_filename) + 5);
sprintf(cmd, "%s > %s", command, pipe_filename);
rc = system(cmd);
free(cmd);
/* Now open temporary file. */
/* system() returns 1 if the command could not be executed. */
if (rc != 1)
f = fopen(pipe_filename, "r");
else {
remove(pipe_filename);
free(pipe_filename);
pipe_filename = NULL;
errno = EINVAL;
}
} else if (*type == 'w') {
pipe_type = *type;
/* Write output to temporary file and handle the rest in fake_pclose. */
if (type[1] == 'b')
int_error(NO_CARET, "Could not execute pipe '%s'. Writing to binary pipes is not supported.", command);
else
f = fopen(pipe_filename, "w");
pipe_command = strdup(command);
}
return f;
}
static void clear_access_permission_table_handler_callback()
{
if(clear_access_permission_table_callback_handler)
{
clear_access_permission_table_callback_handler();
}
else // NULL
{
int_error("clear_access_permission_table_callback_handler is NULL");
}
}
member_type( struct_name, mem_name, off_ptr ) {
auto *e = lookup_tab( structtab, 32, struct_name );
/* sizeof(struct_entry) */
if (!e) int_error("No such struct found '%s'", struct_name);
e = lookup_tab( &e[5], 24, mem_name ); /* sizeof(sym_entry) */
if (!e) error("No member %s in struct %s", mem_name, struct_name);
if (off_ptr) *off_ptr = e[3];
return e[5][2];
}
static void add_authority_to_list_handler_callback(char *authority_name)
{
if(add_authority_to_list_callback_handler)
{
add_authority_to_list_callback_handler(authority_name);
}
else // NULL
{
int_error("add_authority_to_list_callback_handler is NULL");
}
}
static void clear_authority_table_handler_callback()
{
if(clear_authority_table_callback_handler)
{
clear_authority_table_callback_handler();
}
else // NULL
{
int_error("clear_authority_table_callback_handler is NULL");
}
}
static void add_authority_to_table_handler_callback(char *authority_name, char *ip_address, boolean authority_join_flag)
{
if(add_authority_to_table_callback_handler)
{
add_authority_to_table_callback_handler(authority_name, ip_address, authority_join_flag);
}
else // NULL
{
int_error("add_authority_to_table_callback_handler is NULL");
}
}
static void init_main()
{
// Initial the signal transmissters
if(sem_init(&wake_up_main_thread_mutex, 0, 0) != 0)
int_error("Initial a mutex failed");
if(sem_init(&confirm_err_msg_sending_to_frontend_mutex, 0, 0) != 0)
int_error("Initial a mutex failed");
if(sem_init(&send_signal_to_confirm_cancellation_thread_mutex, 0, 0) != 0)
int_error("Initial a mutex failed");
if(sem_init(&cancellation_thread_got_confirmation_mutex, 0, 0) != 0)
int_error("Initial a mutex failed");
strcpy(err_msg_to_frontend, "");
emergency_phr_extraction_thread_terminated_flag = false;
transaction_success_status_flag = false;
emergency_phr_extracting_cancellation_flag = false;
}
void init_dhparams(void)
{
BIO *bio;
bio = BIO_new_file("dh512.pem", "r");
if (!bio)
int_error("Error opening file dh512.pem");
dh512 = PEM_read_bio_DHparams(bio, NULL, NULL, NULL);
if (!dh512)
int_error("Error reading DH parameters from dh512.pem");
BIO_free(bio);
bio = BIO_new_file("dh1024.pem", "r");
if (!bio)
int_error("Error opening file dh1024.pem");
dh1024 = PEM_read_bio_DHparams(bio, NULL, NULL, NULL);
if (!dh1024)
int_error("Error reading DH parameters from dh1024.pem");
BIO_free(bio);
}
void
f_push(union argument *x)
{
struct udvt_entry *udv;
udv = x->udv_arg;
if (udv->udv_undef) { /* undefined */
int_error(NO_CARET, "undefined variable: %s", udv->udv_name);
}
push(&(udv->udv_value));
}
// Implementaion
static void backend_alert_msg_handler_callback(char *alert_msg)
{
if(backend_alert_msg_callback_handler)
{
backend_alert_msg_callback_handler(alert_msg);
}
else // NULL
{
int_error("backend_alert_msg_callback_handler is NULL");
}
}
/*
* Class: MailServerConfigurationChanging
* Method: change_mail_server_configuration
* Signature: (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Z
*/
JNIEXPORT jboolean JNICALL Java_MailServerConfigurationChanging_change_1mail_1server_1configuration(JNIEnv *env, jobject obj,
jstring j_mail_server_url, jstring j_authority_email_address, jstring j_authority_email_passwd)
{
const char *mail_server_url;
const char *authority_email_address;
const char *authority_email_passwd;
jclass cls;
boolean changing_flag;
// Get variables from Java
mail_server_url = (*env)->GetStringUTFChars(env, j_mail_server_url, 0);
authority_email_address = (*env)->GetStringUTFChars(env, j_authority_email_address, 0);
authority_email_passwd = (*env)->GetStringUTFChars(env, j_authority_email_passwd, 0);
Java_env = env;
Java_object = obj;
// Get the method ids for returning output to Java
cls = (*env)->GetObjectClass(env, obj);
Java_backend_alert_msg_callback_handler_id = (*env)->GetMethodID(env, cls, "backend_alert_msg_callback_handler", "(Ljava/lang/String;)V");
Java_backend_fatal_alert_msg_callback_handler_id = (*env)->GetMethodID(env, cls, "backend_fatal_alert_msg_callback_handler", "(Ljava/lang/String;)V");
if(Java_backend_alert_msg_callback_handler_id == 0)
int_error("Could not find method \"backend_alert_msg_callback_handler\"");
if(Java_backend_fatal_alert_msg_callback_handler_id == 0)
int_error("Could not find method \"backend_fatal_alert_msg_callback_handler\"");
// Change emergency unit's mail server configuration at emergency staff authority
changing_flag = change_emu_mail_server_configuration((char *)mail_server_url, (char *)authority_email_address, (char *)authority_email_passwd,
backend_alert_msg_callback_handler, backend_fatal_alert_msg_callback_handler);
// Free up the Java string arguments
(*env)->ReleaseStringUTFChars(env, j_mail_server_url, mail_server_url);
(*env)->ReleaseStringUTFChars(env, j_authority_email_address, authority_email_address);
(*env)->ReleaseStringUTFChars(env, j_authority_email_passwd, authority_email_passwd);
return (jboolean)changing_flag;
}
void
f_words(union argument *arg)
{
struct value a, b, result;
int nwords = 0;
int ntarget;
char *s;
(void) arg;
if (pop(&b)->type != INTGR)
int_error(NO_CARET, "internal error : non-INTGR argument");
ntarget = b.v.int_val;
if (pop(&a)->type != STRING)
int_error(NO_CARET, "internal error : non-STRING argument");
s = a.v.string_val;
Gstring(&result, "");
while (*s) {
while (isspace(*s)) s++;
if (!*s)
break;
nwords++;
if (nwords == ntarget) { /* Found the one we wanted */
Gstring(&result,s);
s = result.v.string_val;
}
while (*s && !isspace(*s)) s++;
if (nwords == ntarget) { /* Terminate this word cleanly */
*s = '\0';
break;
}
}
if (ntarget < 0)
/* words(s) = word(s,-1) = # of words in string */
Ginteger(&result, nwords);
push(&result);
gpfree_string(&a);
}
/* Return the lvalue flag for the symbol NAME, or 1 if it is
* not defined (as we assume external symbols are lvalues).
* Also set *OFF_PTR to the symbol table offset of the symbol, or
* 0 if it is not defined (as 0 is not a valid offset because
* 0(%ebp) is the calling frame's base pointer.) */
lookup_sym( name, off_ptr ) {
auto e = lookup_tab( symtab, 24, name ); /* sizeof(sym_entry) */
if (e) {
if (e[2]) int_error("Object declaration is a typedef");
if (off_ptr) *off_ptr = e[3];
return is_lv_decl(e[5][2]);
}
/* Symbol not found -- default to rvalues e.g. functions */
if (off_ptr) *off_ptr = 0;
return 0;
}
/* Used by plot2d/plot3d/fit:
* Parse an expression that may return a string or may return a constant or may
* be a dummy function using dummy variables x, y, ...
* If any dummy variables are present, set (*atptr) to point to an action table
* corresponding to the parsed expression, and return NULL.
* Otherwise evaluate the expression and return a string if there is one.
* The return value "str" and "*atptr" both point to locally-managed memory,
* which must not be freed by the caller!
*/
char*
string_or_express(struct at_type **atptr)
{
int i;
TBOOLEAN has_dummies;
static char* str = NULL;
free(str);
str = NULL;
if (atptr)
*atptr = NULL;
if (END_OF_COMMAND)
int_error(c_token, "expression expected");
/* parsing for datablocks */
if (equals(c_token,"$"))
return parse_datablock_name();
if (isstring(c_token)) {
str = try_to_get_string();
return str;
}
/* parse expression */
temp_at();
/* check if any dummy variables are used */
has_dummies = FALSE;
for (i = 0; i < at->a_count; i++) {
enum operators op_index = at->actions[i].index;
if ( op_index == PUSHD1 || op_index == PUSHD2 || op_index == PUSHD
|| op_index == SUM ) {
has_dummies = TRUE;
break;
}
}
if (!has_dummies) {
/* no dummy variables: evaluate expression */
struct value val;
evaluate_at(at, &val);
if (!undefined && val.type == STRING)
str = val.v.string_val;
}
/* prepare return */
if (atptr)
*atptr = at;
return str;
}
static int
get_num(char str[])
{
int count = 0;
char *endptr;
token[t_num].is_token = FALSE;
token[t_num].l_val.type = INTGR; /* assume unless . or E found */
while (isdigit((unsigned char) str[count]))
count++;
if (str[count] == '.') {
token[t_num].l_val.type = CMPLX;
/* swallow up digits until non-digit */
while (isdigit((unsigned char) str[++count]));
/* now str[count] is other than a digit */
}
if (str[count] == 'e' || str[count] == 'E') {
token[t_num].l_val.type = CMPLX;
count++;
if (str[count] == '-' || str[count] == '+')
count++;
if (!isdigit((unsigned char) str[count])) {
token[t_num].start_index += count;
int_error(t_num, "expecting exponent");
}
while (isdigit((unsigned char) str[++count]));
}
if (token[t_num].l_val.type == INTGR) {
long long lval;
errno = 0;
lval = strtoll(str, &endptr, 0);
if (!errno) {
count = endptr - str;
/* Linux and Windows implementations of POSIX function strtoll() differ.*/
/* I don't know which is "correct" but returning 0 causes an infinite */
/* loop on input "0x" as the scanner fails to progress. */
if (count == 0) count++;
if ((token[t_num].l_val.v.int_val = lval) == lval)
return(count);
if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X')) {
if ((long long unsigned int)lval == (long long unsigned int)token[t_num].l_val.v.int_val)
return(count);
}
}
int_warn(t_num, "integer overflow; changing to floating point");
token[t_num].l_val.type = CMPLX;
/* Fall through */
}
token[t_num].l_val.v.cmplx_val.imag = 0.0;
token[t_num].l_val.v.cmplx_val.real = strtod(str, &endptr);
count = endptr - str;
return (count);
}
void init_dhparams()
{
BIO *bio;
bio = BIO_new_file("../../certificates/dh512.pem","r");
if(!bio)
int_error("Could not open dh512.pem file");
dh512 = PEM_read_bio_DHparams(bio,nullptr,nullptr,nullptr);
if(!dh512)
int_error("Error reading DH params for dh512.pem");
BIO_free(bio);
bio = BIO_new_file("../../certificates/dh1024.pem", "r");
if(!bio)
int_error("Could not open dh512.pem file");
dh1024 = PEM_read_bio_DHparams(bio,nullptr,nullptr,nullptr);
if(!dh1024)
int_error("Error reading DH params for dh1024.pem");
BIO_free(bio);
}
void
graph_error(const char *fmt, va_dcl)
#endif
{
#ifdef VA_START
va_list args;
#endif
multiplot = FALSE;
term_end_plot();
#ifdef VA_START
VA_START(args, fmt);
#if 0
/* HBB 20001120: this seems not to work at all. Probably because a
* va_list argument, is, after all, something else than a varargs
* list (i.e. a '...') */
int_error(NO_CARET, fmt, args);
#else
/* HBB 20001120: instead, copy the core code from int_error() to
* here: */
PRINT_SPACES_UNDER_PROMPT;
PRINT_FILE_AND_LINE;
# if defined(HAVE_VFPRINTF) || _LIBC
vfprintf(stderr, fmt, args);
# else
_doprnt(fmt, args, stderr);
# endif
va_end(args);
fputs("\n\n", stderr);
bail_to_command_line();
#endif /* 1/0 */
va_end(args);
#else
int_error(NO_CARET, fmt, a1, a2, a3, a4, a5, a6, a7, a8);
#endif
}
/*
* Class: EmU_UserAndAdminManagement
* Method: edit_user_email_address_main
* Signature: (ZLjava/lang/String;Ljava/lang/String;)Z
*/
JNIEXPORT jboolean JNICALL Java_EmU_1UserAndAdminManagement_edit_1user_1email_1address_1main(
JNIEnv *env, jobject obj, jboolean j_is_admin_flag, jstring j_username, jstring j_email_address)
{
boolean is_admin_flag;
const char *username;
const char *email_address;
jclass cls;
boolean editing_flag;
// Get variables from Java
is_admin_flag = (boolean)j_is_admin_flag;
username = (*env)->GetStringUTFChars(env, j_username, 0);
email_address = (*env)->GetStringUTFChars(env, j_email_address, 0);
Java_env = env;
Java_object = obj;
// Get the method ids for returning output to Java
cls = (*env)->GetObjectClass(env, obj);
Java_backend_alert_msg_callback_handler_id = (*env)->GetMethodID(env, cls, "backend_alert_msg_callback_handler", "(Ljava/lang/String;)V");
Java_backend_fatal_alert_msg_callback_handler_id = (*env)->GetMethodID(env, cls, "backend_fatal_alert_msg_callback_handler", "(Ljava/lang/String;)V");
if(Java_backend_alert_msg_callback_handler_id == 0)
int_error("Could not find method \"backend_alert_msg_callback_handler\"");
if(Java_backend_fatal_alert_msg_callback_handler_id == 0)
int_error("Could not find method \"backend_fatal_alert_msg_callback_handler\"");
// Edit the emergency unit's user/admin e-mail address
editing_flag = edit_emu_user_email_address(is_admin_flag, (char *)username, (char *)email_address,
backend_alert_msg_callback_handler, backend_fatal_alert_msg_callback_handler);
// Free up the Java string arguments
(*env)->ReleaseStringUTFChars(env, j_username, username);
(*env)->ReleaseStringUTFChars(env, j_email_address, email_address);
return (jboolean)editing_flag;
}
/* push onto load_file state stack
essentially, we save information needed to undo the load_file changes
called by load_file */
void
lf_push(FILE *fp, char *name, char *cmdline)
{
LFS *lf;
int argindex;
lf = (LFS *) gp_alloc(sizeof(LFS), (char *) NULL);
if (lf == (LFS *) NULL) {
if (fp != (FILE *) NULL)
(void) fclose(fp); /* it won't be otherwise */
int_error(c_token, "not enough memory to load file");
}
lf->fp = fp; /* save this file pointer */
lf->name = name;
lf->cmdline = cmdline;
lf->interactive = interactive; /* save current state */
lf->inline_num = inline_num; /* save current line number */
lf->do_load_arg_substitution = do_load_arg_substitution;
lf->call_argc = call_argc;
for (argindex = 0; argindex < 10; argindex++) {
lf->call_args[argindex] = call_args[argindex];
call_args[argindex] = NULL; /* initially no args */
}
lf->depth = lf_head ? lf_head->depth+1 : 0; /* recursion depth */
if (lf->depth > STACK_DEPTH)
int_error(NO_CARET, "load/eval nested too deeply");
lf->if_depth = if_depth;
lf->if_open_for_else = if_open_for_else;
lf->if_condition = if_condition;
lf->c_token = c_token;
lf->num_tokens = num_tokens;
lf->tokens = gp_alloc((num_tokens+1) * sizeof(struct lexical_unit),
"lf tokens");
memcpy(lf->tokens, token, (num_tokens+1) * sizeof(struct lexical_unit));
lf->input_line = gp_strdup(gp_input_line);
lf->prev = lf_head; /* link to stack */
lf_head = lf;
}
void define()
{
register int start_token; /* the 1st token in the function definition */
register struct udvt_entry *udv;
register struct udft_entry *udf;
if (equals(c_token + 1, "(")) {
/* function ! */
int dummy_num = 0;
struct at_type *at_tmp;
char save_dummy[MAX_NUM_VAR][MAX_ID_LEN + 1];
memcpy(save_dummy, c_dummy_var, sizeof(save_dummy));
start_token = c_token;
do {
c_token += 2; /* skip to the next dummy */
copy_str(c_dummy_var[dummy_num++], c_token, MAX_ID_LEN);
} while (equals(c_token + 1, ",") && (dummy_num < MAX_NUM_VAR));
if (equals(c_token + 1, ","))
int_error("function contains too many parameters", c_token + 2);
c_token += 3; /* skip (, dummy, ) and = */
if (END_OF_COMMAND)
int_error("function definition expected", c_token);
udf = dummy_func = add_udf(start_token);
if ((at_tmp = perm_at()) == (struct at_type *) NULL)
int_error("not enough memory for function", start_token);
if (udf->at) /* already a dynamic a.t. there */
free((char *) udf->at); /* so free it first */
udf->at = at_tmp; /* before re-assigning it. */
memcpy(c_dummy_var, save_dummy, sizeof(save_dummy));
m_capture(&(udf->definition), start_token, c_token - 1);
dummy_func = NULL; /* dont let anyone else use our workspace */
} else {
/* variable ! */
start_token = c_token;
c_token += 2;
udv = add_udv(start_token);
(void) const_express(&(udv->udv_value));
udv->udv_undef = FALSE;
}
}
int main_ssl(int argc, char **argv)
{
BIO *conn;
SSL *ssl;
SSL_CTX *ctx;
long err;
init_OpenSSL();
seed_prng();
ctx = setup_client_ctx();
fprintf(stderr, "SERVER= %s:%s\n", SERVER, PORT);
conn = BIO_new_connect(SERVER ":" PORT);
if (!conn)
int_error("Error creating connection BIO");
if (BIO_do_connect(conn) <= 0)
int_error("Error connecting to remote machine");
ssl = SSL_new(ctx);
SSL_set_bio(ssl, conn, conn);
if (SSL_connect(ssl) <= 0)
int_error("Error connecting SSL object");
if ((err = post_connection_check(ssl, SERVER)) != X509_V_OK) {
fprintf(stderr, "-Error: peer certificate: %s\n",
X509_verify_cert_error_string(err));
int_error("Error checking SSL object after connection");
}
fprintf(stderr, "SSL Connection opened\n");
if (do_client_loop(ssl))
SSL_shutdown(ssl);
else
SSL_clear(ssl);
fprintf(stderr, "SSL Connection closed\n");
SSL_free(ssl);
SSL_CTX_free(ctx);
return 0;
}
/* TOKPUSH(tok, sym) - Push a token
** Note that the "constant" structure is not pushed or changed.
** It is OK for the current token to be a constant, if the token pushed
** (arg to tokpush) is not a constant. In fact, no constants can be
** pushed. The code for unary() in CCSTMT is the only place where this
** sort of thing has to be taken into account.
*/
void
tokpush(int t, SYMBOL *s)
{
if(++tokstack >= MAXTSTACK) /* Token stack depth exceeded? */
--tokstack, int_error("tokpush: tokstack overflow");
else
{
tstack[tokstack].ttoken = token;
tstack[tokstack].tsym = csymbol;
token = t;
csymbol = s;
}
}
static void add_access_permission_to_table_handler_callback(char *assigned_username, char *assigned_user_authority_name,
boolean upload_permission_flag, boolean download_permission_flag, boolean delete_permission_flag)
{
if(add_access_permission_to_table_callback_handler)
{
add_access_permission_to_table_callback_handler(assigned_username, assigned_user_authority_name,
upload_permission_flag, download_permission_flag, delete_permission_flag);
}
else // NULL
{
int_error("add_access_permission_to_table_callback_handler is NULL");
}
}
SSL_CTX *setup_client_ctx(void)
{
SSL_CTX *ctx;
ctx = SSL_CTX_new(SSLv23_method());
if (SSL_CTX_load_verify_locations(ctx, CAFILE, CADIR) != 1)
int_error("Error loading CA file and/or directory");
if (SSL_CTX_set_default_verify_paths(ctx) != 1)
int_error
("Error loading default CA file and/or directory");
if (SSL_CTX_use_certificate_chain_file(ctx, CERTFILE) != 1)
int_error("Error loading certificate from file");
if (SSL_CTX_use_PrivateKey_file(ctx, CERTFILE, SSL_FILETYPE_PEM) !=
1)
int_error("Error loading private key from file");
SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, verify_callback);
SSL_CTX_set_verify_depth(ctx, 4);
SSL_CTX_set_options(ctx, SSL_OP_ALL | SSL_OP_NO_SSLv2);
if (SSL_CTX_set_cipher_list(ctx, CIPHER_LIST) != 1)
int_error("Error setting cipher list (no valid ciphers)");
return ctx;
}
int main(int argc, char * argv[]) {
BIO * acc, * client;
THREAD_TYPE tid;
SSL * ssl;
SSL_CTX * ctx;
init_OpenSSL();
seed_prng();
ctx = setup_server_ctx();
acc = BIO_new_accept(PORT);
if (!acc)
int_error("Error creating server socket");
if (BIO_do_accept(acc) <= 0)
int_error("Error binding server socket");
// BIO_do_accept() will block and wait for a remote connection.
while (1) {
if (BIO_do_accept(acc) <= 0)
int_error("Error accepting connection");
// get the client BIO
client = BIO_pop(acc);
if (!(ssl = SSL_new(ctx)))
int_error("Error creating SSL context");
SSL_set_accept_state(ssl);
SSL_set_bio(ssl, client, client);
// create a new thread to handle the new connection,
// The thread will call do_server_loop with the client BIO.
// THREAD_CREATE(tid, entry, arg);
// tid is the id of the new thread.
// server_thread is the function defined above, which will call
// do_server_loop() with the client BIO.
THREAD_CREATE(tid, server_thread, ssl);
}
SSL_CTX_free(ctx);
BIO_free(acc);
return 0;
}
/*
* Class: EmU_PHRAuthorityManagement
* Method: edit_phr_authority_ip_address_main
* Signature: (Ljava/lang/String;Ljava/lang/String;)Z
*/
JNIEXPORT jboolean JNICALL Java_EmU_1PHRAuthorityManagement_edit_1phr_1authority_1ip_1address_1main(
JNIEnv *env, jobject obj, jstring j_phr_authority_name, jstring j_ip_address)
{
const char *phr_authority_name;
const char *ip_address;
jclass cls;
boolean editing_flag;
// Get variables from Java
phr_authority_name = (*env)->GetStringUTFChars(env, j_phr_authority_name, 0);
ip_address = (*env)->GetStringUTFChars(env, j_ip_address, 0);
Java_env = env;
Java_object = obj;
// Get the method ids for returning output to Java
cls = (*env)->GetObjectClass(env, obj);
Java_backend_alert_msg_callback_handler_id = (*env)->GetMethodID(env, cls, "backend_alert_msg_callback_handler", "(Ljava/lang/String;)V");
Java_backend_fatal_alert_msg_callback_handler_id = (*env)->GetMethodID(env, cls, "backend_fatal_alert_msg_callback_handler", "(Ljava/lang/String;)V");
if(Java_backend_alert_msg_callback_handler_id == 0)
int_error("Could not find method \"backend_alert_msg_callback_handler\"");
if(Java_backend_fatal_alert_msg_callback_handler_id == 0)
int_error("Could not find method \"backend_fatal_alert_msg_callback_handler\"");
// Edit PHR authority's IP address
editing_flag = edit_phr_authority_ip_address((char *)phr_authority_name, (char *)ip_address,
backend_alert_msg_callback_handler, backend_fatal_alert_msg_callback_handler);
// Free up the Java string arguments
(*env)->ReleaseStringUTFChars(env, j_phr_authority_name, phr_authority_name);
(*env)->ReleaseStringUTFChars(env, j_ip_address, ip_address);
return (jboolean)editing_flag;
}
/* Variable assignment operator */
void
f_assign(union argument *arg)
{
struct value a, b;
(void) arg;
(void) pop(&b); /* new value */
(void) pop(&a); /* name of variable */
if (a.type == STRING) {
struct udvt_entry *udv;
if (!strncmp(a.v.string_val,"GPVAL_",6) || !strncmp(a.v.string_val,"MOUSE_",6))
int_error(NO_CARET,"Attempt to assign to a read-only variable");
udv = add_udv_by_name(a.v.string_val);
gpfree_string(&a);
if (!udv->udv_undef)
gpfree_string(&(udv->udv_value));
udv->udv_value = b;
udv->udv_undef = FALSE;
push(&b);
} else {
int_error(NO_CARET, "attempt to assign to something other than a named variable");
}
}
__u16
listenSendMessage(Application_t *app, struct sk_buff *skb)
{
_cmsg *cmsg;
cmsg = cmsg_alloc();
if (!cmsg) {
int_error();
return (CAPI_MSGOSRESOURCEERR);
}
capi_message2cmsg(cmsg, skb->data);
switch (CMSGCMD(cmsg)) {
case CAPI_LISTEN_REQ:
if (mISDN_FsmEvent(&app->listen_m, EV_LISTEN_REQ, cmsg))
cmsg_free(cmsg);
break;
default:
int_error();
cmsg_free(cmsg);
}
dev_kfree_skb(skb);
return(CAPI_NOERROR);
}
static void init_server()
{
set_using_safety_threads_for_openssl(true);
seed_prng();
init_openssl();
assert_cache_directory_existence();
get_necessary_info();
load_pub_key();
// Initial the e-mail sending lock mutex
if(sem_init(&email_sending_lock_mutex, 0, 1) != 0)
int_error("Initial a mutex failed");
}
static void extend_cur_line()
{
char *new_line;
/* extent input line length */
new_line=ralloc(cur_line, line_len+MAXBUF, NULL);
if(!new_line) {
reset_termio();
int_error("Can't extend readline length", NO_CARET);
}
cur_line=new_line;
line_len+=MAXBUF;
}
