", message? message: "", "
" \
"Application is . . . . .: %s\n" \
"Started at date/time . .: %s %s\n" \
"Active server processes .: %d\n" \
"Total transaction steps .: %ld\n" \
"Average transaction cost : %ld msecs\n" \
"Current user sessions . .: %ld\n" \
"Peak user sessions . . .: %ld\n" \
"Total sessions handled .: %ld\n" \
"Total fatal errors . . .: %ld\n" \
""
static char
report [sizeof (REPORT_TEXT) + 100];
char
*state,
*fmtdate,
*fmttime;
qbyte
cur_sessions = 0,
peak_sessions = 0,
trans_count = 0,
trans_cost = 0,
fatal_errors = 0;
if (tcb-> applic_state == APPLIC_STOPPED)
{
state = "stopped";
fmtdate = "-";
fmttime = "";
}
else
{
fmtdate = conv_date_pict (tcb-> start_date, "d mmm, yy");
fmttime = conv_time_pict (tcb-> start_time, "hh:mm:ss");
cur_sessions = tcb-> info-> cur_sessions;
peak_sessions = tcb-> info-> peak_sessions;
trans_count = tcb-> info-> trans_count;
trans_cost = tcb-> info-> trans_cost;
if (trans_count > 0)
trans_cost = trans_cost / trans_count * 10;
fatal_errors = tcb-> info-> fatal_errors;
if (tcb-> applic_state == APPLIC_RUNNING)
state = "running";
else
if (tcb-> applic_state == APPLIC_LOCKED)
state = "running, locked";
else
state = "?";
}
sprintf (report, REPORT_TEXT,
state,
fmtdate, fmttime,
tcb-> nbr_servers,
trans_count, trans_cost,
cur_sessions, peak_sessions,
tcb-> session_count,
fatal_errors);
http_reply_html (thread, "Application report:", report);
}
/************************ HTTP REPLY APPLIC LOCKED ***********************/
MODULE http_reply_applic_locked (THREAD *thread)
{
http_reply_html (thread, "Application is now locked", NULL);
}
/*********************** HTTP REPLY APPLIC UNLOCKED **********************/
MODULE http_reply_applic_unlocked (THREAD *thread)
{
http_reply_html (thread, "Application is now unlocked", NULL);
}
/********************* HTTP REPLY APPLIC UNAVAILABLE *********************/
MODULE http_reply_applic_unavailable (THREAD *thread)
{
http_reply_html (thread, "Application not available",
"You can try to reconnect at a later time.");
}
/*********************** HTTP REPLY INVALID CONTROL **********************/
MODULE http_reply_invalid_control (THREAD *thread)
{
http_reply_html (thread, "Error", "Invalid control command.");
}
/************************* WAIT FOR SOCKET INPUT *************************/
MODULE wait_for_socket_input (THREAD *thread)
{
tcb = thread-> tcb; /* Point to thread's context */
send_input (&sockq, 0, tcb-> handle, 0);
}
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
S E S S I O N T H R E A D
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
/************************ INITIALISE SESSION DATA ************************/
MODULE initialise_session_data (THREAD *thread)
{
tcb = thread-> tcb; /* Point to thread's context */
/* Allocate empty program stack */
tcb-> call_stack = mem_alloc (STACK_MAX * sizeof (char *));
tcb-> session_context = sym_create_table ();
if (tcb-> call_stack == NULL
|| tcb-> session_context == NULL)
raise_exception (out_of_memory_event);
}
/********************** SESSION USE INITIAL PROGRAM **********************/
MODULE session_use_initial_program (THREAD *thread)
{
char
*root_program;
tcb = thread-> tcb; /* Point to thread's context */
/* Set reply QID for all HTTP responses */
tcb-> http_qid = thread-> event-> sender;
/* Use application root program as defined in program table. Entry
* code is WTP_DOINIT. Build WTP_DO message with empty HTML stream.
* Thread event body contains initial program arguments (from URL).
*/
root_program = session_root_program (tcb);
if (root_program)
{
ASSERT (tcb-> session_program == NULL);
tcb-> session_program = mem_strdup (root_program);
ASSERT (tcb-> session_request == NULL);
tcb-> session_reqsize = put_wtp_msg_do (
&tcb-> session_request,
WTP_DO, /* Message type */
0, /* ATP signature */
tcb-> session_program, /* Program to execute */
WTP_DOINIT, /* Program entry code */
session_uri (thread), /* URL for hyperlinks */
NULL, /* Encoded HTTP data */
thread-> event-> body_size,
thread-> event-> body, /* Call arguments size & data */
0, /* Result of last call */
tcb-> session_envsize, /* HTTP environment block size */
tcb-> session_envdata, /* and contents */
0, NULL, /* Global context block */
0, NULL); /* Local context block */
}
else
{
raise_exception (exception_event);
http_reply_html (thread, "Application root program not found", NULL);
}
}
/* -------------------------------------------------------------------------
* session_root_program
*
* Locates the root program for the application. If no root program is
* defined, returns NULL, else returns the name of the root program.
*/
static char *
session_root_program (TCB *tcb)
{
SYMBOL
*symbol; /* Program symbol */
symbol = tcb-> programs-> table-> symbols;
while (symbol)
{
if (symbol-> value && streq (symbol-> value, "ROOT"))
return (symbol-> name);
symbol = symbol-> next;
}
return (NULL);
}
/* -------------------------------------------------------------------------
* session_uri
*
* Formats and returns URL for session. URL argument is encoded as
* '+xxxxxxxx:yyyy" where xxxxxxxx is the thread name (SESSID_SIZE chars)
* and yyyy is the session step (4 digits).
*/
static char *
session_uri (THREAD *thread)
{
static char
uri [LINE_MAX];
tcb = thread-> tcb; /* Point to thread's context */
tcb-> session_step++; /* Cycles from 1 to n and around */
sprintf (uri, "/wtp%s?+%s:%04X",
tcb-> applic_uri, thread-> name, tcb-> session_step);
return (uri);
}
/********************** SESSION USE CURRENT PROGRAM **********************/
MODULE session_use_current_program (THREAD *thread)
{
qbyte
global_size,
local_size;
byte
*global_data,
*local_data;
tcb = thread-> tcb; /* Point to thread's context */
/* Set reply QID for all HTTP responses */
tcb-> http_qid = thread-> event-> sender;
/* Current program is already okay - entry code is WTP_DOGET
* Build WTP_DO message using thread event body for HTML data
*/
get_context (&global_size, &global_data, &local_size, &local_data);
ASSERT (tcb-> session_request == NULL);
tcb-> session_reqsize = put_wtp_msg_do (
&tcb-> session_request,
WTP_DO, /* Message type */
0, /* ATP signature */
tcb-> session_program, /* Program to execute */
WTP_DOGET, /* Program entry code */
session_uri (thread), /* URL for hyperlinks */
(char *) thread-> event-> body, /* Encoded HTTP data */
0, NULL, /* Call arguments size & data */
0, /* Result of last call */
0, NULL, /* Environment data block */
global_size, global_data, /* Global context block */
local_size, local_data); /* Local context block */
}
static void
get_context (qbyte *global_size, byte **global_data,
qbyte *local_size, byte **local_data)
{
SYMBOL
*symbol;
symbol = sym_lookup_symbol (tcb-> session_context, "$global");
if (symbol)
{
*global_size = ((DESCR *) symbol-> data)-> size;
*global_data = ((DESCR *) symbol-> data)-> data;
}
else
{
*global_size = 0;
*global_data = NULL;
}
symbol = sym_lookup_symbol (tcb-> session_context, tcb-> session_program);
if (symbol)
{
*local_size = ((DESCR *) symbol-> data)-> size;
*local_data = ((DESCR *) symbol-> data)-> data;
}
else
{
*local_size = 0;
*local_data = NULL;
}
}
/*********************** SESSION USE CALLED PROGRAM **********************/
MODULE session_use_called_program (THREAD *thread)
{
struct_wtp_msg_donecall
*wtp_msg = NULL;
byte
entry_code, /* WTP_DO entry code */
call_result; /* If call failed */
qbyte
global_size,
local_size;
byte
*global_data,
*local_data;
tcb = thread-> tcb; /* Point to thread's context */
/* Unpack WTP_DONECALL message into usable structure */
get_wtp_msg_donecall (thread-> event-> body, &wtp_msg);
/* Save global and local context blocks, since we stay in program */
put_context (0, wtp_msg-> global_size, wtp_msg-> global_data);
put_context (1, wtp_msg-> local_size, wtp_msg-> local_data);
/* Push current program, use called program - entry code is WTP_DOINIT
* Build WTP_DO message, with empty HTML data, and pass arguments as
* supplied in wtp_donecall message.
*/
strupc (wtp_msg-> program); /* Normalise the program name */
/* Check various errors first of all */
if (tcb-> stack_ptr == STACK_MAX - 1)
call_result = WTP_ERROROVERFLOW;
else
if (!sym_lookup_symbol (tcb-> programs-> table, wtp_msg-> program))
call_result = WTP_ERRORNOTFOUND;
else
if (program_is_active (tcb, wtp_msg-> program))
call_result = WTP_ERRORWOULDLOOP;
else /* Else stack new program */
{
call_result = WTP_NOERROR;
tcb-> call_stack [tcb-> stack_ptr++] = tcb-> session_program;
tcb-> session_program = NULL;
session_set_program (tcb, wtp_msg-> program);
}
if (call_result == WTP_NOERROR)
entry_code = WTP_DOINIT;
else
entry_code = WTP_DOCONTINUE;
get_context (&global_size, &global_data, &local_size, &local_data);
ASSERT (tcb-> session_request == NULL);
tcb-> session_reqsize = put_wtp_msg_do (
&tcb-> session_request,
WTP_DO, /* Message type */
0, /* ATP signature */
tcb-> session_program, /* Program to execute */
entry_code, /* Program entry code */
session_uri (thread), /* URL for hyperlinks */
NULL, /* Encoded HTTP data */
wtp_msg-> args_size, /* Call arguments size */
wtp_msg-> args_data, /* Call arguments data */
call_result, /* Result of last call */
0, NULL, /* Environment data block */
global_size, global_data, /* Global context block */
local_size, local_data); /* Local context block */
/* Free areas used by message structure */
free_wtp_msg_donecall (&wtp_msg);
}
/* -------------------------------------------------------------------------
* program_is_active
*
* Returns TRUE if the program name is already active; the supplied name
* must have been normalised (put into uppercase) beforehand.
*/
static Bool
program_is_active (TCB *tcb, char *program)
{
int
prog_nbr; /* Program on active stack */
for (prog_nbr = 0; prog_nbr < tcb-> stack_ptr; prog_nbr++)
if (streq (tcb-> call_stack [prog_nbr], program))
return (TRUE);
return (FALSE);
}
static void
put_context (int local_block, qbyte size, byte *data)
{
char
*context_key;
SYMBOL
*symbol;
if (local_block)
context_key = tcb-> session_program;
else
context_key = "$global";
/* Delete context block if it already exists */
symbol = sym_lookup_symbol (tcb-> session_context, context_key);
if (symbol)
{
mem_free (symbol-> data);
sym_delete_symbol (tcb-> session_context, symbol);
}
/* Now store new block if wanted */
if (data)
{
symbol = sym_create_symbol (tcb-> session_context, context_key, NULL);
if (symbol)
symbol-> data = mem_descr (data, size);
else
raise_exception (out_of_memory_event);
}
}
/* -------------------------------------------------------------------------
* session_set_program
*
* Sets a new tcb-> sesssion_program. If the specified program does not
* exist, or is already active, leaves the session_program unchanged.
* Returns one of: WTP_NOERROR or WTP_ERRORNOTFOUND.
*/
static int
session_set_program (TCB *tcb, char *program)
{
char
*normalised;
normalised = mem_strdup (program);
strupc (normalised);
if (sym_lookup_symbol (tcb-> programs-> table, normalised))
{
mem_strfree (&tcb-> session_program);
tcb-> session_program = normalised;
return (WTP_NOERROR);
}
else
{
mem_strfree (&normalised);
return (WTP_ERRORNOTFOUND);
}
}
/*********************** SESSION USE PARENT PROGRAM **********************/
MODULE session_use_parent_program (THREAD *thread)
{
struct_wtp_msg_donereturn
*wtp_msg = NULL;
qbyte
global_size,
local_size;
byte
*global_data,
*local_data;
tcb = thread-> tcb; /* Point to thread's context */
/* Pop parent program - entry code is WTP_DOCONTINUE. If stack was
* empty, raise session_exit exception. Otherwise, build WTP_DO
* message with empty HTML data and return code from called program.
*/
if (tcb-> stack_ptr == 0)
{
raise_exception (session_exit_event);
return;
}
/* Unpack WTP_DONERETURN message into usable structure */
get_wtp_msg_donereturn (thread-> event-> body, &wtp_msg);
/* Save global context blocks, since we leave in program */
put_context (0, wtp_msg-> global_size, wtp_msg-> global_data);
put_context (1, 0, NULL); /* Wipe local context block */
mem_strfree (&tcb-> session_program);
tcb-> session_program = tcb-> call_stack [--tcb-> stack_ptr];
get_context (&global_size, &global_data, &local_size, &local_data);
ASSERT (tcb-> session_request == NULL);
tcb-> session_reqsize = put_wtp_msg_do (
&tcb-> session_request,
WTP_DO, /* Message type */
0, /* ATP signature */
tcb-> session_program, /* Program to execute */
WTP_DOCONTINUE, /* Program entry code */
session_uri (thread), /* URL for hyperlinks */
NULL, /* Encoded HTTP data */
wtp_msg-> args_size, /* Call arguments size */
wtp_msg-> args_data, /* Call arguments data */
WTP_NOERROR, /* Result of last call */
0, NULL, /* Environment data block */
global_size, global_data, /* Global context block */
local_size, local_data); /* Local context block */
/* Free areas used by message structure */
free_wtp_msg_donereturn (&wtp_msg);
}
/************************* SESSION SHOW HTML DATA ************************/
MODULE session_show_html_data (THREAD *thread)
{
struct_wtp_msg_doneshow
*wtp_msg = NULL;
char
*html_data;
tcb = thread-> tcb; /* Point to thread's context */
/* Unpack WTP_DONESHOW message into usable structure */
get_wtp_msg_doneshow (thread-> event-> body, &wtp_msg);
/* Save global and local context blocks, since we stay in program */
put_context (0, wtp_msg-> global_size, wtp_msg-> global_data);
put_context (1, wtp_msg-> local_size, wtp_msg-> local_data);
/* Save HTML data in session TCB, for refreshing if necessary */
/* We translate accented characters into SGML metacharacters */
if (tcb-> session_screen == NULL)
tcb-> session_screen = mem_alloc (FORM_MAX + 1);
html_data = wtp_msg-> html_data;
http_encode_meta (tcb-> session_screen, &html_data, FORM_MAX, TRUE);
/* Send HTML data back to HTTP agent and thence on to the browser */
send_wsx_ok (&tcb-> http_qid, tcb-> session_screen);
/* Free areas used by message structure */
free_wtp_msg_doneshow (&wtp_msg);
}
/************************* SESSION RESYNCHRONIZE *************************/
MODULE session_resynchronize (THREAD *thread)
{
tcb = thread-> tcb; /* Point to thread's context */
/* We have received a new request for a session that is already busy.
This typically happens when users click twice or are impatient for
a slow response to finish. The browser behavior is to close the
first active socket and open a new one with the second click. In
Xitami this is two threads. We handle this by discarding the old
http_qid and taking the new one, but we do not send anything back
to the browser - it has to wait until the server is correctly done
with its work and sends the reply back.
*/
tcb-> http_qid = thread-> event-> sender;
}
/********************** ROUTE WTP REQUEST TO SERVER **********************/
MODULE route_wtp_request_to_server (THREAD *thread)
{
SYMBOL
*symbol; /* Program symbol */
THREAD
*server_thread; /* Symbol refers to thread */
TCB
*server_tcb;
QID
target_qid; /* Where do we send the request? */
tcb = thread-> tcb; /* Point to thread's context */
/* Look for available server based on program symbol table and server
* ready flags... If none available, add do message to request queue.
*/
target_qid = tcb-> do_queue-> qid; /* By default */
symbol = sym_lookup_symbol (tcb-> programs-> table, tcb-> session_program);
while (symbol)
{
if (streq (symbol-> name, tcb-> session_program))
{
server_thread = symbol-> data;
server_tcb = server_thread-> tcb;
if (server_tcb-> server_ready)
{
server_tcb-> server_ready = FALSE;
target_qid = server_thread-> queue-> qid;
break;
}
}
symbol = symbol-> next;
}
event_send (
&target_qid,
&thread-> queue-> qid,
"_REQUEST",
tcb-> session_request,
tcb-> session_reqsize,
NULL, NULL, NULL, 0);
mem_free (tcb-> session_request);
tcb-> session_request = NULL;
}
/************************** SESSION SET TIMEOUT **************************/
MODULE session_set_timeout (THREAD *thread)
{
long
timeout; /* Timeout in seconds */
tcb = thread-> tcb; /* Point to thread's context */
timeout = atol (TCONFIG ("general:session_timeout", "60"));
timeout = timeout * 60 * 100; /* Minutes => 1/100th seconds */
send_alarm (&timeq, 0, timeout, 0, NULL);
}
/********************* SESSION SHOW APPLICATION ENDED ********************/
MODULE session_show_application_ended (THREAD *thread)
{
char
*goodbye; /* Sign-off message or URL */
goodbye = TCONFIG ("general:goodbye", "Goodbye");
if (*goodbye == '@')
send_wsx_redirect (&tcb-> http_qid, goodbye + 1);
else
http_reply_html (thread, "Finished", goodbye);
}
/********************* SESSION SHOW APPLICATION ERROR ********************/
MODULE session_show_application_error (THREAD *thread)
{
struct_wtp_msg_doneerror
*wtp_msg = NULL;
tcb = thread-> tcb; /* Point to thread's context */
get_wtp_msg_doneerror (thread-> event-> body, &wtp_msg);
http_reply_html (thread, "Error", wtp_msg-> error_text);
free_wtp_msg_doneerror (&wtp_msg);
}
/********************** HTTP REPLY SERVER TIMED OUT **********************/
MODULE http_reply_server_timed_out (THREAD *thread)
{
http_reply_html (thread, "Application program was looping", NULL);
}
/*********************** HTTP REPLY SERVER ABORTED ***********************/
MODULE http_reply_server_aborted (THREAD *thread)
{
http_reply_html (thread, "Application program aborted", NULL);
}
/******************* HTTP REPLY INSUFFICIENT RESOURCES *******************/
MODULE http_reply_insufficient_resources (THREAD *thread)
{
http_reply_html (thread, "Application under stress - try later", NULL);
}
/************************* SESSION END PROCESSING ************************/
MODULE session_end_processing (THREAD *thread)
{
SYMBOL
*symbol; /* Symbol in context table */
tcb = thread-> tcb; /* Point to thread's context */
tcb-> info-> cur_sessions--; /* Update info block */
/* Go through context table, and delete symbol context blocks. */
symbol = tcb-> session_context-> symbols;
while (symbol)
{
mem_free (symbol-> data);
symbol = symbol-> next;
}
sym_delete_table (tcb-> session_context);
/* Free program call stack and other areas */
while (tcb-> stack_ptr > 0)
{
tcb-> stack_ptr--;
mem_free (tcb-> call_stack [tcb-> stack_ptr]);
}
mem_free (tcb-> call_stack);
mem_free (tcb-> session_screen);
unuse_programs_table (tcb);
unuse_servers_table (tcb);
unuse_info_table (tcb);
}
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
S E R V E R T H R E A D
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
/************************** READ SERVER MESSAGE **************************/
MODULE read_server_message (THREAD *thread)
{
tcb = thread-> tcb; /* Point to thread's context */
/* WTP messages are compatible with the GET_BLOCK method of SMTTRAN */
send_get_huge (&tranq, tcb-> handle, NULL);
event_wait (); /* Wait for transfer agent reply */
}
/************************* DECODE SERVER MESSAGE *************************/
MODULE decode_server_message (THREAD *thread)
{
struct_wtp_msg
*wtp_msg = NULL;
tcb = thread-> tcb; /* Point to thread's context */
if (the_external_event == ok_event)
{
/* Free any previous message, then get new one from event body */
mem_strfree (&tcb-> server_msg);
exdr_read (thread-> event-> body, SMT_TRAN_GETH_OK,
&tcb-> server_msgsize, &tcb-> server_msg);
/* Get just the message type */
get_wtp_msg ((byte *) tcb-> server_msg, &wtp_msg);
tcb-> message_type = wtp_msg-> type;
free_wtp_msg (&wtp_msg);
switch (tcb-> message_type)
{
case WTP_CONNECT:
the_next_event = wtp_connect_event;
break;
case WTP_REGISTER:
the_next_event = wtp_register_event;
break;
case WTP_READY:
the_next_event = wtp_ready_event;
break;
case WTP_DISCONNECT:
the_next_event = wtp_disconnect_event;
break;
case WTP_OK:
the_next_event = wtp_ok_event;
break;
case WTP_ERROR:
the_next_event = wtp_error_event;
break;
case WTP_DO:
the_next_event = wtp_do_event;
break;
case WTP_DONESHOW: /* We handle these in much the */
case WTP_DONECALL: /* way; reply to session thread */
case WTP_DONERETURN:
case WTP_DONEEXIT:
case WTP_DONEERROR:
the_next_event = wtp_done_event;
break;
default:
the_next_event = error_event;
}
}
else
raise_exception (the_external_event);
}
/************************ HANDLE SERVER CONNECTION ***********************/
MODULE handle_server_connection (THREAD *thread)
{
struct_wtp_msg_connect
*wtp_msg = NULL;
int
server_nbr; /* Index into application servers */
long
callback;
SERVER
*server; /* Entry into servers table */
tcb = thread-> tcb; /* Point to thread's context */
get_wtp_msg_connect ((byte *) tcb-> server_msg, &wtp_msg);
/* Look for server with matching callback key */
callback = atol (wtp_msg-> callback_key);
for (server_nbr = 0; server_nbr < tcb-> nbr_servers; server_nbr++)
{
server = &tcb-> servers-> table [server_nbr];
if (server-> callback == callback)
break;
}
/* Did we find it okay? */
if (server_nbr < tcb-> nbr_servers)
{
ASSERT (server-> thread == NULL);
tcb-> server_name = mem_strdup (atp_name_value (server-> atp));
tcb-> server_index = server_nbr;
server-> thread = thread;
server-> signature = wtp_msg-> signature;
}
else
{
sendfmt (&operq, "ERROR",
"wtpman: unauthorised server callback: %s",
wtp_msg-> callback_key);
raise_exception (error_event);
}
free_wtp_msg_connect (&wtp_msg);
}
/*********************** HANDLE SERVER REGISTRATION **********************/
MODULE handle_server_registration (THREAD *thread)
{
struct_wtp_msg_register
*wtp_msg = NULL;
SYMBOL
*symbol; /* Newly-created symbol */
tcb = thread-> tcb; /* Point to thread's context */
get_wtp_msg_register ((byte *) tcb-> server_msg, &wtp_msg);
strupc (wtp_msg-> program);
/* Create new entry in program lookup table; don't check duplicates
* If the program is a root program, its value is set to "ROOT", else
* to null.
*/
symbol = sym_create_symbol (tcb-> programs-> table, wtp_msg-> program, NULL);
if (symbol == NULL)
{
wtp_send_msg_error (thread, WTP_ERRORFATAL);
raise_exception (out_of_memory_event);
}
else
{
wtp_send_msg_ok (thread);
symbol-> data = thread;
if (wtp_msg-> is_root)
symbol-> value = mem_strdup ("ROOT");
}
free_wtp_msg_register (&wtp_msg);
}
static void
wtp_send_msg_error (THREAD *thread, dbyte code)
{
byte
*buffer; /* Buffer holds formatted WTP msg */
qbyte
size; /* Size of formatted message */
tcb = thread-> tcb; /* Point to thread's context */
size = put_wtp_msg_error (&buffer, WTP_ERROR, code, "Error");
send_put_huge (&tranq, tcb-> handle, size, buffer, NULL);
mem_free (buffer);
}
static void
wtp_send_msg_ok (THREAD *thread)
{
byte
*buffer; /* Buffer holds formatted WTP msg */
qbyte
size; /* Size of formatted message */
tcb = thread-> tcb; /* Point to thread's context */
size = put_wtp_msg_ok (&buffer, WTP_OK);
send_put_huge (&tranq, tcb-> handle, size, buffer, NULL);
mem_free (buffer);
}
/************************** HANDLE SERVER READY **************************/
MODULE handle_server_ready (THREAD *thread)
{
wtp_send_msg_ok (thread);
}
/************************** WTP SEND DO PROGRAM **************************/
MODULE wtp_send_do_program (THREAD *thread)
{
struct_wtp_msg_do
*wtp_msg = NULL;
byte
*buffer; /* Buffer holds formatted WTP msg */
qbyte
size; /* Size of formatted message */
tcb = thread-> tcb; /* Point to thread's context */
/* Set reply QID for all eventual responses */
tcb-> session_qid = thread-> event-> sender;
/* Event body holds a DO message complete except for the signature.
* We have to decode it, sign it, rebuild it, and send it to the
* server process.
*/
get_wtp_msg_do (thread-> event-> body, &wtp_msg);
size = put_wtp_msg_do (&buffer, WTP_DO,
tcb-> servers-> table [tcb-> server_index].signature,
wtp_msg-> program,
wtp_msg-> entry_code,
wtp_msg-> http_uri,
wtp_msg-> http_data,
wtp_msg-> args_size,
wtp_msg-> args_data,
wtp_msg-> call_result,
wtp_msg-> env_size,
wtp_msg-> env_data,
wtp_msg-> global_size,
wtp_msg-> global_data,
wtp_msg-> local_size,
wtp_msg-> local_data);
send_put_huge (&tranq, tcb-> handle, size, buffer, NULL);
mem_free (buffer);
free_wtp_msg_do (&wtp_msg);
tcb-> server_ready = FALSE;
tcb-> entry_time = time_now ();
}
/*************************** HANDLE SERVER DONE **************************/
MODULE handle_server_done (THREAD *thread)
{
char
*method = NULL; /* Method to send to session */
int
elapsed_time; /* Transaction elapsed time */
tcb = thread-> tcb; /* Point to thread's context */
switch (tcb-> message_type)
{
case WTP_DONESHOW:
method = "_SESSION_SHOW";
break;
case WTP_DONECALL:
method = "_SESSION_CALL";
break;
case WTP_DONERETURN:
method = "_SESSION_RETURN";
break;
case WTP_DONEEXIT:
method = "_SESSION_EXIT";
break;
case WTP_DONEERROR:
method = "_SESSION_ERROR";
break;
default:
sendfmt (&operq, "ERROR", "wtpman: handle_server_done() failed");
}
/* Unless there was a screw-up, send the ATP message through as-is to
* the session thread. The contents of the message depend on the type
* of the message.
*/
if (method)
event_send (
&tcb-> session_qid,
NULL,
method,
(byte *) tcb-> server_msg,
tcb-> server_msgsize,
NULL, NULL, NULL, 0);
/* Compute elapsed time and total so far */
elapsed_time = time_to_csecs (time_now ())
- time_to_csecs (tcb-> entry_time);
if (elapsed_time < 0) /* Passed over midnight */
elapsed_time += INTERVAL_DAY;
tcb-> info-> trans_count += 1;
tcb-> info-> trans_cost += elapsed_time;;
}
/*************************** SERVER SET TIMEOUT **************************/
MODULE server_set_timeout (THREAD *thread)
{
long
timeout; /* Timeout in seconds */
tcb = thread-> tcb; /* Point to thread's context */
timeout = atol (TCONFIG ("general:program_timeout", "60"));
timeout = timeout * 100; /* Seconds => 1/100th seconds */
send_alarm (&timeq, 0, timeout, 0, NULL);
}
/************************* WTP SEND NOT EXPECTED *************************/
MODULE wtp_send_not_expected (THREAD *thread)
{
wtp_send_msg_error (thread, WTP_ERRORUNEXPECTED);
}
/************************* WTP SEND NOT CONNECTED ************************/
MODULE wtp_send_not_connected (THREAD *thread)
{
wtp_send_msg_error (thread, WTP_ERRORUNCONNECTED);
}
/************************ WTP SEND NOT AUTHORISED ************************/
MODULE wtp_send_not_authorised (THREAD *thread)
{
wtp_send_msg_error (thread, WTP_ERRORUNAUTHORISED);
}
/**************************** WTP SEND INVALID ***************************/
MODULE wtp_send_invalid (THREAD *thread)
{
wtp_send_msg_error (thread, WTP_ERRORINVALID);
}
/************************* TAKE DO REQUEST IF ANY ************************/
MODULE take_do_request_if_any (THREAD *thread)
{
EVENT
*event; /* Event information block */
tcb = thread-> tcb; /* Point to thread's context */
/* Get next event off queue */
event = event_iterate (tcb-> do_queue, NULL);
if (event)
{
if (thread-> event) /* Release any thread event */
event_destroy (thread-> event);
/* Get event off queue; it now belongs to the thread */
thread-> event = event_accept (tcb-> do_queue, event);
the_next_event = ok_event;
}
else
the_next_event = not_found_event;
}
/************************ SERVER PROCESS IS READY ************************/
MODULE server_process_is_ready (THREAD *thread)
{
tcb = thread-> tcb; /* Point to thread's context */
tcb-> server_ready = TRUE;
}
/************************ SIGNAL SERVER TIMED OUT ************************/
MODULE signal_server_timed_out (THREAD *thread)
{
tcb = thread-> tcb; /* Point to thread's context */
/* Tell application thread to check & refresh its server table */
sendfmt (&tcb-> applic_qid, "_REFRESH", "");
sendfmt (&operq, "ERROR", "wtpman: server '%s' looping", tcb-> server_name);
/* Tell session thread to forget it, and inform the user */
sendfmt (&tcb-> session_qid, "_SERVER_TIMEOUT", "");
}
/************************* SIGNAL SERVER ABORTED *************************/
MODULE signal_server_aborted (THREAD *thread)
{
tcb = thread-> tcb; /* Point to thread's context */
/* Tell application thread to check & refresh its server table */
sendfmt (&tcb-> applic_qid, "_REFRESH", "");
sendfmt (&operq, "ERROR", "wtpman: server '%s' aborted", tcb-> server_name);
/* Tell session thread to forget it, and inform the user */
sendfmt (&tcb-> session_qid, "_SERVER_ABORT", "");
}
/************************* SERVER END PROCESSING *************************/
MODULE server_end_processing (THREAD *thread)
{
PROCESS
*pid;
SYMBOL
*symbol,
*next;
tcb = thread-> tcb; /* Point to thread's context */
/* Kill server process if it is still running */
pid = &tcb-> servers-> table [tcb-> server_index].pid;
if (*pid != NULL_PROCESS)
{
if (process_status (*pid) == PROCESS_RUNNING)
process_kill (*pid);
else
process_close (*pid);
*pid = NULL_PROCESS;
}
/* Go through program symbol table, and delete any symbols that refer
* to this thread.
*/
symbol = tcb-> programs-> table-> symbols;
while (symbol)
{
next = symbol-> next;
if (symbol-> data == thread)
sym_delete_symbol (tcb-> programs-> table, symbol);
symbol = next;
}
/* As far as the applic thread is concerned, we're gone */
tcb-> servers-> table [tcb-> server_index].thread = NULL;
unuse_programs_table (tcb);
unuse_servers_table (tcb);
unuse_info_table (tcb);
}
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
A L L T H R E A D S
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
/************************ CLEAR ALARMS FOR THREAD ************************/
MODULE clear_alarms_for_thread (THREAD *thread)
{
tcb = thread-> tcb; /* Point to thread's context */
event_send (
&timeq,
&thread-> queue-> qid,
"FLUSH",
NULL, 0,
NULL, NULL, NULL, 0);
}
/************************** SIGNAL SOCKET ERROR **************************/
MODULE signal_socket_error (THREAD *thread)
{
tcb = thread-> tcb; /* Point to thread's context */
sendfmt (&operq, "ERROR",
"wtpman: error on socket: %s", thread-> event-> body);
}
/************************** SIGNAL OUT OF MEMORY *************************/
MODULE signal_out_of_memory (THREAD *thread)
{
tcb = thread-> tcb; /* Point to thread's context */
sendfmt (&operq, "ERROR", "wtpman: no memory available");
sprintf (server_message, "Insufficient memory");
}
/************************** SIGNAL INVALID EVENT *************************/
MODULE signal_invalid_event (THREAD *thread)
{
tcb = thread-> tcb; /* Point to thread's context */
sendfmt (&operq, "ERROR", "wtpman: invalid dialog event detected");
}
/*************************** CHECK THREAD TYPE ***************************/
MODULE check_thread_type (THREAD *thread)
{
tcb = thread-> tcb; /* Point to thread's context */
the_next_event = tcb-> thread_type;
}
/************************ SHUTDOWN THE APPLICATION ***********************/
MODULE shutdown_the_application (THREAD *thread)
{
tcb = thread-> tcb; /* Point to thread's context */
smt_shutdown (); /* Halt the application */
}
/************************* TERMINATE THE THREAD **************************/
MODULE terminate_the_thread (THREAD *thread)
{
tcb = thread-> tcb; /* Point to thread's context */
if (tcb-> handle)
close_socket (tcb-> handle);
/* Potentially used in each thread */
mem_free (tcb-> server_msg);
mem_free (tcb-> server_name);
mem_free (tcb-> session_program);
mem_free (tcb-> session_request);
mem_free (tcb-> session_envdata);
/* Allocated by applic thread but shared by server & session threads: */
if (tcb-> thread_type == master_event)
{
sym_delete_table (tcb-> config_table);
mem_free (tcb-> config_file);
}
else
if (tcb-> thread_type == applic_event)
{
if (tcb-> do_queue)
queue_destroy (tcb-> do_queue);
sym_delete_table (tcb-> config_table);
mem_free (tcb-> config_file);
mem_free (tcb-> applic_uri);
mem_free (tcb-> applic_name);
}
the_next_event = terminate_event;
}