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
}
