int32_t _shutdowns_direct( uint8_t index, struct session_manager * manager, struct sidlist * ids )
{
uint32_t i = 0;
int32_t count = 0;
for ( i = 0; i < sidlist_count(ids); ++i )
{
sid_t id = sidlist_get(ids, i);
if ( SID_INDEX(id) != index )
{
continue;
}
struct session * session = session_manager_get( manager, id );
if ( session == NULL )
{
continue;
}
// 直接终止
++count;
session_close( session );
session_shutdown( session );
}
sidlist_destroy( ids );
return count;
}
int
recv_init(struct nbr *nbr, char *buf, u_int16_t len)
{
struct ldp_msg init;
struct sess_prms_tlv sess;
log_debug("recv_init: neighbor ID %s", inet_ntoa(nbr->id));
bcopy(buf, &init, sizeof(init));
buf += sizeof(struct ldp_msg);
len -= sizeof(struct ldp_msg);
if (len < SESS_PRMS_SIZE) {
session_shutdown(nbr, S_BAD_MSG_LEN, init.msgid, init.type);
return (-1);
}
bcopy(buf, &sess, sizeof(sess));
if (ntohs(sess.length) != SESS_PRMS_SIZE - TLV_HDR_LEN ||
ntohs(sess.length) > len - TLV_HDR_LEN) {
session_shutdown(nbr, S_BAD_TLV_LEN, init.msgid, init.type);
return (-1);
}
if (ntohs(sess.proto_version) != LDP_VERSION) {
session_shutdown(nbr, S_BAD_PROTO_VER, init.msgid, init.type);
return (-1);
}
buf += SESS_PRMS_SIZE;
len -= SESS_PRMS_SIZE;
/* just ignore all optional TLVs for now */
if (tlv_decode_opt_init_prms(buf, len) == -1) {
session_shutdown(nbr, S_BAD_TLV_VAL, init.msgid, init.type);
return (-1);
}
nbr->keepalive = min(leconf->keepalive, ntohs(sess.keepalive_time));
if (!nbr_pending_idtimer(nbr))
nbr_fsm(nbr, NBR_EVT_INIT_RCVD);
return (ntohs(init.length));
}
int
recv_notification(struct nbr *nbr, char *buf, u_int16_t len)
{
struct ldp_msg not;
struct status_tlv st;
log_debug("recv_notification: neighbor ID %s", inet_ntoa(nbr->id));
bcopy(buf, ¬, sizeof(not));
buf += sizeof(struct ldp_msg);
len -= sizeof(struct ldp_msg);
if (len < STATUS_SIZE) {
session_shutdown(nbr, S_BAD_MSG_LEN, not.msgid, not.type);
return (-1);
}
bcopy(buf, &st, sizeof(st));
if (ntohs(st.length) > STATUS_SIZE - TLV_HDR_LEN ||
ntohs(st.length) > len - TLV_HDR_LEN) {
session_shutdown(nbr, S_BAD_TLV_LEN, not.msgid, not.type);
return (-1);
}
/* TODO optional parameters: ext status, returned PDU and msg */
if (st.status_code & htonl(STATUS_FATAL))
log_warnx("received notification from neighbor %s: %s",
inet_ntoa(nbr->id),
notification_name(ntohl(st.status_code)));
else
log_debug("received non-fatal notification from neighbor "
"%s: %s", inet_ntoa(nbr->id),
notification_name(ntohl(st.status_code)));
if (st.status_code & htonl(STATUS_FATAL)) {
nbr_fsm(nbr, NBR_EVT_CLOSE_SESSION);
return (-1);
}
/* XXX in some cases we should inform the RDE about non-fatal ones */
return (ntohs(not.length));
}
int32_t _shutdown_direct( struct session_manager * manager, sid_t id )
{
struct session * session = session_manager_get( manager, id );
if ( session == NULL )
{
syslog(LOG_WARNING, "%s(SID=%ld) failed, the Session is invalid .", __FUNCTION__,id );
return -1;
}
// 设置会话被逻辑层终止了
session_close( session );
return session_shutdown( session );
}
int
recv_keepalive(struct nbr *nbr, char *buf, u_int16_t len)
{
struct ldp_msg ka;
bcopy(buf, &ka, sizeof(ka));
if (len != LDP_MSG_LEN) {
session_shutdown(nbr, S_BAD_MSG_LEN, ka.msgid, ka.type);
return (-1);
}
if (nbr->state != NBR_STA_OPER)
nbr_fsm(nbr, NBR_EVT_KEEPALIVE_RCVD);
else
nbr_fsm(nbr, NBR_EVT_PDU_RCVD);
return (ntohs(ka.length));
}
static void
initiate_shutdown (GsmSession *session)
{
GSList *cl;
session->phase = GSM_SESSION_PHASE_SHUTDOWN;
if (session->clients == NULL)
session_shutdown (session);
for (cl = session->clients; cl; cl = cl->next)
{
GsmClient *client = GSM_CLIENT (cl->data);
session->shutdown_clients =
g_slist_prepend (session->shutdown_clients, client);
gsm_client_save_yourself (client, FALSE);
}
}
static void
client_save_yourself_done (GsmClient *client, gpointer data)
{
GsmSession *session = data;
session->shutdown_clients =
g_slist_remove (session->shutdown_clients, client);
session->interact_clients =
g_slist_remove (session->interact_clients, client);
session->phase2_clients =
g_slist_remove (session->phase2_clients, client);
if (session->phase == GSM_SESSION_PHASE_SHUTDOWN &&
!session->shutdown_clients)
{
if (session->phase2_clients)
session_shutdown_phase2 (session);
else
session_shutdown (session);
}
}
static void
_shutdown(void)
{
if (prefs_get_boolean(PREF_WINTITLE_SHOW)) {
if (prefs_get_boolean(PREF_WINTITLE_GOODBYE)) {
ui_goodbye_title();
} else {
ui_clear_win_title();
}
}
jabber_conn_status_t conn_status = connection_get_status();
if (conn_status == JABBER_CONNECTED) {
cl_ev_disconnect();
}
#ifdef HAVE_GTK
tray_shutdown();
#endif
session_shutdown();
plugins_on_shutdown();
muc_close();
caps_close();
#ifdef HAVE_LIBOTR
otr_shutdown();
#endif
#ifdef HAVE_LIBGPGME
p_gpg_close();
#endif
chat_log_close();
theme_close();
accounts_close();
tlscerts_close();
log_stderr_close();
log_close();
plugins_shutdown();
cmd_uninit();
ui_close();
prefs_close();
}
static int on_session(session *s, void *param)
{
if (session_on_connect(s))
{
printf("CONNECTED\n");
return 1;
}
if (session_on_disconnect(s))
{
printf("DISCONNECTED\n");
return 0;
}
char *msg;
if (!session_readmsg(s, &msg)) // read the echo
return 0;
if (!g_quiet) printf("DATA: %s", msg);
int count = session_get_udata_int(s);
if (count++ == g_loops)
{
session_shutdown(s);
return 0;
}
session_set_udata_int(s, count);
if (session_writemsg(s, hello) <= 0)
{
printf("write: %s\n", strerror(errno));
return 0;
}
return 1;
}
static void session_cleanup(struct event_session *session)
{
session_shutdown(session);
ao2_cleanup(session);
}
int
recv_address(struct nbr *nbr, char *buf, u_int16_t len)
{
struct ldp_msg addr;
struct address_list_tlv alt;
enum imsg_type type;
if (nbr->state != NBR_STA_OPER) {
log_debug("recv_address: neighbor ID %s not operational",
inet_ntoa(nbr->id));
return (-1);
}
bcopy(buf, &addr, sizeof(addr));
log_debug("recv_address: neighbor ID %s%s", inet_ntoa(nbr->id),
ntohs(addr.type) == MSG_TYPE_ADDR ? "" : " address withdraw");
if (ntohs(addr.type) == MSG_TYPE_ADDR)
type = IMSG_ADDRESS_ADD;
else
type = IMSG_ADDRESS_DEL;
buf += sizeof(struct ldp_msg);
len -= sizeof(struct ldp_msg);
if (len < sizeof(alt)) {
session_shutdown(nbr, S_BAD_MSG_LEN, addr.msgid, addr.type);
return (-1);
}
bcopy(buf, &alt, sizeof(alt));
if (ntohs(alt.length) != len - TLV_HDR_LEN) {
session_shutdown(nbr, S_BAD_TLV_LEN, addr.msgid, addr.type);
return (-1);
}
if (ntohs(alt.type) != TLV_TYPE_ADDRLIST) {
session_shutdown(nbr, S_UNKNOWN_TLV, addr.msgid, addr.type);
return (-1);
}
/* For now we only support IPv4 */
if (alt.family != htons(ADDR_IPV4)) {
send_notification_nbr(nbr, S_UNSUP_ADDR, addr.msgid, addr.type);
return (-1);
}
buf += sizeof(alt);
len -= sizeof(alt);
while (len >= sizeof(struct in_addr)) {
ldpe_imsg_compose_lde(type, nbr->peerid, 0,
buf, sizeof(struct in_addr));
buf += sizeof(struct in_addr);
len -= sizeof(struct in_addr);
}
if (len != 0) {
session_shutdown(nbr, S_BAD_TLV_LEN, addr.msgid, addr.type);
return (-1);
}
return (ntohs(addr.length));
}
int
recv_notification(struct nbr *nbr, char *buf, uint16_t len)
{
struct ldp_msg msg;
struct status_tlv st;
struct notify_msg nm;
int tlen;
memcpy(&msg, buf, sizeof(msg));
buf += LDP_MSG_SIZE;
len -= LDP_MSG_SIZE;
if (len < STATUS_SIZE) {
session_shutdown(nbr, S_BAD_MSG_LEN, msg.id, msg.type);
return (-1);
}
memcpy(&st, buf, sizeof(st));
if (ntohs(st.length) > STATUS_SIZE - TLV_HDR_SIZE ||
ntohs(st.length) > len - TLV_HDR_SIZE) {
session_shutdown(nbr, S_BAD_TLV_LEN, msg.id, msg.type);
return (-1);
}
buf += STATUS_SIZE;
len -= STATUS_SIZE;
memset(&nm, 0, sizeof(nm));
nm.status_code = ntohl(st.status_code);
/* Optional Parameters */
while (len > 0) {
struct tlv tlv;
uint16_t tlv_len;
if (len < sizeof(tlv)) {
session_shutdown(nbr, S_BAD_TLV_LEN, msg.id, msg.type);
return (-1);
}
memcpy(&tlv, buf, TLV_HDR_SIZE);
tlv_len = ntohs(tlv.length);
if (tlv_len + TLV_HDR_SIZE > len) {
session_shutdown(nbr, S_BAD_TLV_LEN, msg.id, msg.type);
return (-1);
}
buf += TLV_HDR_SIZE;
len -= TLV_HDR_SIZE;
switch (ntohs(tlv.type)) {
case TLV_TYPE_EXTSTATUS:
case TLV_TYPE_RETURNEDPDU:
case TLV_TYPE_RETURNEDMSG:
/* TODO is there any use for this? */
break;
case TLV_TYPE_PW_STATUS:
if (tlv_len != 4) {
session_shutdown(nbr, S_BAD_TLV_LEN,
msg.id, msg.type);
return (-1);
}
nm.pw_status = ntohl(*(uint32_t *)buf);
nm.flags |= F_NOTIF_PW_STATUS;
break;
case TLV_TYPE_FEC:
if ((tlen = tlv_decode_fec_elm(nbr, &msg, buf,
tlv_len, &nm.fec)) == -1)
return (-1);
/* allow only one fec element */
if (tlen != tlv_len) {
session_shutdown(nbr, S_BAD_TLV_VAL,
msg.id, msg.type);
return (-1);
}
nm.flags |= F_NOTIF_FEC;
break;
default:
if (!(ntohs(tlv.type) & UNKNOWN_FLAG))
send_notification_nbr(nbr, S_UNKNOWN_TLV,
msg.id, msg.type);
/* ignore unknown tlv */
break;
}
buf += tlv_len;
len -= tlv_len;
}
if (nm.status_code == S_PW_STATUS) {
if (!(nm.flags & (F_NOTIF_PW_STATUS|F_NOTIF_FEC))) {
send_notification_nbr(nbr, S_MISS_MSG,
msg.id, msg.type);
return (-1);
}
switch (nm.fec.type) {
case MAP_TYPE_PWID:
break;
default:
send_notification_nbr(nbr, S_BAD_TLV_VAL,
msg.id, msg.type);
return (-1);
}
}
if (st.status_code & htonl(STATUS_FATAL))
log_warnx("received notification from lsr-id %s: %s",
inet_ntoa(nbr->id),
status_code_name(ntohl(st.status_code)));
else
log_debug("received non-fatal notification from lsr-id "
"%s: %s", inet_ntoa(nbr->id),
status_code_name(ntohl(st.status_code)));
if (st.status_code & htonl(STATUS_FATAL)) {
if (nbr->state == NBR_STA_OPENSENT)
nbr_start_idtimer(nbr);
nbr_fsm(nbr, NBR_EVT_CLOSE_SESSION);
return (-1);
}
if (nm.status_code == S_PW_STATUS)
ldpe_imsg_compose_lde(IMSG_NOTIFICATION, nbr->peerid, 0,
&nm, sizeof(nm));
return (0);
}
static void owner_disconnected(DBusConnection *connection, void *user_data)
{
struct session_data *session = user_data;
session_shutdown(session);
}
