void session_delete(t_session *session) { t_context *context; t_session *tmp; t_session *tmp2; session_end(session); context = get_context_ptr((void *)0); VERBOSE(printf("\033[%d;1m<%03d> - session delete\033[m\n", COLOR(session->id), session->id)); tmp = context->sessions; if (tmp == session) { context->sessions = tmp->next; session_free(tmp); return ; } tmp2 = tmp; tmp = tmp->next; for (tmp2 = tmp, tmp = tmp->next; tmp && tmp != session; tmp = tmp->next, tmp2 = tmp2->next) ; if (tmp == session) { tmp2->next = tmp->next; session_free(tmp); } return ; }
void fe_close_window (struct session *sess) { /* * There's really no point in doing all of this if the user is * quitting the app. It makes it slow (as they watch individual * channels and servers disappear), and the OS is about to free * everything much more efficiently than we ever could. * * If we ever choose to run on Windows ME, this could be a problem :) */ if (gui.quit) { session_free (sess); return; } navigation_tree_remove_session (gui.server_tree, sess); conversation_panel_remove_session (CONVERSATION_PANEL (gui.conversation_panel), sess); topic_label_remove_session (TOPIC_LABEL (gui.topic_label), sess); text_entry_remove_session (TEXT_ENTRY (gui.text_entry), sess); if (sess->type == SESS_SERVER) { status_bar_remove_server (STATUS_BAR (gui.status_bar), sess->server); } if (sess == gui.current_session) { gui.current_session = NULL; } session_free (sess); }
/* * Handle socket events, such as connection failure or success. * - BEV_EVENT_ERROR - network is unreachable * - BEV_EVENT_ERROR+READING - connection refused or connection timed out * - BEV_EVENT_TIMEOUT+READING - write timeout, if activated by * bufferevent_set_timeouts */ static void session_eventcb(struct bufferevent *bev, short what, void *thunk) { struct session *session = thunk; switch (what & ~(BEV_EVENT_READING|BEV_EVENT_WRITING)) { case BEV_EVENT_CONNECTED: session_send(session); return; case BEV_EVENT_EOF: bufferevent_disable(bev, EV_READ|EV_WRITE); if (session->completed) target_mark(session->t, session->seq, '.'); else target_mark(session->t, session->seq, '%'); break; case BEV_EVENT_ERROR: bufferevent_disable(bev, EV_READ|EV_WRITE); target_mark(session->t, session->seq, '#'); break; case BEV_EVENT_TIMEOUT: target_mark(session->t, session->seq, '?'); break; } session_free(session); }
/* Called from main context */ static void sink_input_kill(pa_sink_input* i) { struct session *s; pa_sink_input_assert_ref(i); pa_assert_se(s = i->userdata); session_free(s); }
inline NSAPIEnvironment::~NSAPIEnvironment() { // Tidy up the thread-specific "globals" for the next caller conf_reset_thread_globals(); // Discard the request if (rq) request_free(rq); // Discard the session if (sn) { if (sn->csd && sn->csd_open) PR_Close(sn->csd); sn->csd_open = 0; session_free(sn); } // Restore the caller's pool. session_free() set it to NULL if (poolCaller) systhread_setdata(keyPool, poolCaller); // This may have been a request thread. If it was, we need to restore the // HttpRequest* for the thread-specific "globals". if (hrq) { HttpRequest::SetCurrentRequest(hrq); conf_set_thread_globals(hrq); } else { conf_set_thread_globals(threadHrq, threadVS); } }
PRIVATE void signal_handler(int sig) { switch (sig) { case SIGINT: case SIGTERM: { dbg_printf(P_INFO2, "SIGTERM/SIGINT caught"); closing = true; break; } case SIGHUP: { if(isRunning || !mySession) { seenHUP = true; } else { auto_handle * s = NULL; dbg_printf(P_MSG, "Caught SIGHUP. Reloading config file."); s = session_init(); if((parse_config_file(s, AutoConfigFile) != 0) || !setupSession(s)) { dbg_printf(P_ERROR, "Error parsing config file. Keeping the old settings."); session_free(s); } seenHUP = false; } break; } } }
static void ssh_relay_event_cb(struct bufferevent *bev, short what, void *ptr) { obfsproxyssh_client_session_t *session = ptr; struct evbuffer *buf; assert(bev == session->ssh_ev); if (what & (BEV_EVENT_EOF | BEV_EVENT_ERROR)) { session->ssh_is_valid = 0; libssh2_channel_free(session->ssh_channel); session->ssh_channel = NULL; libssh2_session_free(session->ssh_session); session->ssh_session = NULL; buf = bufferevent_get_output(session->socks_ev); if (0 == session->socks_is_valid || 0 == evbuffer_get_length(buf)) session_free(session); else { bufferevent_disable(session->socks_ev, EV_READ); bufferevent_setcb(session->socks_ev, NULL, socks_relay_teardown_cb, socks_event_cb, session); } } }
static void on_disconnect(netc_t *netc) { struct session *session; session = netc->ext_ptr; session_free(session); }
/** @brief Free a transport_client, along with all resources it owns. @param client Pointer to the transport_client to be freed. @return 1 if successful, or 0 if not. The only error condition is if @a client is NULL. */ int client_free( transport_client* client ) { if(client == NULL) return 0; session_free( client->session ); client->session = NULL; return client_discard( client ); }
void obc_session_unref(struct obc_session *session) { int refs; refs = __sync_sub_and_fetch(&session->refcount, 1); DBG("%p: ref=%d", session, refs); if (refs > 0) return; sessions = g_slist_remove(sessions, session); if (!session->obex) goto disconnect; /* Wait OBEX Disconnect to complete if command succeed otherwise * proceed with transport disconnection since there is nothing else to * be done */ if (g_obex_disconnect(session->obex, disconnect_complete, session, NULL)) return; disconnect: /* Disconnect transport */ if (session->id > 0 && session->transport != NULL) { session->transport->disconnect(session->id); session->id = 0; } session_free(session); }
int session_mem_create(session_opt_t *so, request_t *rq, response_t *rs, session_t **pss) { session_t *ss = NULL; dbg_err_if (so == NULL); dbg_err_if (rq == NULL); dbg_err_if (rs == NULL); dbg_err_if (pss == NULL); ss = u_zalloc(sizeof(session_t)); dbg_err_if(ss == NULL); ss->load = session_mem_load; ss->save = session_mem_save; ss->remove = session_mem_remove; ss->term = session_mem_term; ss->mtime = time(0); ss->so = so; dbg_err_if(session_prv_init(ss, rq, rs)); *pss = ss; return 0; err: if(ss) session_free(ss); return ~0; }
static void ssh_auth_cb(obfsproxyssh_client_session_t *session) { obfsproxyssh_t *state = session->client->state; int rval; rval = libssh2_userauth_publickey(session->ssh_session, bdata(session->user), get_rsa_public_key(session->privkey), get_rsa_public_key_len(session->privkey), sign_with_private_key, &session->privkey); if (LIBSSH2_ERROR_EAGAIN == rval) return; else if (0 != rval) { log_f(state, "SSH: Error: %s Failed to authenticate - %d", bdata(session->ssh_addr), rval); libssh2_session_free(session->ssh_session); session->ssh_session = NULL; session_free(session); return; } session->libssh2_cb = ssh_channel_cb; session->libssh2_cb(session); }
static void socks_relay_teardown_cb(struct bufferevent *bev, void *ptr) { obfsproxyssh_client_session_t *session = ptr; session_free(session); }
// This callback is received whenever a session is closed. The RISP session itself will be destroyed right after this callback exits. void connclosed_cb(RISPSESSION streamsession, void *dataptr) { assert(streamsession); assert(dataptr); maindata_t *maindata = dataptr; assert(maindata); assert(maindata->verify == 0xc001b33f); // we need to go through the list in maindata, to find this particular session. When we have found it, we remove it. assert(maindata->sessions.list); assert(maindata->sessions.max > 0); fprintf(stderr, "Session Closed. Finding in the list. Max:%d\n", maindata->sessions.max); short found = 0; for (int index=0; index < maindata->sessions.max; index++) { if (maindata->sessions.list[index]) { if (maindata->sessions.list[index]->session_ptr == streamsession) { // free the resources used by the session, and the session object itself. session_free(maindata->sessions.list[index]); // clear the entry in the list. maindata->sessions.list[index] = NULL; // we found the one we were looking for, so mark it, and exit the loop. found = 1; index = maindata->sessions.max; } } } // we should have found one in that list. assert(found == 1); }
/** * Free the memory associated with the session * * @param instance The filter instance * @param session The filter session */ static void freeSession(FILTER *instance, void *session) { TEE_SESSION *my_session = (TEE_SESSION *)session; SESSION* ses = my_session->branch_session; session_state_t state; #ifdef SS_DEBUG skygw_log_write(LOGFILE_TRACE,"Tee free: %d", atomic_add(&debug_seq,1)); #endif if (ses != NULL) { state = ses->state; if (state == SESSION_STATE_ROUTER_READY) { session_free(ses); } else if (state == SESSION_STATE_TO_BE_FREED) { /** Free branch router session */ ses->service->router->freeSession( ses->service->router_instance, ses->router_session); /** Free memory of branch client session */ ses->state = SESSION_STATE_FREE; free(ses); /** This indicates that branch session is not available anymore */ my_session->branch_session = NULL; } else if(state == SESSION_STATE_STOPPING) { orphan_session_t* orphan; if((orphan = malloc(sizeof(orphan_session_t))) == NULL) { skygw_log_write(LOGFILE_ERROR,"Error : Failed to " "allocate memory for orphan session struct, " "child session might leak memory."); }else{ orphan->session = ses; spinlock_acquire(&orphanLock); orphan->next = allOrphans; allOrphans = orphan; spinlock_release(&orphanLock); } } } if (my_session->dummy_filterdef) { filter_free(my_session->dummy_filterdef); } if(my_session->tee_replybuf) gwbuf_free(my_session->tee_replybuf); free(session); orphan_free(NULL); return; }
PRIVATE void shutdown_daemon(auto_handle *as) { dbg_printft(P_MSG, "Shutting down daemon"); if (as && as->bucket_changed) { save_state(as->statefile, as->downloads); } session_free(as); SessionID_free(); log_close(); exit(EXIT_SUCCESS); }
static void setup_destroy(void *user_data) { struct network_adapter *na = user_data; struct network_session *setup = na->setup; if (!setup) return; na->setup = NULL; session_free(setup); }
static int manager_sysview_session_remove(Manager *m, sysview_event *event) { sysview_session *session = event->session_remove.session; Session *s; s = sysview_session_get_userdata(session); if (!s) return 0; session_free(s); return 0; }
static void audio_client_free(struct audio_client *ac) { session_free(ac->session, ac); if (ac->buf[0].data) dma_free_coherent(NULL, ac->buf[0].size, ac->buf[0].data, ac->buf[0].phys); if (ac->buf[1].data) dma_free_coherent(NULL, ac->buf[1].size, ac->buf[1].data, ac->buf[1].phys); kfree(ac); }
NBBOOL session_delete(sessions_t *sessions, char *name) { session_t *session = sessions->first_session; session_t *next_session; /* Check if we have any sessions. */ if(!session) { fprintf(stderr, "There are no sessions to delete\n"); return FALSE; } /* Check if the first session is the one we're deleting. */ if(!strcasecmp(sessions->first_session->name, name)) { fprintf(stderr, "Found session to delete: %s\n", name); session = (session_t*)sessions->first_session->next_session; session_free(sessions, sessions->first_session); sessions->first_session = session; return TRUE; } /* Check if any of the other sessions match. */ while((next_session = (session_t *)session->next_session) != NULL) { if(!strcasecmp(next_session->name, name)) { fprintf(stderr, "Found session to delete: %s\n", name); session->next_session = next_session->next_session; session_free(sessions, next_session); return TRUE; } session = next_session; } return FALSE; }
static void on_disconnect(netc_t *netc) { jlog(L_DEBUG, "disconnect"); struct session *session = NULL; struct mac_list *mac_itr = NULL; session = netc->ext_ptr; if (session == NULL) { return; } if (session->state == SESSION_STATE_NOT_AUTHED) { session_free(session); return; } /* If the context is still valid, update the node in it. */ if (session->context != NULL) { linkst_disjoin(session->context->linkst, session->id); while (session->mac_list != NULL) { mac_itr = session->mac_list; session->mac_list = mac_itr->next; ftable_erase(session->context->ftable, mac_itr->mac_addr); free(mac_itr); } ctable_erase(session->context->ctable, session->node_info->uuid); context_del_session(session->context, session); } transmit_node_connectinfo(ConnectState_disconnected, session->ip, session->cert_name); session_free(session); return; }
int cmd_rm(int argc, char **argv) { unsigned char key[KDF_HASH_LEN]; struct session *session = NULL; struct blob *blob = NULL; static struct option long_options[] = { {"sync", required_argument, NULL, 'S'}, {"color", required_argument, NULL, 'C'}, {0, 0, 0, 0} }; int option; int option_index; char *name; enum blobsync sync = BLOB_SYNC_AUTO; struct account *found; while ((option = getopt_long(argc, argv, "", long_options, &option_index)) != -1) { switch (option) { case 'S': sync = parse_sync_string(optarg); break; case 'C': terminal_set_color_mode( parse_color_mode_string(optarg)); break; case '?': default: die_usage(cmd_rm_usage); } } if (argc - optind != 1) die_usage(cmd_rm_usage); name = argv[optind]; init_all(sync, key, &session, &blob); found = find_unique_account(blob, name); if (!found) die("Could not find specified account '%s'.", name); if (found->share && found->share->readonly) die("%s is a readonly shared entry from %s. It cannot be deleted.", found->fullname, found->share->name); list_del(&found->list); lastpass_remove_account(sync, key, session, found, blob); blob_save(blob, key); account_free(found); session_free(session); blob_free(blob); return 0; }
static void session_release(struct worker_ctx *worker, struct session *s) { if (!s) { return; } if (worker->pool_sessions.len < MP_FREELIST_SIZE) { session_clear(s); array_push(worker->pool_sessions, s); kr_asan_poison(s, sizeof(*s)); } else { session_free(s); } }
void obc_session_unref(struct obc_session *session) { gboolean ret; ret = g_atomic_int_dec_and_test(&session->refcount); DBG("%p: ref=%d", session, session->refcount); if (ret == FALSE) return; session_free(session); }
static void session_inactivity_timer_handler(EV_P_ ev_timer *w, int revents) { session_context *sc = (session_context *)w->data; ev_tstamp now = ev_now(EV_A); (void)revents; log_debug("session_inactivity_timer_handler - sc=%x timeout: " "now=%.3f - last_activity=%.3f (duration=%.3f) > timeout=%d", sc, now, sc->last_activity, now - sc->last_activity, sc->options->session_timeout); log_info("(%s:%d) Session timeout", sc->client_ip_str, sc->client_port); session_free(EV_A_ sc); active_session_context = NULL; }
void context_free(context_t *context) { if (context) { pki_passport_destroy(context->passport); linkst_free(context->linkst); ftable_delete(context->ftable); ctable_delete(context->ctable); ctable_delete(context->atable); bitpool_free(context->bitpool); session_free(context->access_session); free(context); } }
/* * Read response status. Attempt to read the status line, but if CRLF * can not be found in the first 2048 bytes, consider it an error and * disconnect. Once status line is read switch to draining the rest of * the data. The server should close the connection due to * "Connection: close" header otherwise it will be caught by timeout. * * Even though status line says 200, the actual success is registered * on socket close. */ static void session_readcb_status(struct bufferevent *bev, void *thunk) { struct session *session = thunk; struct evbuffer *evbuf = bufferevent_get_input(bev); size_t len; char *line; char *protocol; char *number; line = evbuffer_readln(evbuf, &len, EVBUFFER_EOL_CRLF); if (line == NULL) { if (evbuffer_get_length(evbuf) > 2048) { session_free(session); return; } else return; /* wait for more data */ } /* Parse response line */ protocol = strsep(&line, " "); if (line == NULL) return session_free(session); number = strsep(&line, " "); if (line == NULL) return session_free(session); (void)protocol; (void)number; switch (atoi(number)) { case 200: session->completed = 1; break; default: target_mark(session->t, session->seq, '%'); break; } /* Drain the response on future callbacks */ bufferevent_setcb(session->bev, session_readcb_drain, NULL, session_eventcb, session); }
void io_deinit(uv_handle_t *handle) { if (!handle) { return; } uv_loop_t *loop = handle->loop; if (loop && loop->data) { struct worker_ctx *worker = loop->data; session_release(worker, handle->data); } else { session_free(handle->data); } handle->data = NULL; }
/** * Free the memory associated with the session * * @param instance The filter instance * @param session The filter session */ static void freeSession(FILTER *instance, void *session) { TEE_SESSION *my_session = (TEE_SESSION *) session; SESSION* ses = my_session->branch_session; session_state_t state; #ifdef SS_DEBUG MXS_INFO("Tee free: %d", atomic_add(&debug_seq, 1)); #endif if (ses != NULL) { state = ses->state; if (state == SESSION_STATE_ROUTER_READY) { session_free(ses); } else if (state == SESSION_STATE_TO_BE_FREED) { /** Free branch router session */ ses->service->router->freeSession( ses->service->router_instance, ses->router_session); /** Free memory of branch client session */ ses->state = SESSION_STATE_FREE; free(ses); /** This indicates that branch session is not available anymore */ my_session->branch_session = NULL; } else if (state == SESSION_STATE_STOPPING) { create_orphan(ses); } } if (my_session->dummy_filterdef) { filter_free(my_session->dummy_filterdef); } if (my_session->tee_replybuf) { gwbuf_free(my_session->tee_replybuf); } free(session); orphan_free(NULL); return; }
/* This function kills an existing embryonic session. It stops the connection's * transport layer, releases assigned resources, resumes the listener if it was * disabled and finally kills the file descriptor. This function requires that * sess->origin points to the incoming connection. */ static void session_kill_embryonic(struct session *sess) { int level = LOG_INFO; struct connection *conn = __objt_conn(sess->origin); struct task *task = sess->task; unsigned int log = sess->fe->to_log; const char *err_msg; if (sess->fe->options2 & PR_O2_LOGERRORS) level = LOG_ERR; if (log && (sess->fe->options & PR_O_NULLNOLOG)) { /* with "option dontlognull", we don't log connections with no transfer */ if (!conn->err_code || conn->err_code == CO_ER_PRX_EMPTY || conn->err_code == CO_ER_PRX_ABORT || conn->err_code == CO_ER_CIP_EMPTY || conn->err_code == CO_ER_CIP_ABORT || conn->err_code == CO_ER_SSL_EMPTY || conn->err_code == CO_ER_SSL_ABORT) log = 0; } if (log) { if (!conn->err_code && (task->state & TASK_WOKEN_TIMER)) { if (conn->flags & CO_FL_ACCEPT_PROXY) conn->err_code = CO_ER_PRX_TIMEOUT; else if (conn->flags & CO_FL_ACCEPT_CIP) conn->err_code = CO_ER_CIP_TIMEOUT; else if (conn->flags & CO_FL_SSL_WAIT_HS) conn->err_code = CO_ER_SSL_TIMEOUT; } session_prepare_log_prefix(sess); err_msg = conn_err_code_str(conn); if (err_msg) send_log(sess->fe, level, "%s: %s\n", trash.str, err_msg); else send_log(sess->fe, level, "%s: unknown connection error (code=%d flags=%08x)\n", trash.str, conn->err_code, conn->flags); } /* kill the connection now */ conn_stop_tracking(conn); conn_full_close(conn); conn_free(conn); task_delete(task); task_free(task); session_free(sess); }