static int
proc_auth(tc_sess_t *s, tc_iph_t *ip, tc_tcph_t *tcp)
{
uint16_t size_tcp;
unsigned char *p, *payload, pack_number;
tc_mysql_session *mysql_sess;
if (!s->sm.rcv_rep_greet) {
return PACK_STOP;
}
mysql_sess = s->data;
if (!s->sm.fake_syn) {
if (!mysql_sess->req_begin) {
size_tcp = tcp->doff << 2;
payload = (unsigned char *) ((char *) tcp + size_tcp);
/* skip packet length */
payload = payload + 3;
pack_number = payload[0];
if (pack_number == 0) {
mysql_sess->req_begin = 1;
mysql_sess->old_ps_cleaned = 1;
tc_log_debug0(LOG_NOTICE, 0, "it has no sec auth packet");
release_resources(s->hash_key);
} else if (pack_number == (unsigned char) SEC_AUTH_PACKET_NUM) {
/* if it is the second authenticate_user, skip it */
tc_log_debug0(LOG_NOTICE, 0, "omit sec validation for mysql");
mysql_sess->req_begin = 1;
mysql_sess->seq_diff = s->cur_pack.cont_len;
mysql_sess->old_ps_cleaned = 1;
release_resources(s->hash_key);
return PACK_NEXT;
}
}
if (!mysql_sess->req_begin) {
if (!ctx.fir_auth_pack) {
p = cp_fr_ip_pack(ctx.pool, ip);
ctx.fir_auth_pack = (tc_iph_t *) (p + ETHERNET_HDR_LEN);
ctx.fir_auth_cont_len = s->cur_pack.cont_len;
tc_log_info(LOG_NOTICE, 0, "fir auth is set");
}
}
} else {
if (!mysql_sess->old_ps_cleaned) {
mysql_sess->old_ps_cleaned = 1;
release_resources(s->hash_key);
}
}
return PACK_CONTINUE;
}
SoundOutput_DirectSound::~SoundOutput_DirectSound()
{
stop_mixer_thread();
if (soundbuffer)
soundbuffer->Stop();
release_resources();
}
SoundOutput_DirectSound::SoundOutput_DirectSound(int mixing_frequency, int mixing_latency)
: SoundOutput_Impl(mixing_frequency, mixing_latency), directsound(0), soundbuffer(0),
frag_size(0), sleep_event(0), hwnd(0), notify(0), has_sound(true), last_write_pos(-1)
{
try
{
create_directsound_object();
set_cooperative_level();
set_fragment_size();
create_sound_buffer();
verify_sound_buffer_capabilities();
clear_sound_buffer();
create_notify_event();
retrieve_notify_interface();
set_notify_positions();
play_sound_buffer();
}
catch (const Exception &e)
{
release_resources();
log_event("mixer", e.message);
frag_size = mixing_frequency/2;
has_sound = false;
}
}
void statement_imp::prepare (std::string const& query, bool bRepeatable)
{
m_query = query;
m_session.log_query(query);
m_last_insert_rowid = 0;
release_resources();
char const* tail = 0;
int result = sqlite3_prepare_v2(
m_session.get_connection(),
query.c_str(),
static_cast<int>(query.size()),
&m_stmt,
&tail );
if (result == SQLITE_OK)
{
m_bReady = true;
}
else
{
Throw (detail::sqliteError (__FILE__, __LINE__, result));
}
}
void clean(){
int i;
int flag = FALSE;
lock_repo();
for (i=0; i<REPO_SIZE; ++i) {
if (SHM_SERVER_IDS_ADRESS[i] == MSG_RECEIVER) {
SHM_SERVER_IDS_ADRESS[i] = -1;
} else if (SHM_SERVER_IDS_ADRESS[i] != -1) {
flag = TRUE;
}
}
unlock_repo();
for(i=0; i<MAX_USERS_NUMBER; ++i) {
if (LOCAL_REPO[i].client_id != -1){
MSG_LOGIN user;
user.ipc_num = LOCAL_REPO[i].client_id;
strcpy(user.username, LOCAL_REPO[i].user_name);
unregister_user(user);
}
}
log_data("DEAD");
//we are last server so we clean whole repo
if(!flag){
log_data("CLEANING REPOSITORY");
clean_repo();
}
release_resources();
signal(SIGINT, SIG_DFL);
exit(EXIT_SUCCESS);
}
/*
* Log & Quit
*/
void
quit_route6d(char *s, int ret_code)
{
if (s)
syslog(LOG_ERR, "%s: %m", s);
release_resources();
exit(ret_code);
}
int main(int argc, char **argv)
{
t_core c;
if (!init(&c))
return (0);
loop(&c);
release_resources(&c);
release_levels(&c);
free(c.rdf);
(void)argc;
(void)argv;
return (1);
}
int openib_initialize()
{
// Use the previously cached info
me = l_state.rank;
nprocs = l_state.size;
assert(l_state.world_comm);
// initialize the envs
openib_init_envs();
//Initialize the registration cache
reg_cache_init(nprocs, 0);
init_params();
if(open_hca()) {
release_resources();
exit(1);
}
if(create_cq()) {
release_resources();
exit(1);
}
if(get_lid()) {
release_resources();
exit(1);
}
if(create_qp()) {
release_resources();
exit(1);
}
if(exch_addr()) {
release_resources();
exit(1);
}
if(connect_qp()) {
release_resources();
exit(1);
}
// Create network locks
openib_create_locks();
// Allocate buffers for one sided operations
openib_alloc_buf();
MPI_Barrier(l_state.world_comm);
return 0;
}
static void
signal_handler(int sig)
{
tc_log_info(LOG_ERR, 0, "set signal handler:%d", sig);
printf("set signal handler:%d\n", sig);
if (sig == SIGSEGV) {
tc_log_info(LOG_ERR, 0, "SIGSEGV error");
release_resources();
/* avoid dead loop*/
signal(SIGSEGV, SIG_DFL);
kill(getpid(), sig);
} else {
exit(EXIT_SUCCESS);
}
}
static void
remove_obsolete_resources(int is_full)
{
time_t thresh_access_tme;
uint32_t i, cnt = 0;
link_list *l;
hash_node *hn;
p_link_node ln, next_ln;
if (ctx.table == NULL || ctx.table->total == 0) {
return;
}
if (is_full) {
thresh_access_tme = tc_time() + 1;
} else {
thresh_access_tme = tc_time() - MAX_IDLE_TIME;
}
for (i = 0; i < ctx.table->size; i ++) {
l = get_link_list(ctx.table, i);
if (l->size > 0) {
ln = link_list_first(l);
while (ln) {
hn = (hash_node *) ln->data;
next_ln = link_list_get_next(l, ln);
if (hn->access_time < thresh_access_tme) {
release_resources(hn->key);
}
ln = next_ln;
}
cnt += l->size;
if (ctx.table->total == cnt) {
break;
}
}
}
}
void *thread_create(void *cno)
{
int ii,j,request[NUMBER_OF_RESOURCES],request_flag=0;
int cust_no = (int)cno;
//Create a random request
for(ii=0;ii<NUMBER_OF_RESOURCES;ii++)
{
//this will be always less than the max that can be requested
request[ii] = rand() % available[ii];
}
//Resource allocated depending on safety and this customer waits on request
if(request_resources(cust_no,request)<0)
{
printf("\n Customer %d ", cust_no);
for(j=0;j<NUMBER_OF_RESOURCES;j++)
printf("%d ", request[j]);
printf(":Request Denied\n");
}
else
{
request_flag = 1;
printf("\n Customer %d ", cust_no);
for(j=0;j<NUMBER_OF_RESOURCES;j++)
printf("%d ", request[j]);
printf(":Request Accepted\n");
}
//sleep for a random amount of time
sleep(rand() % 10);
//Release the resource if allocated
if(request_flag==1)
{
release_resources(cust_no, request);
printf("\n Customer %d released resouces", cust_no);
}
}
void
parse_file(PARROT_INTERP, int flexdebug, ARGIN(FILE *infile),
ARGIN(char * const filename), int flags,
int thr_id, unsigned macro_size,
ARGMOD_NULLOK(char * const outputfile))
{
ASSERT_ARGS(parse_file)
yyscan_t yyscanner;
lexer_state *lexer = NULL;
/* create a yyscan_t object */
yypirlex_init(&yyscanner);
/* set debug flag */
yypirset_debug(flexdebug, yyscanner);
/* set the input file */
yypirset_in(infile, yyscanner);
/* set the extra parameter in the yyscan_t structure */
lexer = new_lexer(interp, filename, flags);
lexer->macro_size = macro_size;
/* initialize the scanner state */
init_scanner_state(yyscanner);
if (strstr(filename, ".pasm")) { /* PASM mode */
SET_FLAG(lexer->flags, LEXER_FLAG_PASMFILE);
}
yypirset_extra(lexer, yyscanner);
/* and store the yyscanner in the lexer, so they're close buddies */
lexer->yyscanner = yyscanner;
/* go parse */
yypirparse(yyscanner, lexer);
if (lexer->parse_errors == 0) {
char outfile[20];
sprintf(outfile, "output_thr_%d", thr_id);
lexer->outfile = open_file(outfile, "w");
if (lexer->outfile == NULL) {
fprintf(stderr, "Failed to open file %s\n", outfile);
lexer->outfile = stdout;
}
if (TEST_FLAG(lexer->flags, LEXER_FLAG_NOOUTPUT)) /* handy for testing the compiler */
fprintf(stdout, "ok\n");
else if (TEST_FLAG(lexer->flags, LEXER_FLAG_PREPROCESS))
emit_pir_subs(lexer, outputfile);
else if (TEST_FLAG(lexer->flags, LEXER_FLAG_OUTPUTPBC))
emit_pbc(lexer, outputfile);
else
/*
fprintf(stderr, "Parse successful!\n");
*/
print_subs(lexer);
fclose(lexer->outfile);
if (TEST_FLAG(lexer->flags, LEXER_FLAG_WARNINGS))
check_unused_symbols(lexer);
}
/* there may have been errors during the instruction generation, check again here. */
if (lexer->parse_errors > 0)
fprintf(stderr, "There were %d errors\n", lexer->parse_errors);
fclose(infile);
/* XXX just want to make sure pirc doesn't segfault when doing bytecode stuff. */
/*
if (TEST_FLAG(lexer->flags, LEXER_FLAG_OUTPUTPBC))
fprintf(stderr, "pirc ok\n");
*/
/* clean up after playing */
release_resources(lexer);
yypirlex_destroy(yyscanner);
}
/*
=item C<void parse_string(PARROT_INTERP, char *pirstring, int flags, int
pasminput, unsigned macro_size)>
Parse a PIR string.
=cut
*/
void
parse_string(PARROT_INTERP, ARGIN(char *pirstring), int flags, int pasminput,
unsigned macro_size)
{
ASSERT_ARGS(parse_string)
yyscan_t yyscanner;
lexer_state *lexer = NULL;
char name[64];
PackFile_ByteCode *old_cs, *new_cs;
INTVAL eval_number;
if (eval_nr == 0)
MUTEX_INIT(eval_nr_lock);
LOCK(eval_nr_lock);
eval_number = ++eval_nr;
UNLOCK(eval_nr_lock);
snprintf(name, sizeof (name), "EVAL_" INTVAL_FMT, eval_number);
new_cs = PF_create_default_segs(interp, Parrot_str_new(interp, name, strlen(name)), 0);
old_cs = Parrot_switch_to_cs(interp, new_cs, 0);
/* create a yyscan_t object */
yypirlex_init(&yyscanner);
yypirset_debug(0, yyscanner);
/* set the extra parameter in the yyscan_t structure */
lexer = new_lexer(interp, name, flags);
lexer->macro_size = macro_size;
yypirset_extra(lexer, yyscanner);
lexer->yyscanner = yyscanner;
/* initialize the scanner state */
init_scanner_state(yyscanner);
/* set the scanner to a string buffer and go parse */
yypir_scan_string(pirstring, yyscanner);
if (pasminput) { /* PASM mode */
SET_FLAG(lexer->flags, LEXER_FLAG_PASMFILE);
}
yypirparse(yyscanner, lexer);
if (lexer->parse_errors == 0) {
print_subs(lexer);
if (TEST_FLAG(lexer->flags, LEXER_FLAG_WARNINGS))
check_unused_symbols(lexer);
}
/* there may have been errors during the instruction generation, check again here. */
if (lexer->parse_errors > 0)
fprintf(stderr, "There were %d errors\n", lexer->parse_errors);
/* XXX just want to make sure pirc doesn't segfault when doing bytecode stuff. */
if (TEST_FLAG(lexer->flags, LEXER_FLAG_OUTPUTPBC)) {
emit_pbc(lexer, NULL);
}
/*
fprintf(stderr, "ok\n");
*/
/* clean up after playing */
release_resources(lexer);
/* clean up after playing */
yypirlex_destroy(yyscanner);
}
void statement_imp::clean_up()
{
erase_bindings();
release_resources();
}
int openib_finalize()
{
release_resources();
}
file_system_watcher::path_watcher::~path_watcher()
{ try { release_resources(); } catch( const std::exception& exception ) { assert(false); } }
void term() {
release_resources();
if(device) { device->Release(); device = 0; }
if(lpd3d) { lpd3d->Release(); lpd3d = 0; }
}
static int
proc_when_sess_destroyed(tc_sess_t *s)
{
release_resources(s->hash_key);
return TC_OK;
}