SessionDlg::SessionDlg(QWidget* parent) : QDialog(parent), result_(0) {
ui.setupUi(this);
ui.sessionTree->header()->hide();
QStringList sList = sessionList();
foreach (QString session, sList) {
if (session.compare("_empty_session_") != 0) {
QStringList items;
items << session;
QTreeWidgetItem* it = new QTreeWidgetItem(items);
ui.sessionTree->addTopLevelItem(it);
}
}
if (sList.count() > 0) {
ui.sessionTree->setCurrentItem(ui.sessionTree->topLevelItem(0));
}
else {
ui.openSessionBtn->setEnabled(false);
ui.removeSessionBtn->setEnabled(false);
}
connect(ui.openSessionBtn, SIGNAL(clicked()), SLOT(openSession()));
connect(ui.newSessionBtn, SIGNAL(clicked()), SLOT(newSession()));
connect(ui.removeSessionBtn, SIGNAL(clicked()), SLOT(removeSession()));
connect(ui.sessionTree, SIGNAL(itemActivated(QTreeWidgetItem*, int)), SLOT(activated(QTreeWidgetItem*, int)));
}
void ServerStanzaChannel::finishSession(const JID& to, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ToplevelElement> element, bool last) {
#else
void ServerStanzaChannel::finishSession(const JID& to, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Element> element, bool last) {
#endif
std::vector<SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ServerFromClientSession> > candidateSessions;
for (std::list<SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ServerFromClientSession> >::const_iterator i = sessions[to.toBare().toString()].begin(); i != sessions[to.toBare().toString()].end(); ++i) {
candidateSessions.push_back(*i);
}
for (std::vector<SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ServerFromClientSession> >::const_iterator i = candidateSessions.begin(); i != candidateSessions.end(); ++i) {
removeSession(*i);
if (element) {
(*i)->sendElement(element);
}
if (last && (*i)->getRemoteJID().isValid()) {
Swift::Presence::ref presence = Swift::Presence::create();
presence->setFrom((*i)->getRemoteJID());
presence->setType(Swift::Presence::Unavailable);
onPresenceReceived(presence);
}
(*i)->finishSession();
// std::cout << "FINISH SESSION " << sessions[to.toBare().toString()].size() << "\n";
if (last) {
break;
}
}
}
bool CGroupModel::modifyGroupMember(uint32_t nUserId, uint32_t nGroupId, IM::BaseDefine::GroupModifyType nType, set<uint32_t>& setUserId, list<uint32_t>& lsCurUserId)
{
bool bRet = false;
if(hasModifyPermission(nUserId, nGroupId, nType))
{
switch (nType) {
case IM::BaseDefine::GROUP_MODIFY_TYPE_ADD:
bRet = addMember(nGroupId, setUserId, lsCurUserId);
break;
case IM::BaseDefine::GROUP_MODIFY_TYPE_DEL:
bRet = removeMember(nGroupId, setUserId, lsCurUserId);
removeSession(nGroupId, setUserId);
break;
default:
log("unknown type:%u while modify group.%u->%u", nType, nUserId, nGroupId);
break;
}
//if modify group member success, need to inc the group version and clear the user count;
if(bRet)
{
incGroupVersion(nGroupId);
for (auto it=setUserId.begin(); it!=setUserId.end(); ++it) {
uint32_t nUserId=*it;
CUserModel::getInstance()->clearUserCounter(nUserId, nGroupId, IM::BaseDefine::SESSION_TYPE_GROUP);
}
}
}
else
{
log("user:%u has no permission to modify group:%u", nUserId, nGroupId);
} return bRet;
}
/**
* Terminate the session pool, removing all objects and freeing allocated memory
*
* @param pool Pointer to session-pool structure.
*/
void terminateSessionPool(struct p11SessionPool_t *pool)
{
while(pool->list) {
if (removeSession(pool, pool->list->handle) != CKR_OK)
return;
}
}
bool AbstractSensorChannel::stop(int sessionId)
{
if(activeSessions_.remove(sessionId))
{
removeSession(sessionId); //Note: when client restarts the session it is responsible to reconfiguring the sensor.
return stop();
}
return false;
}
void ServerStanzaChannel::handleSessionFinished(const boost::optional<Session::SessionError>&, const SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ServerFromClientSession>& session) {
removeSession(session);
// if (!session->initiatedFinish()) {
Swift::Presence::ref presence = Swift::Presence::create();
presence->setFrom(session->getRemoteJID());
presence->setType(Swift::Presence::Unavailable);
onPresenceReceived(presence);
// }
}
void ObexManagerPrivate::interfacesRemoved(const QDBusObjectPath &objectPath, const QStringList &interfaces)
{
const QString &path = objectPath.path();
Q_FOREACH (const QString &interface, interfaces) {
if (interface == Strings::orgBluezObexSession1()) {
removeSession(path);
}
}
}
SockJsSession *takeNext()
{
Session *s = 0;
while(!s)
{
if(pendingSessions.isEmpty())
return 0;
s = pendingSessions.takeFirst();
s->pending = false;
if(!s->req && !s->sock)
{
// this means the object was a zombie. clean up and take next
removeSession(s);
s = 0;
continue;
}
}
s->ext = new SockJsSession;
if(s->req)
{
assert(!s->sid.isEmpty());
assert(!s->lastPart.isEmpty());
s->ext->setupServer(q, s->req, s->jsonpCallback, s->asUri, s->sid, s->lastPart, s->reqBody.toByteArray(), s->route);
s->req->disconnect(this);
sessionsByRequest.remove(s->req);
s->req = 0;
}
else // s->sock
{
if(!s->sid.isEmpty())
{
assert(!s->lastPart.isEmpty());
s->ext->setupServer(q, s->sock, s->asUri, s->sid, s->lastPart, s->route);
}
else
s->ext->setupServer(q, s->sock, s->asUri, s->route);
s->sock->disconnect(this);
sessionsBySocket.remove(s->sock);
s->sock = 0;
}
sessionsByExt.insert(s->ext, s);
s->ext->startServer();
return s->ext;
}
void SessionManager::renameSession( const QString & oldName, const QString & newName )
{
if (mCurrentSession && mCurrentSession->name() == oldName) {
saveSessionAs(newName);
removeSession(oldName);
} else {
QDir dir = sessionsDir();
if (dir.path().isEmpty())
return;
if (!dir.rename(oldName + ".yaml", newName + ".yaml"))
qWarning("Could not rename session file!");
}
}
/**
* Close all sessions opened for a slot
*
* @param pool Pointer to session-pool structure
* @param slotID The slot ID
*/
void closeSessionsForSlot(struct p11SessionPool_t *pool, CK_SLOT_ID slotID)
{
struct p11Session_t *session;
session = pool->list;
while (session != NULL) {
if (session->slotID == slotID) {
removeSession(pool, session->handle);
session = pool->list;
} else {
session = session->next;
}
}
}
void WebUserManager::checkExpiredSessions() noexcept {
SessionList removedSession;
auto tick = GET_TICK();
{
RLock l(cs);
boost::algorithm::copy_if(sessionsLocalId | map_values, back_inserter(removedSession), [=](const SessionPtr& s) {
return s->getLastActivity() + s->getMaxInactivity() < tick;
});
}
for (const auto& s : removedSession) {
// Don't remove sessions with active socket
if (!server->getSocket(s->getId())) {
removeSession(s);
}
}
}
void SessionMgr::saveSession(QString name)
{
QDir dir(getFolder());
if(!dir.exists())
dir.mkpath(dir.absolutePath());
if(m_sessions.contains(name))
removeSession(name);
QByteArray data;
DataFileParser parser(&data, QIODevice::WriteOnly, getFolder(), name);
sWorkTabMgr.saveData(&parser);
parser.close();
DataFileBuilder::writeWithHeader(getFolder() + name + ".cldta", data, true, DATAFILE_SESSION);
}
void unlink(SockJsSession *ext)
{
Session *s = sessionsByExt.value(ext);
assert(s);
sessionsByExt.remove(s->ext);
s->ext = 0;
if(s->closeValue.isValid())
{
// if there's a close value, hang around for a little bit
s->timer = new QTimer(this);
connect(s->timer, SIGNAL(timeout()), SLOT(timer_timeout()));
s->timer->setSingleShot(true);
sessionsByTimer.insert(s->timer, s);
s->timer->start(5000);
}
else
removeSession(s);
}
void HttpProtocolData::checkSession(HttpSession *ses)
{
LOG(0, "enter checkSession, ses = %p in task = %p\n", ses, ses->t);
HttpTask *task = ses->t;
LOG(0, "check task %p session from %lu, len %d, sessions size = %lu\n",
task->info, ses->pos, ses->length, task->sessions.size());
if (ses->length > 0)
{
LOG(0, "session length is not 0.\n");
}
removeSession(ses);
size_t begin;
size_t len;
if (findNonDownload(task, &begin, &len))
{
makeSession(task, begin, len);
}
else if (task->sessions.size() == 0)
{
TaskInfo *info = task->info;
LOG(0, "task %p finish\n", info);
task->info->downloadFinish(info);
p->removeTask(info);
}
else
{
splitMaxSession(task);
}
}
void SessionTreeControl::removeSessionEvent( wxCommandEvent& evt )
{
std::string selectedAddress = std::string(
GetItemText( GetSelection() ).char_str() );
removeSession( selectedAddress );
}
void SessionListWidget::removeSessionSlot()
{
QAction *action = qobject_cast<QAction *>(sender());
JobDefinition *job = action->data().value<JobDefinition *>();
emit removeSession(job);
}
void handleRequest(Session *s)
{
QString method = s->req->requestMethod();
log_debug("sockjs request: path=[%s], asUri=[%s]", s->path.data(), s->asUri.toEncoded().data());
if(method == "OPTIONS")
{
respondEmpty(s->req);
}
else if(method == "GET" && s->path == "/info")
{
quint32 x = (quint32)qrand();
QVariantMap out;
out["websocket"] = true;
out["origins"] = QVariantList() << QString("*:*");
out["cookie_needed"] = false;
out["entropy"] = x;
respondOk(s->req, out);
}
else if(method == "GET" && s->path.startsWith("/iframe") && s->path.endsWith(".html"))
{
HttpHeaders headers;
headers += HttpHeader("ETag", iframeHtmlEtag);
QByteArray ifNoneMatch = s->req->requestHeaders().get("If-None-Match");
if(ifNoneMatch == iframeHtmlEtag)
{
respond(s->req, 304, "Not Modified", headers, QByteArray());
}
else
{
headers += HttpHeader("Content-Type", "text/html; charset=UTF-8");
headers += HttpHeader("Cache-Control", "public, max-age=31536000");
respond(s->req, 200, "OK", headers, iframeHtml);
}
}
else
{
QList<QByteArray> parts = s->path.mid(1).split('/');
if(parts.count() == 3)
{
QByteArray sid = parts[1];
QByteArray lastPart = parts[2];
Session *existing = sessionsById.value(sid);
if(existing)
{
if(existing->ext)
{
// give to external session
ZhttpRequest *req = s->req;
QByteArray body = s->reqBody.toByteArray();
QByteArray jsonpCallback = s->jsonpCallback;
s->req->disconnect(this);
s->req = 0;
removeSession(s);
existing->ext->handleRequest(req, jsonpCallback, lastPart, body);
}
else
{
if(existing->closeValue.isValid())
{
respondOk(s->req, existing->closeValue, "c", s->jsonpCallback);
}
else
{
QVariantList out;
out += 2010;
out += QString("Another connection still open");
respondOk(s->req, out, "c", s->jsonpCallback);
}
}
return;
}
if((method == "POST" && lastPart == "xhr") || ((method == "GET" || method == "POST") && lastPart == "jsonp"))
{
if(lastPart == "jsonp" && s->jsonpCallback.isEmpty())
{
respondError(s->req, 400, "Bad Request", "Bad Request");
return;
}
s->sid = sid;
s->lastPart = lastPart;
sessionsById.insert(s->sid, s);
s->pending = true;
pendingSessions += s;
emit q->sessionReady();
return;
}
}
respondError(s->req, 404, "Not Found", "Not Found");
}
}
void WebUserManager::logout(const SessionPtr& aSession) {
aSession->onSocketDisconnected();
removeSession(aSession);
}
void ClassMember::removeSession(const QString &date)
{
removeSession(QDateTime::fromString(date, "yyyy.MM.dd-hh:mm"));
}
void SessionListWidget::onCloseSessionTriggered()
{
ChatSessionImpl *s = currentSession();
if(s)
removeSession(s);
}
