/*
* Logout from the IMAP server and disconnect from the server.
*/
int
request_logout(session *ssn)
{
if (response_generic(ssn, send_request(ssn, "LOGOUT")) == -1) {
session_destroy(ssn);
} else {
close_connection(ssn);
session_destroy(ssn);
}
return STATUS_OK;
}
static gchar *news_fetch_msg(Folder *folder, FolderItem *item, gint num)
{
gchar *path, *filename;
NewsSession *session;
gint ok;
cm_return_val_if_fail(folder != NULL, NULL);
cm_return_val_if_fail(item != NULL, NULL);
path = folder_item_get_path(item);
if (!is_dir_exist(path))
make_dir_hier(path);
filename = g_strconcat(path, G_DIR_SEPARATOR_S, itos(num), NULL);
g_free(path);
if (is_file_exist(filename)) {
debug_print("article %d has been already cached.\n", num);
return filename;
}
session = news_session_get(folder);
if (!session) {
g_free(filename);
return NULL;
}
ok = news_select_group(folder, item->path, NULL, NULL, NULL);
if (ok != NEWSNNTP_NO_ERROR) {
if (ok == NEWSNNTP_ERROR_STREAM) {
session_destroy(SESSION(session));
REMOTE_FOLDER(folder)->session = NULL;
}
g_free(filename);
return NULL;
}
debug_print("getting article %d...\n", num);
ok = news_get_article(folder,
num, filename);
if (ok != NEWSNNTP_NO_ERROR) {
g_warning("can't read article %d", num);
if (ok == NEWSNNTP_ERROR_STREAM) {
session_destroy(SESSION(session));
REMOTE_FOLDER(folder)->session = NULL;
}
g_free(filename);
return NULL;
}
GTK_EVENTS_FLUSH();
return filename;
}
void
test_session_tcp6(void) {
lagopus_result_t ret;
char cbuf[256] = {0};
char sbuf[256] = {0};
lagopus_session_t sesc, sess, sesa;
struct addrunion dst, src;
ret = session_create(SESSION_TCP6|SESSION_PASSIVE, &sess);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
addrunion_ipv6_set(&src, "::0");
ret = session_bind(sess, &src, 10023);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
ret = session_create(SESSION_TCP6|SESSION_ACTIVE, &sesc);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
addrunion_ipv6_set(&dst, "::1");
ret = session_connect(sesc, &dst, 10023, NULL, 0);
if (ret == 0 || errno == EINPROGRESS) {
TEST_ASSERT(true);
} else {
TEST_ASSERT(false);
}
ret = session_accept(sess, &sesa);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
TEST_ASSERT_NOT_NULL(sesa);
TEST_ASSERT_TRUE(session_is_alive(sess));
TEST_ASSERT_TRUE(session_is_alive(sesc));
TEST_ASSERT_TRUE(session_is_alive(sesa));
snprintf(cbuf, sizeof(cbuf), "hogehoge\n");
ret = session_write(sesc, cbuf, strlen(cbuf));
TEST_ASSERT_EQUAL(ret, strlen(cbuf));
ret = session_read(sesa, sbuf, sizeof(sbuf));
TEST_ASSERT_EQUAL(ret, strlen(sbuf));
ret = session_write(sesa, sbuf, strlen(sbuf));
TEST_ASSERT_EQUAL(ret, strlen(sbuf));
ret = session_read(sesc, cbuf, sizeof(cbuf));
TEST_ASSERT_EQUAL(ret, strlen(cbuf));
session_destroy(sesc);
session_destroy(sesa);
session_destroy(sess);
}
void
test_channel_local_addr_get_set_unset(void) {
lagopus_result_t ret;
struct channel *channel;
struct addrunion addr = {0,{{0}}};
struct addrunion addr1 = {0,{{0}}};
channel = s_create_data_channel();
addrunion_ipv4_set(&addr, "127.0.0.1");
ret = channel_local_addr_set(channel, &addr);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"channel_local_addr_set() error.");
ret = channel_local_addr_get(channel, &addr1);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"channel_local_addr_get() error.");
TEST_ASSERT_EQUAL_MEMORY_MESSAGE(&addr, &addr1, sizeof(addr),
"channel_local_addr_get() addr error");
ret = channel_local_addr_unset(channel);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"channel_local_addr_unset() error.");
ret = channel_local_addr_get(channel, &addr1);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"channel_local_addr_get() error.");
addrunion_ipv4_set(&addr, "0.0.0.0");
TEST_ASSERT_EQUAL_MEMORY_MESSAGE(&addr, &addr1, sizeof(addr),
"channel_local_addr_get() addr error");
session_destroy(channel_session_get(channel));
free(channel);
}
void
test_channel_local_port_get_set_unset(void) {
uint16_t port;
lagopus_result_t ret;
struct channel *channel;
channel = s_create_data_channel();
ret = channel_local_port_set(channel, 10101);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"channel_local_port_set() error.");
ret = channel_local_port_get(channel, &port);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"channel_local_port_get() error.");
TEST_ASSERT_EQUAL_MESSAGE(10101, port,
"channel_local_port_get() port error");
ret = channel_local_port_unset(channel);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"channel_local_port_unset() error.");
ret = channel_local_port_get(channel, &port);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"channel_local_port_get() error.");
TEST_ASSERT_EQUAL_MESSAGE(0, port,
"channel_local_port_get() port error");
session_destroy(channel_session_get(channel));
free(channel);
}
void
test_channel_proto_get_set_unset(void) {
lagopus_result_t ret;
struct channel *channel;
enum channel_protocol protocol;
channel = s_create_data_channel();
ret = channel_protocol_set(channel, PROTOCOL_TCP6);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"channel_protocol_set() error.");
ret = channel_protocol_get(channel, &protocol);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"channel_protocol_get() error.");
TEST_ASSERT_EQUAL_MESSAGE(PROTOCOL_TCP6, protocol,
"channel_protocol_get() proto error");
ret = channel_protocol_unset(channel);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"channel_protocol_unset() error.");
ret = channel_protocol_get(channel, &protocol);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"channel_protocol_get() error.");
TEST_ASSERT_EQUAL_MESSAGE(PROTOCOL_TCP, protocol,
"channel_protocol_get() proto error");
session_destroy(channel_session_get(channel));
free(channel);
}
void
test_channel_xid_get_set(void) {
struct channel *channel;
uint32_t ret_xid;
uint32_t xid = 0x10;
channel = s_create_data_channel();
/* Call func. */
channel_xid_set(channel, xid);
ret_xid = channel_xid_get(channel);
TEST_ASSERT_EQUAL_MESSAGE(ret_xid, xid,
"xid error.");
/* incrementation */
/* Call func. */
ret_xid = channel_xid_get(channel);
TEST_ASSERT_EQUAL_MESSAGE(ret_xid, xid + 1,
"xid incrementation error.");
/* max */
/* Call func. */
channel_xid_set(channel, UINT32_MAX);
ret_xid = channel_xid_get(channel);
TEST_ASSERT_EQUAL_MESSAGE(ret_xid, 100 /*START_XID*/,
"xid max error.");
session_destroy(channel_session_get(channel));
free(channel);
}
static zx_status_t new_vc_cb(port_handler_t* ph, zx_signals_t signals, uint32_t evt) {
zx_handle_t h;
uint32_t dcount, hcount;
if (zx_channel_read(ph->handle, 0, NULL, &h, 0, 1, &dcount, &hcount) < 0) {
return ZX_OK;
}
if (hcount != 1) {
return ZX_OK;
}
vc_t* vc;
int fd;
if (session_create(&vc, &fd, true, false) < 0) {
zx_handle_close(h);
return ZX_OK;
}
zx_handle_t handles[FDIO_MAX_HANDLES];
uint32_t types[FDIO_MAX_HANDLES];
zx_status_t r = fdio_transfer_fd(fd, FDIO_FLAG_USE_FOR_STDIO | 0, handles, types);
if (zx_channel_write(h, 0, types,
static_cast<uint32_t>(r * sizeof(uint32_t)), handles, r) != ZX_OK) {
session_destroy(vc);
} else {
port_wait(&port, &vc->fh.ph);
}
zx_handle_close(h);
return ZX_OK;
}
static zx_status_t session_io_cb(port_fd_handler_t* fh, unsigned pollevt, uint32_t evt) {
vc_t* vc = containerof(fh, vc_t, fh);
if (pollevt & POLLIN) {
char data[1024];
ssize_t r = read(vc->fd, data, sizeof(data));
if (r > 0) {
vc_write(vc, data, r, 0);
return ZX_OK;
}
}
if (pollevt & (POLLRDHUP | POLLHUP)) {
// shell sessions get restarted on exit
if (vc->is_shell) {
zx_task_kill(vc->proc);
vc->proc = ZX_HANDLE_INVALID;
int fd = openat(vc->fd, "0", O_RDWR);
if (fd < 0) {
goto fail;
}
if (launch_shell(vc, fd, NULL) < 0) {
goto fail;
}
return ZX_OK;
}
}
fail:
session_destroy(vc);
return ZX_ERR_STOP;
}
void http_session_destroy(struct http_session *s)
{
int must_destroy = 0;
http_sessions_t http_sessions = s->http_sessions;
yaz_log(http_sessions->log_level, "Session %u destroy", s->session_id);
yaz_mutex_enter(http_sessions->mutex);
/* only if http_session has no active http sessions on it can be destroyed */
if (s->destroy_counter == s->activity_counter)
{
struct http_session **p = 0;
must_destroy = 1;
for (p = &http_sessions->session_list; *p; p = &(*p)->next)
if (*p == s)
{
*p = (*p)->next;
break;
}
}
yaz_mutex_leave(http_sessions->mutex);
if (must_destroy)
{ /* destroying for real */
yaz_log(http_sessions->log_level, "Session %u destroyed", s->session_id);
iochan_destroy(s->timeout_iochan);
session_destroy(s->psession);
http_session_use(-1);
nmem_destroy(s->nmem);
}
else {
yaz_log(http_sessions->log_level, "Session %u destroying delayed. Active clients (%d-%d). Waiting for new timeout.",
s->session_id, s->activity_counter, s->destroy_counter);
}
}
int sessiondb_init(fate_cb tcpest_fn, fate_cb tcptrans_fn)
{
int error;
error = session_init();
if (error)
return error;
error = pktqueue_init();
if (error) {
session_destroy();
return error;
}
sessiontable_init(&session_table_udp,
config_get_ttl_udp, just_die,
NULL, NULL);
sessiontable_init(&session_table_tcp,
config_get_ttl_tcpest, tcpest_fn,
config_get_ttl_tcptrans, tcptrans_fn);
sessiontable_init(&session_table_icmp,
config_get_ttl_icmp, just_die,
NULL, NULL);
return 0;
}
gint news_post(Folder *folder, const gchar *file)
{
gint ok;
char *contents = file_read_to_str_no_recode(file);
NewsSession *session;
cm_return_val_if_fail(folder != NULL, -1);
cm_return_val_if_fail(FOLDER_CLASS(folder) == &news_class, -1);
cm_return_val_if_fail(contents != NULL, -1);
session = news_session_get(folder);
if (!session) {
g_free(contents);
return -1;
}
ok = nntp_threaded_post(folder, contents, strlen(contents));
g_free(contents);
if (ok == NEWSNNTP_ERROR_STREAM) {
session_destroy(SESSION(session));
REMOTE_FOLDER(folder)->session = NULL;
}
return (ok == NEWSNNTP_NO_ERROR ? 0 : -1);
}
static gboolean nntp_ping(gpointer data)
{
Session *session = (Session *)data;
NewsSession *news_session = NEWS_SESSION(session);
int r;
struct tm lt;
if (session->state != SESSION_READY || news_folder_locked(news_session->folder))
return FALSE;
news_folder_lock(NEWS_FOLDER(news_session->folder));
if ((r = nntp_threaded_date(news_session->folder, <)) != NEWSNNTP_NO_ERROR) {
if (r != NEWSNNTP_ERROR_COMMAND_NOT_SUPPORTED &&
r != NEWSNNTP_ERROR_COMMAND_NOT_UNDERSTOOD) {
log_warning(LOG_PROTOCOL, _("NNTP connection to %s:%d has been"
" disconnected.\n"),
news_session->folder->account->nntp_server,
news_session->folder->account->set_nntpport ?
news_session->folder->account->nntpport : NNTP_PORT);
REMOTE_FOLDER(news_session->folder)->session = NULL;
news_folder_unlock(NEWS_FOLDER(news_session->folder));
session->state = SESSION_DISCONNECTED;
session->sock = NULL;
session_destroy(session);
return FALSE;
}
}
news_folder_unlock(NEWS_FOLDER(news_session->folder));
session_set_access_time(session);
return TRUE;
}
static void
reactor_logic_on_close_completed(struct server_s* self, void* ud)
{
struct net_reactor* reactor = (struct net_reactor*)server_getext(self);
struct net_session_s* session = (struct net_session_s*)ud;
session_destroy(reactor, session);
}
/*
* Rename a mailbox.
*/
int
request_rename(const char *server, const char *port, const char *user,
const char *oldmbox, const char *newmbox)
{
int r;
session *s;
char *o, *n;
if (!(s = session_find(server, port, user)))
return -1;
o = xstrdup(apply_namespace(oldmbox, s->ns.prefix, s->ns.delim));
n = xstrdup(apply_namespace(newmbox, s->ns.prefix, s->ns.delim));
r = response_generic(s, imap_rename(s, o, n));
xfree(o);
xfree(n);
if (r == -1)
goto fail;
return r;
fail:
close_connection(s);
session_destroy(s);
return -1;
}
int control_process() {
char* buffer = NULL;
// 检查用户是否按下了按钮
if (cgiFormSubmitClicked("led1") == cgiFormSuccess) {
// 调用 led 1 控制代码
control_led(0);
} else if (cgiFormSubmitClicked("led2") == cgiFormSuccess) {
// 调用 led 2 控制代码
control_led(1);
} else if (cgiFormSubmitClicked("logout") == cgiFormSuccess) {
// 退出登录
session_destroy();
cgiHeaderLocation(cgiScriptName);
return 0;
}
// 输出 ContentType header
// 作为 CGI 程序必须输出这个 header，否则会导致 500 错误
fprintf(cgiOut, "Pragma: no-cache\n");
cgiHeaderContentType("text/html");
buffer = read_template(g_control_template);
if (buffer == NULL) {
fprintf(cgiOut, "Warning: Can't read template file: %s.<br />\n",
g_control_template);
return -1;
}
fprintf(cgiOut, "%s", buffer);
free(buffer);
return 0;
}
/*
* Add, remove or replace the specified flags of the messages.
*/
int
request_store(const char *server, const char *port, const char *user,
const char *mesg, const char *mode, const char *flags)
{
int t, r;
session *s;
if (!(s = session_find(server, port, user)))
return -1;
t = imap_store(s, mesg, mode, flags);
if ((r = response_generic(s, t)) == -1)
goto fail;
if (xstrcasestr(flags, "\\Deleted") && get_option_boolean("expunge"))
if (response_generic(s, imap_expunge(s)) == -1)
goto fail;
return r;
fail:
close_connection(s);
session_destroy(s);
return -1;
}
/*
* Copy the specified messages to another mailbox.
*/
int
request_copy(const char *server, const char *port, const char *user,
const char *mesg, const char *mbox)
{
int t, r;
session *s;
const char *m;
if (!(s = session_find(server, port, user)))
return -1;
m = apply_namespace(mbox, s->ns.prefix, s->ns.delim);
do {
t = imap_copy(s, mesg, m);
switch (r = response_generic(s, t)) {
case STATUS_RESPONSE_TRYCREATE:
if (create_mailbox(s, mbox) == -1)
goto fail;
break;
case -1:
goto fail;
break;
}
} while (r == STATUS_RESPONSE_TRYCREATE);
return r;
fail:
close_connection(s);
session_destroy(s);
return -1;
}
/*
* Fetch the specified header fields, ie. BODY[HEADER.FIELDS (<fields>)], of
* the messages.
*/
int
request_fetchfields(const char *server, const char *port, const char *user,
const char *mesg, const char *headerfields, char **fields, size_t *len)
{
int t, r, n;
session *s;
char *f;
n = strlen("BODY.PEEK[HEADER.FIELDS ()]") + strlen(headerfields) + 1;
f = (char *)xmalloc(n * sizeof(char));
snprintf(f, n, "%s%s%s", "BODY.PEEK[HEADER.FIELDS (", headerfields, ")]");
if (!(s = session_find(server, port, user)))
return -1;
t = imap_fetch(s, mesg, f);
if ((r = response_fetchbody(s, t, fields, len)) == -1)
goto fail;
xfree(f);
return r;
fail:
close_connection(s);
session_destroy(s);
return -1;
}
/*
* Fetch the specified message part, ie. BODY[<part>], of the
* messages.
*/
int
request_fetchpart(const char *server, const char *port, const char *user,
const char *mesg, const char *part, char **bodypart, size_t *len)
{
int t, r, n;
session *s;
char *f;
n = strlen("BODY.PEEK[]") + strlen(part) + 1;
f = (char *)xmalloc(n * sizeof(char));
snprintf(f, n, "%s%s%s", "BODY.PEEK[", part, "]");
if (!(s = session_find(server, port, user)))
return -1;
t = imap_fetch(s, mesg, f);
if ((r = response_fetchbody(s, t, bodypart, len)) == -1)
goto fail;
xfree(f);
return r;
fail:
close_connection(s);
session_destroy(s);
return -1;
}
void session_del(session_list_t * list, session_t * session)
{
if (session->next == NULL && session->prev == NULL) // unique element of the list
{
list->first = NULL;
list->last = NULL;
}
else if (session->next == NULL) // last item of list
{
list->last = session->prev;
session->prev->next = NULL;
}
else if (session->prev == NULL) // first item of the list
{
list->first = session->next;
session->next->prev = NULL;
}
else // generic element of list
{
session->next->prev = session->prev;
session->prev->next = session->next;
}
session_destroy(session);
list->count --;
}
/*
* Get mailbox's status.
*/
int
request_status(const char *server, const char *port, const char *user,
const char *mbox, unsigned int *exists, unsigned int *recent,
unsigned int *unseen, unsigned int *uidnext)
{
int t, r;
session *s;
const char *m;
if (!(s = session_find(server, port, user)))
return -1;
m = apply_namespace(mbox, s->ns.prefix, s->ns.delim);
if (s->protocol == PROTOCOL_IMAP4REV1) {
t = imap_status(s, m, "MESSAGES RECENT UNSEEN UIDNEXT");
if ((r = response_status(s, t, exists, recent, unseen, uidnext)) == -1)
goto fail;
} else {
t = imap_examine(s, m);
if ((r = response_examine(s, t, exists, recent)) == -1)
goto fail;
}
return r;
fail:
close_connection(s);
session_destroy(s);
return -1;
}
static void inc_session_destroy(IncSession *session)
{
cm_return_if_fail(session != NULL);
session_destroy(session->session);
g_free(session);
}
void end_full(void)
{
filtering_destroy();
session_destroy();
bib_destroy();
pool4_destroy();
pool6_destroy();
}
void
test_session_create_and_close(void) {
lagopus_result_t ret;
lagopus_session_t ses;
ret = session_create(SESSION_TCP|SESSION_ACTIVE, &ses);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
session_destroy(ses);
}
static gboolean service_callback(GIOChannel *io, GIOCondition cond,
gpointer user_data)
{
struct bluetooth_session *session = user_data;
sdp_list_t *search, *attrid;
uint32_t range = 0x0000ffff;
GError *gerr = NULL;
uuid_t uuid;
if (cond & G_IO_NVAL)
return FALSE;
if (cond & G_IO_ERR)
goto failed;
if (sdp_set_notify(session->sdp, search_callback, session) < 0)
goto failed;
if (bt_string2uuid(&uuid, session->service) < 0)
goto failed;
sdp_uuid128_to_uuid(&uuid);
search = sdp_list_append(NULL, &uuid);
attrid = sdp_list_append(NULL, &range);
if (sdp_service_search_attr_async(session->sdp,
search, SDP_ATTR_REQ_RANGE, attrid) < 0) {
sdp_list_free(attrid, NULL);
sdp_list_free(search, NULL);
goto failed;
}
sdp_list_free(attrid, NULL);
sdp_list_free(search, NULL);
g_io_add_watch(io, G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
process_callback, session);
return FALSE;
failed:
g_io_channel_shutdown(session->io, TRUE, NULL);
g_io_channel_unref(session->io);
session->io = NULL;
g_set_error(&gerr, OBC_BT_ERROR, -EIO,
"Unable to find service record");
if (session->func)
session->func(session->io, gerr, session->user_data);
g_clear_error(&gerr);
session_destroy(session);
return FALSE;
}
void sessiondb_destroy(void)
{
log_debug("Emptying the session tables...");
sessiontable_destroy(&session_table_udp);
sessiontable_destroy(&session_table_tcp);
sessiontable_destroy(&session_table_icmp);
pktqueue_destroy();
session_destroy();
}
static void transport_callback(GIOChannel *io, GError *err, gpointer user_data)
{
struct bluetooth_session *session = user_data;
DBG("");
if (session->func)
session->func(io, err, session->user_data);
if (err != NULL)
session_destroy(session);
}
void
test_channel_session_get_set(void) {
struct channel *channel;
lagopus_session_t session;
lagopus_session_t ret_session;
channel = s_create_data_channel();
(void) session_create(SESSION_TCP|SESSION_ACTIVE, &session);
TEST_ASSERT_NOT_EQUAL_MESSAGE(session, channel_session_get(channel),
"session error.");
session_destroy(channel_session_get(channel));
/* Call func. */
channel_session_set(channel, session);
ret_session = channel_session_get(channel);
TEST_ASSERT_EQUAL_MESSAGE(ret_session, session,
"session error.");
session_destroy(channel_session_get(channel));
free(channel);
}
int
cmd_kill_session_exec(struct cmd *self, struct cmd_ctx *ctx)
{
struct args *args = self->args;
struct session *s;
if ((s = cmd_find_session(ctx, args_get(args, 't'))) == NULL)
return (-1);
server_destroy_session(s);
session_destroy(s);
return (0);
}
