int main(int argc, char* argv[]) { schd = create_scheduler(); initialize_scheduler(schd, NULL); session_1 = create_session(); initialize_session(session_1, "222.214.218.237", 6601, "1299880", 0); set_session_index(session_1, 0); add_session(schd, session_1); session_2 = create_session(); initialize_session(session_2, "222.214.218.237", 6601, "1299880", 1); set_session_index(session_2, 1); add_session(schd, session_2); set_surface_mode(schd->surface, mode_2); scheduler_start(schd); session_start(session_1); session_start(session_2); scheduler_wait(schd); session_stop(session_1); session_stop(session_2); destroy_session(session_1); destroy_session(session_2); return 0; }
gboolean smtp_send_upstream_message (struct smtp_session *session) { rspamd_dispatcher_pause (session->dispatcher); rspamd_dispatcher_restore (session->upstream_dispatcher); session->upstream_state = SMTP_STATE_IN_SENDFILE; session->state = SMTP_STATE_WAIT_UPSTREAM; if (!rspamd_dispatcher_sendfile (session->upstream_dispatcher, session->temp_fd, session->temp_size)) { msg_err ("sendfile failed: %s", strerror (errno)); goto err; } return TRUE; err: session->error = SMTP_ERROR_FILE; session->state = SMTP_STATE_CRITICAL_ERROR; if (!rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE, TRUE)) { return FALSE; } destroy_session (session->s); return FALSE; }
session_state session_service_destroy_session(session_service *service,\ jnx_guid *g) { JNXCHECK(service); session_state e = SESSION_STATE_NOT_FOUND; jnx_node *h = service->session_list->head, *r = service->session_list->head; jnx_list *cl = jnx_list_create(); session *retrieved_session = NULL; while(h) { session *s = h->_data; if(jnx_guid_compare(g,&s->session_guid) == JNX_GUID_STATE_SUCCESS) { retrieved_session = s; e = SESSION_STATE_OKAY; } else { jnx_list_add_ts(cl,s); } h = h->next_node; } service->session_list->head = r; jnx_list_destroy(&service->session_list); if(cl) { destroy_session(retrieved_session); } service->session_list = cl; return e; }
int ProxyDropServer(struct mansession *s, struct message *m) { struct message mo; struct mansession *srv; char *value; int res; memset(&mo, 0, sizeof(struct message)); value = astman_get_header(m, "Server"); pthread_rwlock_rdlock(&sessionlock); srv = sessions; while (*value && srv) { if (srv->server && !strcmp(srv->server->ast_host, value)) break; srv = srv->next; } pthread_rwlock_unlock(&sessionlock); if (srv) { destroy_session(srv); debugmsg("Dropping Server %s", value); AddHeader(&mo, "ProxyResponse: Success"); AddHeader(&mo, "Message: Dropped %s", value); res = 0; } else { debugmsg("Failed to Drop Server %s -- not found", value); AddHeader(&mo, "ProxyResponse: Failure"); AddHeader(&mo, "Message: Cannot Drop Server %s, Does Not Exist", value); res = 1; } s->output->write(s, &mo); FreeHeaders(&mo); return res; }
/* * Creates a new session for the user. */ static struct session *create_session(const char *user, const struct http_message *hm) { /* Find first available slot or use the oldest one. */ struct session *s = NULL; struct session *oldest_s = s_sessions; for (int i = 0; i < NUM_SESSIONS; i++) { if (s_sessions[i].id == 0) { s = &s_sessions[i]; break; } if (s_sessions[i].last_used < oldest_s->last_used) { oldest_s = &s_sessions[i]; } } if (s == NULL) { destroy_session(oldest_s); printf("Evicted %" INT64_X_FMT "/%s\n", oldest_s->id, oldest_s->user); s = oldest_s; } /* Initialize new session. */ s->created = s->last_used = mg_time(); s->user = strdup(user); s->lucky_number = rand(); /* Create an ID by putting various volatiles into a pot and stirring. */ cs_sha1_ctx ctx; cs_sha1_init(&ctx); cs_sha1_update(&ctx, (const unsigned char *) hm->message.p, hm->message.len); cs_sha1_update(&ctx, (const unsigned char *) s, sizeof(*s)); unsigned char digest[20]; cs_sha1_final(digest, &ctx); s->id = *((uint64_t *) digest); return s; }
static void gst_mir_sink_finalize (GObject * object) { GstMirSink *sink = GST_MIR_SINK (object); GST_DEBUG_OBJECT (sink, "Finalizing the sink.."); #if 0 if (sink->window) destroy_window (sink->window); if (sink->display) destroy_display (sink->display); if (sink->session) destroy_session (sink->session); #endif /* Make sure that the SurfaceTextureClientHybris instance gets cleaned * up when the pipeline is being torn down. */ if (sink->surface_texture_client) surface_texture_client_unref (sink->surface_texture_client); g_mutex_clear (&sink->mir_lock); G_OBJECT_CLASS (parent_class)->finalize (object); }
/* Cleans up sessions that have been idle for too long. */ void check_sessions() { double threshold = mg_time() - SESSION_TTL; for (int i = 0; i < NUM_SESSIONS; i++) { struct session *s = &s_sessions[i]; if (s->id != 0 && s->last_used < threshold) { fprintf(stderr, "Session %" INT64_X_FMT " (%s) closed due to idleness.\n", s->id, s->user); destroy_session(s); } } }
/* * Logs the user out. * Removes cookie and any associated session state. */ static void logout_handler(struct mg_connection *nc, int ev, void *p) { struct http_message *hm = (struct http_message *) p; mg_printf(nc, "HTTP/1.0 302 Found\r\n" "Set-Cookie: %s=\r\n" "Location: /\r\n" "\r\n" "Logged out", SESSION_COOKIE_NAME); struct session *s = get_session(hm); if (s != NULL) { fprintf(stderr, "%s logged out, session %" INT64_X_FMT " destroyed\n", s->user, s->id); destroy_session(s); } nc->flags |= MG_F_SEND_AND_CLOSE; (void) ev; }
void *ProxyLogoff(struct mansession *s, struct message *m) { struct message mo; char *actionid = actionid = astman_get_header(m, "ActionID"); memset(&mo, 0, sizeof(struct message)); AddHeader(&mo, "Response: Goodbye"); AddHeader(&mo, "Message: Thanks for all the fish."); if( actionid && strlen(actionid) > 0 ) AddHeader(&mo, "ActionID: %s", actionid); s->output->write(s, &mo); FreeHeaders(&mo); destroy_session(s); if (debug) debugmsg("Client logged off - exiting thread"); pthread_exit(NULL); return 0; }
/* * destroy_all_sessions * * Call destroy_sessions for each registered sessions */ static int destroy_all_sessions(struct lttng_session *sessions, int count) { int i, ret = CMD_SUCCESS; if (count == 0) { MSG("No session found, nothing to do."); } else if (count < 0) { ERR("%s", lttng_strerror(ret)); goto error; } for (i = 0; i < count; i++) { ret = destroy_session(&sessions[i]); if (ret < 0) { goto error; } } error: return ret; }
void smtp_upstream_err_socket (GError *err, void *arg) { struct smtp_session *session = arg; msg_info ("abnormally closing connection with upstream %s, error: %s", rspamd_upstream_name (session->upstream), err->message); session->error = SMTP_ERROR_UPSTREAM; session->state = SMTP_STATE_CRITICAL_ERROR; /* XXX: assume upstream errors as critical errors */ rspamd_dispatcher_restore (session->dispatcher); if (!rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE, TRUE)) { return; } if (!rspamd_dispatcher_write (session->dispatcher, CRLF, sizeof (CRLF) - 1, FALSE, TRUE)) { return; } rspamd_upstream_fail (session->upstream); destroy_session (session->s); }
static int create_test_session(pj_stun_config *stun_cfg, const struct test_session_cfg *cfg, struct test_session **p_sess) { struct test_session *sess; pj_pool_t *pool; pj_turn_sock_cb turn_sock_cb; pj_turn_alloc_param alloc_param; pj_stun_auth_cred cred; pj_status_t status; /* Create client */ pool = pj_pool_create(mem, "turnclient", 512, 512, NULL); sess = PJ_POOL_ZALLOC_T(pool, struct test_session); sess->pool = pool; sess->stun_cfg = stun_cfg; sess->destroy_on_state = cfg->client.destroy_on_state; pj_bzero(&turn_sock_cb, sizeof(turn_sock_cb)); turn_sock_cb.on_rx_data = &turn_on_rx_data; turn_sock_cb.on_state = &turn_on_state; status = pj_turn_sock_create(sess->stun_cfg, pj_AF_INET(), PJ_TURN_TP_UDP, &turn_sock_cb, 0, sess, &sess->turn_sock); if (status != PJ_SUCCESS) { destroy_session(sess); return -20; } /* Create test server */ status = create_test_server(sess->stun_cfg, cfg->srv.flags, SRV_DOMAIN, &sess->test_srv); if (status != PJ_SUCCESS) { destroy_session(sess); return -30; } sess->test_srv->turn_respond_allocate = cfg->srv.respond_allocate; sess->test_srv->turn_respond_refresh = cfg->srv.respond_refresh; /* Create client resolver */ status = pj_dns_resolver_create(mem, "resolver", 0, sess->stun_cfg->timer_heap, sess->stun_cfg->ioqueue, &sess->resolver); if (status != PJ_SUCCESS) { destroy_session(sess); return -40; } else { pj_str_t dns_srv = pj_str("127.0.0.1"); pj_uint16_t dns_srv_port = (pj_uint16_t) DNS_SERVER_PORT; status = pj_dns_resolver_set_ns(sess->resolver, 1, &dns_srv, &dns_srv_port); if (status != PJ_SUCCESS) { destroy_session(sess); return -50; } } /* Init TURN credential */ pj_bzero(&cred, sizeof(cred)); cred.type = PJ_STUN_AUTH_CRED_STATIC; cred.data.static_cred.realm = pj_str(SRV_DOMAIN); cred.data.static_cred.username = pj_str(TURN_USERNAME); cred.data.static_cred.data_type = PJ_STUN_PASSWD_PLAIN; cred.data.static_cred.data = pj_str(TURN_PASSWD); /* Init TURN allocate parameter */ pj_turn_alloc_param_default(&alloc_param); alloc_param.ka_interval = KA_INTERVAL; /* Start the client */ if (cfg->client.enable_dns_srv) { /* Use DNS SRV to resolve server, may fallback to DNS A */ pj_str_t domain = pj_str(SRV_DOMAIN); status = pj_turn_sock_alloc(sess->turn_sock, &domain, TURN_SERVER_PORT, sess->resolver, &cred, &alloc_param); } else { /* Explicitly specify server address */ pj_str_t host = pj_str("127.0.0.1"); status = pj_turn_sock_alloc(sess->turn_sock, &host, TURN_SERVER_PORT, NULL, &cred, &alloc_param); } if (status != PJ_SUCCESS) { if (cfg->client.destroy_on_state >= PJ_TURN_STATE_READY) { destroy_session(sess); return -70; } } *p_sess = sess; return 0; }
static int destroy_test(pj_stun_config *stun_cfg, pj_bool_t with_dns_srv, pj_bool_t in_callback) { struct test_session_cfg test_cfg = { { /* Client cfg */ /* DNS SRV */ /* Destroy on state */ PJ_TRUE, 0xFFFF }, { /* Server cfg */ 0xFFFFFFFF, /* flags */ PJ_TRUE, /* respond to allocate */ PJ_TRUE /* respond to refresh */ } }; struct test_session *sess; int target_state; int rc; PJ_LOG(3,("", " destroy test %s %s", (in_callback? "in callback" : ""), (with_dns_srv? "with DNS srv" : "") )); test_cfg.client.enable_dns_srv = with_dns_srv; for (target_state=PJ_TURN_STATE_RESOLVING; target_state<=PJ_TURN_STATE_READY; ++target_state) { enum { TIMEOUT = 60 }; pjlib_state pjlib_state; pj_turn_session_info info; pj_time_val tstart; capture_pjlib_state(stun_cfg, &pjlib_state); PJ_LOG(3,("", " %s", pj_turn_state_name((pj_turn_state_t)target_state))); if (in_callback) test_cfg.client.destroy_on_state = target_state; rc = create_test_session(stun_cfg, &test_cfg, &sess); if (rc != 0) return rc; if (in_callback) { pj_gettimeofday(&tstart); rc = 0; while (sess->turn_sock) { pj_time_val now; poll_events(stun_cfg, 100, PJ_FALSE); pj_gettimeofday(&now); if (now.sec - tstart.sec > TIMEOUT) { rc = -7; break; } } } else { pj_gettimeofday(&tstart); rc = 0; while (sess->turn_sock) { pj_time_val now; poll_events(stun_cfg, 1, PJ_FALSE); pj_turn_sock_get_info(sess->turn_sock, &info); if (info.state >= target_state) { pj_turn_sock_destroy(sess->turn_sock); break; } pj_gettimeofday(&now); if (now.sec - tstart.sec > TIMEOUT) { rc = -8; break; } } } if (rc != 0) { PJ_LOG(3,("", " error: timeout")); return rc; } poll_events(stun_cfg, 1000, PJ_FALSE); destroy_session(sess); rc = check_pjlib_state(stun_cfg, &pjlib_state); if (rc != 0) { PJ_LOG(3,("", " error: memory/timer-heap leak detected")); return rc; } } return 0; }
static int state_progression_test(pj_stun_config *stun_cfg) { struct test_session_cfg test_cfg = { { /* Client cfg */ /* DNS SRV */ /* Destroy on state */ PJ_TRUE, 0xFFFF }, { /* Server cfg */ 0xFFFFFFFF, /* flags */ PJ_TRUE, /* respond to allocate */ PJ_TRUE /* respond to refresh */ } }; struct test_session *sess; unsigned i; int rc; PJ_LOG(3,("", " state progression tests")); for (i=0; i<=1; ++i) { enum { TIMEOUT = 60 }; pjlib_state pjlib_state; pj_turn_session_info info; struct test_result result; pj_time_val tstart; PJ_LOG(3,("", " %s DNS SRV resolution", (i==0? "without" : "with"))); capture_pjlib_state(stun_cfg, &pjlib_state); test_cfg.client.enable_dns_srv = i; rc = create_test_session(stun_cfg, &test_cfg, &sess); if (rc != 0) return rc; pj_bzero(&info, sizeof(info)); /* Wait until state is READY */ pj_gettimeofday(&tstart); while (sess->turn_sock) { pj_time_val now; poll_events(stun_cfg, 10, PJ_FALSE); rc = pj_turn_sock_get_info(sess->turn_sock, &info); if (rc!=PJ_SUCCESS) break; if (info.state >= PJ_TURN_STATE_READY) break; pj_gettimeofday(&now); if (now.sec - tstart.sec > TIMEOUT) { PJ_LOG(3,("", " timed-out")); break; } } if (info.state != PJ_TURN_STATE_READY) { PJ_LOG(3,("", " error: state is not READY")); destroy_session(sess); return -130; } /* Deallocate */ pj_turn_sock_destroy(sess->turn_sock); /* Wait for couple of seconds. * We can't poll the session info since the session may have * been destroyed */ poll_events(stun_cfg, 2000, PJ_FALSE); sess->turn_sock = NULL; pj_memcpy(&result, &sess->result, sizeof(result)); destroy_session(sess); /* Check the result */ if ((result.state_called & (1<<PJ_TURN_STATE_RESOLVING)) == 0) { PJ_LOG(3,("", " error: PJ_TURN_STATE_RESOLVING is not called")); return -140; } if ((result.state_called & (1<<PJ_TURN_STATE_RESOLVED)) == 0) { PJ_LOG(3,("", " error: PJ_TURN_STATE_RESOLVED is not called")); return -150; } if ((result.state_called & (1<<PJ_TURN_STATE_ALLOCATING)) == 0) { PJ_LOG(3,("", " error: PJ_TURN_STATE_ALLOCATING is not called")); return -155; } if ((result.state_called & (1<<PJ_TURN_STATE_READY)) == 0) { PJ_LOG(3,("", " error: PJ_TURN_STATE_READY is not called")); return -160; } if ((result.state_called & (1<<PJ_TURN_STATE_DEALLOCATING)) == 0) { PJ_LOG(3,("", " error: PJ_TURN_STATE_DEALLOCATING is not called")); return -170; } if ((result.state_called & (1<<PJ_TURN_STATE_DEALLOCATED)) == 0) { PJ_LOG(3,("", " error: PJ_TURN_STATE_DEALLOCATED is not called")); return -180; } if ((result.state_called & (1<<PJ_TURN_STATE_DESTROYING)) == 0) { PJ_LOG(3,("", " error: PJ_TURN_STATE_DESTROYING is not called")); return -190; } poll_events(stun_cfg, 500, PJ_FALSE); rc = check_pjlib_state(stun_cfg, &pjlib_state); if (rc != 0) { PJ_LOG(3,("", " error: memory/timer-heap leak detected")); return rc; } } return 0; }
gboolean smtp_upstream_read_socket (f_str_t * in, void *arg) { struct smtp_session *session = arg; gchar outbuf[BUFSIZ]; gint r; msg_debug ("in: %V, state: %d", in, session->upstream_state); switch (session->upstream_state) { case SMTP_STATE_GREETING: r = check_smtp_ustream_reply (in, '2'); if (r == -1) { session->error = rspamd_mempool_alloc (session->pool, in->len + 1); rspamd_strlcpy (session->error, in->begin, in->len + 1); /* XXX: assume upstream errors as critical errors */ session->state = SMTP_STATE_CRITICAL_ERROR; rspamd_dispatcher_restore (session->dispatcher); if (!rspamd_dispatcher_write (session->dispatcher, session->error, in->len, FALSE, TRUE)) { goto err; } if (!rspamd_dispatcher_write (session->dispatcher, CRLF, sizeof (CRLF) - 1, FALSE, TRUE)) { goto err; } destroy_session (session->s); return FALSE; } else if (r == 1) { if (session->ctx->use_xclient) { r = rspamd_snprintf (outbuf, sizeof (outbuf), "XCLIENT NAME=%s ADDR=%s" CRLF, session->resolved ? session->hostname : "[UNDEFINED]", inet_ntoa (session->client_addr)); session->upstream_state = SMTP_STATE_HELO; return rspamd_dispatcher_write (session->upstream_dispatcher, outbuf, r, FALSE, FALSE); } else { session->upstream_state = SMTP_STATE_FROM; if (session->helo) { r = rspamd_snprintf (outbuf, sizeof (outbuf), "%s %s" CRLF, session->esmtp ? "EHLO" : "HELO", session->helo); } else { return smtp_upstream_read_socket (in, arg); } return rspamd_dispatcher_write (session->upstream_dispatcher, outbuf, r, FALSE, FALSE); } } break; case SMTP_STATE_HELO: r = check_smtp_ustream_reply (in, '2'); if (r == -1) { session->error = rspamd_mempool_alloc (session->pool, in->len + 1); rspamd_strlcpy (session->error, in->begin, in->len + 1); /* XXX: assume upstream errors as critical errors */ session->state = SMTP_STATE_CRITICAL_ERROR; rspamd_dispatcher_restore (session->dispatcher); if (!rspamd_dispatcher_write (session->dispatcher, session->error, in->len, FALSE, TRUE)) { goto err; } if (!rspamd_dispatcher_write (session->dispatcher, CRLF, sizeof (CRLF) - 1, FALSE, TRUE)) { goto err; } destroy_session (session->s); return FALSE; } else if (r == 1) { session->upstream_state = SMTP_STATE_FROM; if (session->helo) { r = rspamd_snprintf (outbuf, sizeof (outbuf), "%s %s" CRLF, session->esmtp ? "EHLO" : "HELO", session->helo); } else { return smtp_upstream_read_socket (in, arg); } return rspamd_dispatcher_write (session->upstream_dispatcher, outbuf, r, FALSE, FALSE); } break; case SMTP_STATE_FROM: r = check_smtp_ustream_reply (in, '2'); if (r == -1) { session->error = rspamd_mempool_alloc (session->pool, in->len + 1); rspamd_strlcpy (session->error, in->begin, in->len + 1); /* XXX: assume upstream errors as critical errors */ session->state = SMTP_STATE_CRITICAL_ERROR; rspamd_dispatcher_restore (session->dispatcher); if (!rspamd_dispatcher_write (session->dispatcher, session->error, in->len, FALSE, TRUE)) { goto err; } if (!rspamd_dispatcher_write (session->dispatcher, CRLF, sizeof (CRLF) - 1, FALSE, TRUE)) { goto err; } destroy_session (session->s); return FALSE; } else if (r == 1) { r = rspamd_snprintf (outbuf, sizeof (outbuf), "MAIL FROM: "); r += smtp_upstream_write_list (session->from, outbuf + r, sizeof (outbuf) - r); session->upstream_state = SMTP_STATE_RCPT; return rspamd_dispatcher_write (session->upstream_dispatcher, outbuf, r, FALSE, FALSE); } break; case SMTP_STATE_RCPT: r = check_smtp_ustream_reply (in, '2'); if (r == -1) { session->error = rspamd_mempool_alloc (session->pool, in->len + 1); rspamd_strlcpy (session->error, in->begin, in->len + 1); /* XXX: assume upstream errors as critical errors */ session->state = SMTP_STATE_CRITICAL_ERROR; rspamd_dispatcher_restore (session->dispatcher); if (!rspamd_dispatcher_write (session->dispatcher, session->error, in->len, FALSE, TRUE)) { goto err; } if (!rspamd_dispatcher_write (session->dispatcher, CRLF, sizeof (CRLF) - 1, FALSE, TRUE)) { goto err; } destroy_session (session->s); return FALSE; } else if (r == 1) { r = rspamd_snprintf (outbuf, sizeof (outbuf), "RCPT TO: "); session->cur_rcpt = g_list_first (session->rcpt); r += smtp_upstream_write_list (session->cur_rcpt->data, outbuf + r, sizeof (outbuf) - r); session->cur_rcpt = g_list_next (session->cur_rcpt); session->upstream_state = SMTP_STATE_BEFORE_DATA; return rspamd_dispatcher_write (session->upstream_dispatcher, outbuf, r, FALSE, FALSE); } break; case SMTP_STATE_BEFORE_DATA: r = check_smtp_ustream_reply (in, '2'); if (r == -1) { session->error = rspamd_mempool_alloc (session->pool, in->len + 1); rspamd_strlcpy (session->error, in->begin, in->len + 1); rspamd_dispatcher_restore (session->dispatcher); if (!rspamd_dispatcher_write (session->dispatcher, session->error, in->len, FALSE, TRUE)) { goto err; } if (!rspamd_dispatcher_write (session->dispatcher, CRLF, sizeof (CRLF) - 1, FALSE, TRUE)) { goto err; } if (session->cur_rcpt) { session->rcpt = g_list_delete_link (session->rcpt, session->cur_rcpt); } else { session->rcpt = g_list_delete_link (session->rcpt, session->rcpt); } session->errors++; session->state = SMTP_STATE_RCPT; return TRUE; } else if (r == 1) { if (session->cur_rcpt != NULL) { r = rspamd_snprintf (outbuf, sizeof (outbuf), "RCPT TO: "); r += smtp_upstream_write_list (session->cur_rcpt, outbuf + r, sizeof (outbuf) - r); session->cur_rcpt = g_list_next (session->cur_rcpt); if (!rspamd_dispatcher_write (session->upstream_dispatcher, outbuf, r, FALSE, FALSE)) { goto err; } } else { session->upstream_state = SMTP_STATE_DATA; rspamd_dispatcher_pause (session->upstream_dispatcher); } session->error = rspamd_mempool_alloc (session->pool, in->len + 1); rspamd_strlcpy (session->error, in->begin, in->len + 1); /* Write to client */ if (!rspamd_dispatcher_write (session->dispatcher, session->error, in->len, FALSE, TRUE)) { goto err; } if (!rspamd_dispatcher_write (session->dispatcher, CRLF, sizeof (CRLF) - 1, FALSE, TRUE)) { goto err; } if (session->state == SMTP_STATE_WAIT_UPSTREAM) { rspamd_dispatcher_restore (session->dispatcher); session->state = SMTP_STATE_RCPT; } } break; case SMTP_STATE_DATA: r = check_smtp_ustream_reply (in, '3'); if (r == -1) { session->error = rspamd_mempool_alloc (session->pool, in->len + 1); rspamd_strlcpy (session->error, in->begin, in->len + 1); /* XXX: assume upstream errors as critical errors */ session->state = SMTP_STATE_CRITICAL_ERROR; rspamd_dispatcher_restore (session->dispatcher); if (!rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE, TRUE)) { goto err; } if (!rspamd_dispatcher_write (session->dispatcher, CRLF, sizeof (CRLF) - 1, FALSE, TRUE)) { goto err; } destroy_session (session->s); return FALSE; } else if (r == 1) { if (!make_smtp_tempfile (session)) { session->error = SMTP_ERROR_FILE; session->state = SMTP_STATE_CRITICAL_ERROR; rspamd_dispatcher_restore (session->dispatcher); if (!rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE, TRUE)) { goto err; } destroy_session (session->s); return FALSE; } session->state = SMTP_STATE_AFTER_DATA; session->error = SMTP_ERROR_DATA_OK; rspamd_dispatcher_restore (session->dispatcher); if (!rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE, TRUE)) { goto err; } rspamd_dispatcher_pause (session->upstream_dispatcher); rspamd_set_dispatcher_policy (session->dispatcher, BUFFER_LINE, 0); session->dispatcher->strip_eol = FALSE; return TRUE; } break; case SMTP_STATE_AFTER_DATA: session->error = rspamd_mempool_alloc (session->pool, in->len + 1); rspamd_strlcpy (session->error, in->begin, in->len + 1); session->state = SMTP_STATE_DATA; rspamd_dispatcher_restore (session->dispatcher); if (!rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE, TRUE)) { goto err; } if (!rspamd_dispatcher_write (session->dispatcher, CRLF, sizeof (CRLF) - 1, FALSE, TRUE)) { goto err; } if (!rspamd_dispatcher_write (session->upstream_dispatcher, "QUIT" CRLF, sizeof ("QUIT" CRLF) - 1, FALSE, TRUE)) { goto err; } session->upstream_state = SMTP_STATE_END; return TRUE; break; case SMTP_STATE_END: r = check_smtp_ustream_reply (in, '5'); if (r == -1) { session->error = rspamd_mempool_alloc (session->pool, in->len + 1); rspamd_strlcpy (session->error, in->begin, in->len + 1); /* XXX: assume upstream errors as critical errors */ session->state = SMTP_STATE_CRITICAL_ERROR; rspamd_dispatcher_restore (session->dispatcher); if (!rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE, TRUE)) { goto err; } if (!rspamd_dispatcher_write (session->dispatcher, CRLF, sizeof (CRLF) - 1, FALSE, TRUE)) { goto err; } destroy_session (session->s); return FALSE; } else { remove_normal_event (session->s, (event_finalizer_t)smtp_upstream_finalize_connection, session); } return FALSE; break; default: msg_err ("got upstream reply at unexpected state: %d, reply: %V", session->upstream_state, in); session->state = SMTP_STATE_CRITICAL_ERROR; rspamd_dispatcher_restore (session->dispatcher); if (!rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE, TRUE)) { goto err; } if (!rspamd_dispatcher_write (session->dispatcher, CRLF, sizeof (CRLF) - 1, FALSE, TRUE)) { goto err; } destroy_session (session->s); return FALSE; } return TRUE; err: msg_warn ("write error occured"); return FALSE; }
/* * The 'destroy <options>' first level command */ int cmd_destroy(int argc, const char **argv) { int opt; int ret = CMD_SUCCESS , i, command_ret = CMD_SUCCESS, success = 1; static poptContext pc; char *session_name = NULL; const char *leftover = NULL; struct lttng_session *sessions; int count; int found; pc = poptGetContext(NULL, argc, argv, long_options, 0); poptReadDefaultConfig(pc, 0); while ((opt = poptGetNextOpt(pc)) != -1) { switch (opt) { case OPT_HELP: SHOW_HELP(); break; case OPT_LIST_OPTIONS: list_cmd_options(stdout, long_options); break; default: ret = CMD_UNDEFINED; break; } goto end; } /* Mi preparation */ if (lttng_opt_mi) { writer = mi_lttng_writer_create(fileno(stdout), lttng_opt_mi); if (!writer) { ret = -LTTNG_ERR_NOMEM; goto end; } /* Open command element */ ret = mi_lttng_writer_command_open(writer, mi_lttng_element_command_destroy); if (ret) { ret = CMD_ERROR; goto end; } /* Open output element */ ret = mi_lttng_writer_open_element(writer, mi_lttng_element_command_output); if (ret) { ret = CMD_ERROR; goto end; } /* For validation and semantic purpose we open a sessions element */ ret = mi_lttng_sessions_open(writer); if (ret) { ret = CMD_ERROR; goto end; } } /* Recuperate all sessions for further operation */ count = lttng_list_sessions(&sessions); if (count < 0) { ERR("%s", lttng_strerror(count)); command_ret = CMD_ERROR; success = 0; goto mi_closing; } /* Ignore session name in case all sessions are to be destroyed */ if (opt_destroy_all) { command_ret = destroy_all_sessions(sessions, count); if (command_ret) { success = 0; } } else { opt_session_name = (char *) poptGetArg(pc); if (!opt_session_name) { /* No session name specified, lookup default */ session_name = get_session_name(); if (session_name == NULL) { command_ret = CMD_ERROR; success = 0; goto mi_closing; } } else { session_name = opt_session_name; } /* Find the corresponding lttng_session struct */ found = 0; for (i = 0; i < count; i++) { if (strncmp(sessions[i].name, session_name, NAME_MAX) == 0) { found = 1; command_ret = destroy_session(&sessions[i]); if (command_ret) { success = 0; } } } if (!found) { ERR("Session name %s not found", session_name); command_ret = LTTNG_ERR_SESS_NOT_FOUND; success = 0; goto mi_closing; } } leftover = poptGetArg(pc); if (leftover) { ERR("Unknown argument: %s", leftover); ret = CMD_ERROR; success = 0; goto mi_closing; } mi_closing: /* Mi closing */ if (lttng_opt_mi) { /* Close sessions and output element element */ ret = mi_lttng_close_multi_element(writer, 2); if (ret) { ret = CMD_ERROR; goto end; } /* Success ? */ ret = mi_lttng_writer_write_element_bool(writer, mi_lttng_element_command_success, success); if (ret) { ret = CMD_ERROR; goto end; } /* Command element close */ ret = mi_lttng_writer_command_close(writer); if (ret) { ret = CMD_ERROR; goto end; } } end: /* Mi clean-up */ if (writer && mi_lttng_writer_destroy(writer)) { /* Preserve original error code */ ret = ret ? ret : -LTTNG_ERR_MI_IO_FAIL; } if (opt_session_name == NULL) { free(session_name); } /* Overwrite ret if an error occurred during destroy_session/all */ ret = command_ret ? command_ret : ret; poptFreeContext(pc); return ret; }
int main( int argc, char **argv ) { CSession *pSession = NULL; CSessionParam stSessionParam; const int8_t *pPeerIP = "www.lelsen.sinaapp.com"; //const int8_t *pPeerIP = "www.baidu.com"; const int8_t *pURL = "/business/api/punch.php"; //const int8_t *pURL = "/index.html"; const int16u_t iPeerPort = 80; enable_log( 1 ); set_log( LOG_TYPE_CONSOLE, NULL, 0 ); pHandle = fopen( "./log.txt", "wb" ); if ( !pHandle ) return -1; if ( init_session( ) < 0 ) return -1; log_print( "init_session ok.................." ); memset( &stSessionParam, 0x00, sizeof(stSessionParam) ); memcpy( stSessionParam.pIP, pPeerIP, strlen(pPeerIP) + 1 ); stSessionParam.iPort = iPeerPort; log_print( "start to create session............" ); pSession = create_session( SESSION_TYPE_HTTP_CLIENT, &stSessionParam ); if ( pSession ) { log_print( "create tcp session ok................" ); if ( set_session_business( pSession, stream_session_business, NULL ) >= 0 ) { if ( set_session_event( pSession, stream_session_event ) >= 0 ) { CHttpData stHttpData; memset( &stHttpData, 0x00, sizeof(stHttpData) ); stHttpData.pHost = pPeerIP; stHttpData.pURL = pURL; stHttpData.eHttpAction = SESSION_HTTP_GET; while ( 1 ) { int i, iNSent = -1; //printf( "Please enter 1 to send http request:\r\n" ); i = 0; // scanf( "%d", &i ); //if ( i == 1 ) iNSent = send_session_data( pSession, &stHttpData, sizeof(stHttpData), NULL ); os_sleep( 1000 * 2); } } } } else log_print( "create udp session failed????????????????????????" ); while ( 1 ) os_sleep( 1000 ); destroy_session( pSession ); pSession = NULL; release_session( ); return 0; }
/* Handle the connection of a client. */ static void connection_handler(t_session *session) { int result; #ifdef ENABLE_SSL t_ssl_accept_data sad; #endif #ifdef ENABLE_MONITOR int connections; #ifdef ENABLE_DEBUG session->current_task = "thread started"; #endif connections = ++open_connections; if (session->config->monitor_enabled) { if (connections > session->config->monitor_stats.simultaneous_connections) { session->config->monitor_stats.simultaneous_connections = connections; } } #endif #ifdef ENABLE_SSL if (session->binding->use_ssl) { sad.context = &(session->ssl_context); sad.client_fd = &(session->client_socket); sad.private_key = session->binding->private_key; sad.certificate = session->binding->certificate; sad.ca_certificate = session->binding->ca_certificate; sad.ca_crl = session->binding->ca_crl; sad.timeout = session->kept_alive == 0 ? session->binding->time_for_1st_request : session->binding->time_for_request; sad.min_ssl_version = session->config->min_ssl_version; sad.dh_size = session->config->dh_size; #ifdef ENABLE_DEBUG session->current_task = "ssl accept"; #endif switch (ssl_accept(&sad)) { case -2: handle_timeout(session); break; case 0: session->socket_open = true; break; } } else #endif session->socket_open = true; if (session->socket_open) { do { result = serve_client(session); handle_request_result(session, result); #ifdef ENABLE_DEBUG session->current_task = "request done"; #endif if (session->socket_open) { send_buffer(session, NULL, 0); /* Flush the output-buffer */ } #ifdef ENABLE_MONITOR if (session->config->monitor_enabled) { monitor_counter_request(session); if (session->host->monitor_requests && (result > 0)) { monitor_request(session); } } #endif reset_session(session); #ifdef ENABLE_DEBUG session->current_task = "session reset"; #endif if ((session->kept_alive > 0) && (session->config->ban_on_flooding > 0)) { if (client_is_flooding(session)) { if (ip_allowed(&(session->ip_address), session->config->banlist_mask) != deny) { ban_ip(&(session->ip_address), session->config->ban_on_flooding, session->config->kick_on_ban); log_system(session, "Client banned because of flooding"); session->keep_alive = false; #ifdef ENABLE_MONITOR if (session->config->monitor_enabled) { monitor_counter_ban(session); } #endif } } } } while (session->keep_alive && session->socket_open); #ifdef ENABLE_DEBUG session->current_task = "session done"; #endif destroy_session(session); close_socket(session); } else { close(session->client_socket); } #ifdef ENABLE_MONITOR open_connections--; #endif if (session->config->reconnect_delay > 0) { mark_client_for_removal(session, session->config->reconnect_delay); } else { remove_client(session, true); } /* Client session ends here */ #ifndef ENABLE_THREAD_POOL pthread_exit(NULL); #endif }
gboolean write_smtp_reply (struct smtp_session *session) { gchar logbuf[1024], *new_subject; const gchar *old_subject; struct smtp_metric_callback_data cd; GMimeStream *stream; gint old_fd, sublen; /* Check metrics */ cd.session = session; cd.action = METRIC_ACTION_NOACTION; cd.res = NULL; cd.log_buf = logbuf; cd.log_offset = rspamd_snprintf (logbuf, sizeof (logbuf), "id: <%s>, qid: <%s>, ", session->task->message_id, session->task->queue_id); cd.log_size = sizeof (logbuf); if (session->task->user) { cd.log_offset += rspamd_snprintf (logbuf + cd.log_offset, sizeof (logbuf) - cd.log_offset, "user: %s, ", session->task->user); } g_hash_table_foreach (session->task->results, smtp_metric_callback, &cd); msg_info ("%s", logbuf); if (cd.action <= METRIC_ACTION_REJECT) { if (!rspamd_dispatcher_write (session->dispatcher, session->ctx->reject_message, 0, FALSE, TRUE)) { return FALSE; } if (!rspamd_dispatcher_write (session->dispatcher, CRLF, sizeof (CRLF) - 1, FALSE, TRUE)) { return FALSE; } destroy_session (session->s); return FALSE; } else if (cd.action <= METRIC_ACTION_ADD_HEADER || cd.action <= METRIC_ACTION_REWRITE_SUBJECT) { old_fd = session->temp_fd; if (!make_smtp_tempfile (session)) { session->error = SMTP_ERROR_FILE; session->state = SMTP_STATE_CRITICAL_ERROR; rspamd_dispatcher_restore (session->dispatcher); if (!rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE, TRUE)) { goto err; } destroy_session (session->s); return FALSE; } if (cd.action <= METRIC_ACTION_REWRITE_SUBJECT) { /* XXX: add this action */ old_subject = g_mime_message_get_subject (session->task->message); if (old_subject != NULL) { sublen = strlen (old_subject) + sizeof (SPAM_SUBJECT); new_subject = rspamd_mempool_alloc (session->pool, sublen); rspamd_snprintf (new_subject, sublen, "%s%s", SPAM_SUBJECT, old_subject); } else { new_subject = SPAM_SUBJECT; } g_mime_message_set_subject (session->task->message, new_subject); } else if (cd.action <= METRIC_ACTION_ADD_HEADER) { #ifndef GMIME24 g_mime_message_add_header (session->task->message, "X-Spam", "true"); #else g_mime_object_append_header (GMIME_OBJECT ( session->task->message), "X-Spam", "true"); #endif } stream = g_mime_stream_fs_new (session->temp_fd); g_mime_stream_fs_set_owner (GMIME_STREAM_FS (stream), FALSE); close (old_fd); if (g_mime_object_write_to_stream (GMIME_OBJECT (session->task->message), stream) == -1) { msg_err ("cannot write MIME object to stream: %s", strerror (errno)); session->error = SMTP_ERROR_FILE; session->state = SMTP_STATE_CRITICAL_ERROR; rspamd_dispatcher_restore (session->dispatcher); if (!rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE, TRUE)) { goto err; } destroy_session (session->s); return FALSE; } g_object_unref (stream); } /* XXX: Add other actions */ return smtp_send_upstream_message (session); err: session->error = SMTP_ERROR_FILE; session->state = SMTP_STATE_CRITICAL_ERROR; if (!rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE, TRUE)) { return FALSE; } destroy_session (session->s); return FALSE; }
/* Handle the connection of a client. */ static void connection_handler(t_session *session) { int result; #ifdef ENABLE_SSL t_ssl_accept_data sad; #endif #ifdef ENABLE_DEBUG session->current_task = "thread started"; #endif #ifdef ENABLE_SSL if (session->binding->use_ssl) { sad.context = &(session->ssl_context); sad.client_fd = &(session->client_socket); sad.private_key = session->binding->private_key; sad.certificate = session->binding->certificate; sad.ca_certificate = session->binding->ca_certificate; sad.ca_crl = session->binding->ca_crl; sad.timeout = session->kept_alive == 0 ? session->binding->time_for_1st_request : session->binding->time_for_request; sad.min_ssl_version = session->config->min_ssl_version; sad.dh_size = session->config->dh_size; #ifdef ENABLE_DEBUG sad.thread_id = session->thread_id; session->current_task = "ssl accept"; #endif switch (ssl_accept(&sad)) { case SSL_HANDSHAKE_NO_MATCH: log_system(session, "No cypher overlap during SSL handshake."); break; case SSL_HANDSHAKE_TIMEOUT: handle_timeout(session); break; case SSL_HANDSHAKE_OKE: session->socket_open = true; break; } } else #endif session->socket_open = true; if (session->socket_open) { #ifdef ENABLE_MONITOR if (session->config->monitor_enabled) { monitor_count_connection(session); } #endif do { result = serve_client(session); handle_request_result(session, result); #ifdef ENABLE_TOMAHAWK if (session->parsing_oke) { show_request_to_admins(session->method, session->request_uri, session->http_version, &(session->ip_address), session->http_headers, session->return_code, session->bytes_sent); } #endif #ifdef ENABLE_DEBUG session->current_task = "request done"; #endif if (session->socket_open) { /* Flush the output-buffer */ if (send_buffer(session, NULL, 0) == -1) { session->keep_alive = false; } } #ifdef ENABLE_MONITOR if (session->config->monitor_enabled) { monitor_count_host(session); } #endif reset_session(session); #ifdef ENABLE_DEBUG session->current_task = "session reset"; #endif if ((session->kept_alive > 0) && (session->config->ban_on_flooding > 0)) { if (client_is_flooding(session)) { if (ip_allowed(&(session->ip_address), session->config->banlist_mask) != deny) { ban_ip(&(session->ip_address), session->config->ban_on_flooding, session->config->kick_on_ban); log_system(session, "Client banned because of flooding"); session->keep_alive = false; #ifdef ENABLE_MONITOR if (session->config->monitor_enabled) { monitor_count_ban(session); } #endif } } } } while (session->keep_alive && session->socket_open); #ifdef ENABLE_DEBUG session->current_task = "session done"; #endif destroy_session(session); close_socket(session); } else { close(session->client_socket); } if (session->config->reconnect_delay > 0) { mark_client_for_removal(session, session->config->reconnect_delay); } else { remove_client(session, true); } #ifdef ENABLE_DEBUG /* Show memory usage by thread */ memdbg_print_log(false); #endif /* Client session ends here */ #ifndef ENABLE_THREAD_POOL pthread_exit(NULL); #endif }