/* * 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); }