wxTreeItemId SessionTreeControl::findSession( wxTreeItemId root,
std::string address )
{
wxTreeItemIdValue temp; // unused var, needed in getchild
wxTreeItemId targetItem;
wxTreeItemId current = GetFirstChild( root, temp );
while ( current.IsOk() )
{
wxString text = GetItemText( current );
std::string target = std::string( text.char_str() );
if ( target.compare( address ) == 0 )
return current;
if ( ItemHasChildren( current ) )
{
targetItem = findSession( current, address );
if ( targetItem.IsOk() )
return targetItem;
}
current = GetNextChild( root, temp );
}
wxTreeItemId none;
return none; // return default value if not found
}
void SessionTreeControl::removeSession( std::string address )
{
wxTreeItemId item = findSession( rootID, address );
if ( !item.IsOk() )
{
gravUtil::logWarning( "SessionTreeControl::removeObject: "
"item %s not found?\n", address.c_str() );
return;
}
SessionType type;
wxTreeItemId parent = GetItemParent( item );
if ( parent == videoNodeID )
type = VIDEOSESSION;
else if ( parent == audioNodeID )
type = AUDIOSESSION;
else if ( parent == availableVideoNodeID )
type = AVAILABLEVIDEOSESSION;
else
{
gravUtil::logError( "SessionTreeControl::removeObject: "
"cannot remove %s - invalid tree\n", address.c_str() );
return;
}
if ( sessionManager->removeSession( address, type ) )
Delete( item );
else
{
gravUtil::logError( "SessionTreeControl::removeObject: "
"removal of %s failed \n", address.c_str() );
// TODO throw GUI error dialog
}
}
int logoffUser(TCHAR *userToLogoff)
{
wprintf(L"Logging off %s\n", userToLogoff);
int sessionId = findSession(userToLogoff);
if (sessionId != -1)
{
wprintf(L" session %d\n", sessionId);
if (!WTSLogoffSession(WTS_CURRENT_SERVER_HANDLE, sessionId, TRUE))
{
printError(L"WTSLogoffSession failed: %s");
return 3;
}
else
wprintf(L" ...done.\n");
}
else
{
std::wstring msg;
msg.append(L"Session for ")
.append(userToLogoff)
.append(L" not found");
wprintf(msg.c_str());
showBalloonTip(msg.c_str());
return 2;
}
return 0;
}
void InspectorReplayAgent::insertSessionSegment(ErrorString& errorString, Inspector::Protocol::Replay::SessionIdentifier sessionIdentifier, SegmentIdentifier segmentIdentifier, int segmentIndex)
{
ASSERT_ARG(sessionIdentifier, sessionIdentifier > 0);
ASSERT_ARG(segmentIdentifier, segmentIdentifier > 0);
ASSERT_ARG(segmentIndex, segmentIndex >= 0);
RefPtr<ReplaySession> session = findSession(errorString, sessionIdentifier);
RefPtr<ReplaySessionSegment> segment = findSegment(errorString, segmentIdentifier);
if (!session || !segment)
return;
if (static_cast<size_t>(segmentIndex) > session->size()) {
errorString = ASCIILiteral("Invalid segment index.");
return;
}
if (session == m_page.replayController().loadedSession() && sessionState() != WebCore::SessionState::Inactive) {
errorString = ASCIILiteral("Can't modify a loaded session unless the session is inactive.");
return;
}
session->insertSegment(segmentIndex, WTF::move(segment));
sessionModified(WTF::move(session));
}
//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
void CaClientNotifierProxy::unregisterNotifier(
const CaNotifierFilter ¬ifierFilter,
CaNotifierPrivate::NotifierType notifierType)
{
qDebug() << "CaClientProxy::unregisterNotifier notifierType:"
<< notifierType;
CCaInnerNotifierFilter::TNotifierType innerNotifierType(
CCaInnerNotifierFilter::EEntryChangedWithId);
CaObjectAdapter::convert(
notifierType,
innerNotifierType);
TInt pos = findSession(notifierFilter, innerNotifierType);
if (pos != KErrNotFound) {
// Lock the access to mSessions.
// It will be automatically unlocked at the end of the current range.
QMutexLocker locker(&mMutex);
mSessions[pos].UnregisterNotifier(¬ifierFilter,
innerNotifierType);
if (mSessions[pos].SubsessionsCount() == 0) {
mSessions[pos].Close();
mSessions.Remove(pos);
}
}
}
/**********************************************************************
*%FUNCTION: relayHandlePADT
*%ARGUMENTS:
* iface -- interface on which packet was received
* packet -- the PADT packet
*%RETURNS:
* Nothing
*%DESCRIPTION:
* Receives and processes a PADT packet.
***********************************************************************/
void
relayHandlePADT(PPPoEInterface const *iface,
PPPoEPacket *packet,
int size)
{
SessionHash *sh;
PPPoESession *ses;
/* Destination address must be interface's MAC address */
if (memcmp(packet->ethHdr.h_dest, iface->mac, ETH_ALEN)) {
return;
}
sh = findSession(packet->ethHdr.h_source, packet->session);
if (!sh) {
return;
}
/* Relay the PADT to the peer */
sh = sh->peer;
ses = sh->ses;
packet->session = sh->sesNum;
memcpy(packet->ethHdr.h_source, sh->interface->mac, ETH_ALEN);
memcpy(packet->ethHdr.h_dest, sh->peerMac, ETH_ALEN);
sendPacket(NULL, sh->interface->sessionSock, packet, size);
/* Destroy the session */
freeSession(ses, "Received PADT");
}
int ShmCacheManager::isPurgedByTag(
const char *pTag, CacheEntry *pEntry, CacheKey *pKey, bool isCheckPrivate)
{
if (isCheckPrivate)
{
//assert( "NO_PRIVATE_PURGE_YET" == NULL );
ShmPrivatePurgeData privatePurge;
int ret = findSession(pKey, &privatePurge);
if (ret == 1)
{
if (privatePurge.isFlushed(pEntry->getHeader().m_tmCreated,
pEntry->getHeader().m_msCreated))
return 1;
int tagId = findTagId(pTag, pEntry->getHeader().m_tagLen);
if (tagId == -1)
return 0;
if (privatePurge.shouldPurge(tagId,
pEntry->getHeader().m_tmCreated,
pEntry->getHeader().m_msCreated))
return 1;
}
}
else
{
if (shouldPurge(pTag, pEntry->getHeader().m_tagLen,
pEntry->getHeader().m_tmCreated, pEntry->getHeader().m_msCreated))
return 1;
}
return 0;
}
EdgeSession* RTMFPServerEdge::findEdgeSession(UInt32 id) {
EdgeSession* pSession= dynamic_cast<EdgeSession*>(findSession(id));
if(pSession)
return pSession;
DEBUG("Unknown edge session %u",id);
return NULL;
}
/**
* popuplate the side bar with all sessions inside the current window. Information
* is gathered from the tab control, which remains active (but invisible) when the
* switch bar is in use.
*
* This is needed when the user switches from tabs to a switchbar layout while a
* window is open.
*/
void CSideBar::populateAll()
{
HWND hwndTab = ::GetDlgItem(m_pContainer->hwnd, IDC_MSGTABS);
if (hwndTab == NULL)
return;
int iItems = (int)TabCtrl_GetItemCount(hwndTab);
TCITEM item = { 0 };
item.mask = TCIF_PARAM;
m_iTopButtons = 0;
for (int i = 0; i < iItems; i++) {
TabCtrl_GetItem(hwndTab, i, &item);
if (item.lParam == 0 || !IsWindow((HWND)item.lParam))
continue;
TWindowData *dat = (TWindowData*)::GetWindowLongPtr((HWND)item.lParam, GWLP_USERDATA);
if (dat == NULL)
continue;
CSideBarButton *b_item = findSession(dat);
if (b_item == NULL)
addSession(dat, i);
else {
b_item->setLayout(m_currentLayout);
if (m_dwFlags & SIDEBARLAYOUT_VERTICALORIENTATION) {
b_item->measureItem();
m_topHeight += b_item->getHeight() + 1;
}
else m_topHeight += m_elementHeight + 1;
}
}
}
int switchUser(TCHAR *username, TCHAR *password)
{
int sessionId = findSession(username);
if (password == NULL)
password = L"";
if (sessionId == -1)
{
std::wstring msg;
msg.append(L"Session for ")
.append(username)
.append(L" not found");
wprintf(msg.c_str());
showBalloonTip(msg.c_str());
return 2;
}
if(!WTSConnectSession(sessionId, WTSGetActiveConsoleSessionId(), password, true))
{
wprintf(L"SessionId: %d\n", sessionId);
printError(L"WTSConnectSession error: %s\n");
return 2;
}
return 0;
}
/**
* @brief Resets the server side timeout for this session
*/
void MemorySessionStore::touch(const string& cookie) {
ReadOnlyLock lock(_lock);
Session* session = findSession(lock, cookie);
if (session != 0) {
ReadWriteLock bigLock(_lock);
session->updateLoginTime();
}
}
/**
* Sets the active session item
* called from the global update handler in msgdialog/group room window
* on every tab activation to ensure consistency
*
* @param dat _MessageWindowData*: session data
*
* @return The previously active item (that can be zero)
*/
const CSideBarButton* CSideBar::setActiveItem(const TWindowData *dat)
{
CSideBarButton *item = findSession(dat);
if (item != NULL)
return setActiveItem(item);
return 0;
}
void CSideBar::invalidateButton(const TWindowData *dat)
{
if (m_isActive && m_isVisible) {
CSideBarButton *item = findSession(dat);
if (item != NULL)
RedrawWindow(item->m_buttonControl->hwnd, 0, 0, RDW_INVALIDATE | RDW_UPDATENOW);
}
}
void InspectorReplayAgent::getSessionData(ErrorString& errorString, Inspector::Protocol::Replay::SessionIdentifier identifier, RefPtr<Inspector::Protocol::Replay::ReplaySession>& serializedObject)
{
RefPtr<ReplaySession> session = findSession(errorString, identifier);
if (!session) {
errorString = ASCIILiteral("Couldn't find the specified session.");
return;
}
serializedObject = buildInspectorObjectForSession(WTF::move(session));
}
void SessionTreeControl::unrotateVideoSessions()
{
wxTreeItemId current = findSession( availableVideoNodeID,
sessionManager->getCurrentRotateSessionAddress() );
if ( current.IsOk() )
{
SetItemBackgroundColour( current, *wxBLUE );
SetItemTextColour( current, *wxBLACK );
}
sessionManager->unrotate( false );
}
void SessionTreeControl::rotateToVideoSession( std::string addr, bool fromAuto )
{
if ( !sessionManager->rotateTo( addr, false ) )
{
gravUtil::logVerbose( "SessionTreeControl::rotateTo %s failed\n",
addr.c_str() );
return;
}
wxTreeItemId current = findSession( availableVideoNodeID,
sessionManager->getCurrentRotateSessionAddress() );
wxTreeItemId last = findSession( availableVideoNodeID,
sessionManager->getLastRotateSessionAddress() );
if ( last.IsOk() )
{
SetItemBackgroundColour( last, *wxBLUE );
SetItemTextColour( last, *wxBLACK );
}
if ( current.IsOk() )
{
if ( sessionManager->isInFailedState(
sessionManager->getCurrentRotateSessionAddress(),
AVAILABLEVIDEOSESSION ) )
{
SetItemBackgroundColour( current, *wxRED );
}
else
{
SetItemBackgroundColour( current, *wxWHITE );
SetItemTextColour( current, *wxBLUE );
}
}
// if manually rotated & currently autorotating, stop autorotating
if ( !fromAuto && timer->IsRunning() )
{
toggleAutomaticRotate();
}
}
ATerm get_session_by_path(int cid, const char *path) {
EM_Session session;
EM_Sid sid;
assert(path != NULL);
session = findSession(path);
if (session == NULL) {
return sndValue(ATmake("no-such-session"));
}
sid = EM_getSessionId(session);
return sndValue(ATmake("session(<term>)", EM_SidToTerm(sid)));
}
void InspectorReplayAgent::switchSession(ErrorString& errorString, Inspector::Protocol::Replay::SessionIdentifier identifier)
{
ASSERT_ARG(identifier, identifier > 0);
if (sessionState() != WebCore::SessionState::Inactive) {
errorString = ASCIILiteral("Can't switch sessions unless the session is neither capturing or replaying.");
return;
}
RefPtr<ReplaySession> session = findSession(errorString, identifier);
if (!session)
return;
m_page.replayController().switchSession(WTF::move(session));
}
QByteArray TSessionManager::generateId()
{
QByteArray id;
int i;
for (i = 0; i < 3; ++i) {
id = randomString();
if (findSession(id).isEmpty())
break;
}
if (i == 3)
throw RuntimeException("Unable to generate a unique session ID", __FILE__, __LINE__);
return id;
}
/**
* @brief Returns the userId of the currently logged in user.
* Throws std::invalid_argument if no user with that cookie found.
*
* @param cookie the cookie that the client browser gave us
* @param touch If true, updates the session time out
*
* @return userId of the currently logged in user
*/
int MemorySessionStore::userId(const string& cookie, bool touch) {
ReadOnlyLock lock(_lock);
Session* session = findSession(lock, cookie);
if (session != 0) {
if (session->age() < _timeout) {
if (touch) {
ReadWriteLock touchLock(_lock);
// Session is still good, update its timeout on our end
session->updateLoginTime();
}
return session->userId();
} else {
// Cookie is expired - delete its session and return empty
ReadWriteLock eraseLock(_lock);
sessions.erase(cookie);
}
}
throw invalid_argument("No user with cookie " + cookie + " found");
}
/**
* Remove a new session from the switchbar.
*
* @param dat _MessageWindowData *: session data for a client session.
*/
HRESULT CSideBar::removeSession(const TWindowData *dat)
{
if (dat) {
CSideBarButton *item = findSession(dat);
if (item != NULL) {
m_iTopButtons--;
if (m_dwFlags & SIDEBARLAYOUT_DYNHEIGHT) {
SIZE sz = item->getSize();
m_topHeight -= (sz.cy + 1);
}
else m_topHeight -= (m_elementHeight + 1);
m_buttonlist.remove(item);
Invalidate();
return(S_OK);
}
}
return(S_FALSE);
}
ATerm create_session(int cid, const char *path) {
EM_Session session;
assert(path != NULL);
session = findSession(path);
if (session != NULL) {
EM_SessionStatus status = EM_getSessionStatus(session);
if (!EM_isSessionStatusZombie(status)) {
return sndValue(ATmake("session(<term>)", EM_getSessionId(session)));
}
}
EM_Sid sid = makeUniqueSessionId();
EM_EditorTypeList list = EM_makeEditorTypeListEmpty();
EM_SessionStatus status = EM_makeSessionStatusRunning();
session = EM_makeSessionDefault(sid, path, status, 0, list);
putSession(session);
return sndValue(ATmake("session(<term>)", EM_getSessionId(session)));
}
//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
int CaClientNotifierProxy::registerNotifier(
const CaNotifierFilter *notifierFilter,
CaNotifierPrivate::NotifierType notifierType,
const IDataObserver *observer)
{
qDebug() << "CaClientProxy::registerNotifier notifierType:"
<< notifierType;
CCaInnerNotifierFilter::TNotifierType innerNotifierType(
CCaInnerNotifierFilter::EEntryChangedWithId);
CaObjectAdapter::convert(notifierType,
innerNotifierType);
CCaInnerNotifierFilter *innerNotifierFilter(NULL);
TRAPD(error,
innerNotifierFilter =
CCaInnerNotifierFilter::NewLC(innerNotifierType);
CaObjectAdapter::convertL(*notifierFilter, *innerNotifierFilter);
CleanupStack::Pop(innerNotifierFilter)
);
if (!error) {
// Lock the access to mSessions.
// It will be automatically unlocked at the end of the current range.
QMutexLocker locker(&mMutex);
RCaClientNotifierSession *session = findSession();
if (!session) {
session = newSession(error);
}
if (!error) {
error = session->RegisterNotifier(innerNotifierFilter,
notifierFilter, observer);
}
}
qDebug() << "CaClientProxy::registerNotifier result:" << error;
return error;
}
IDE_RC mmtServiceThread::planGetProtocolA5(cmiProtocolContext *aProtocolContext,
cmiProtocol *aProtocol,
void *aSessionOwner,
void *aUserContext)
{
cmpArgDBPlanGetA5 *sArg = CMI_PROTOCOL_GET_ARG(*aProtocol, DB, PlanGet);
mmcTask *sTask = (mmcTask *)aSessionOwner;
mmtServiceThread *sThread = (mmtServiceThread *)aUserContext;
mmcSession *sSession;
mmcStatement *sStatement;
IDE_CLEAR();
IDE_TEST(findSession(sTask, &sSession, sThread) != IDE_SUCCESS);
IDE_TEST(checkSessionState(sSession, MMC_SESSION_STATE_SERVICE) != IDE_SUCCESS);
IDE_TEST(findStatement(&sStatement,
sSession,
&sArg->mStatementID,
sThread) != IDE_SUCCESS);
if (sStatement->isPlanPrinted() != ID_TRUE)
{
IDE_TEST(checkStatementState(sStatement, MMC_STMT_STATE_PREPARED) != IDE_SUCCESS);
IDE_TEST(sStatement->makePlanTreeText(ID_TRUE) != IDE_SUCCESS);
}
return answerPlanGetResult(aProtocolContext,
sStatement->getStmtID(),
sStatement->getPlanString());
IDE_EXCEPTION_END;
return sThread->answerErrorResultA5(aProtocolContext,
CMI_PROTOCOL_OPERATION(DB, PlanGet),
0);
}
/**
* Invalidate the button associated with the given session.
*
* @param dat _MessageWindowData*: Session data
*/
void CSideBar::updateSession(const TWindowData *dat)
{
if (!m_isVisible || !m_isActive)
return;
CSideBarButton *item = findSession(dat);
if (item == NULL)
return;
if (m_dwFlags & SIDEBARLAYOUT_DYNHEIGHT) {
LONG oldHeight = item->getHeight();
m_topHeight -= (oldHeight + 1);
SIZE sz = item->measureItem();
m_topHeight += (sz.cy + 1);
if (sz.cy != oldHeight) {
Invalidate();
::InvalidateRect(item->getHwnd(), NULL, TRUE);
}
else ::InvalidateRect(item->getHwnd(), NULL, FALSE);
}
else ::InvalidateRect(item->getHwnd(), NULL, FALSE);
}
void InspectorReplayAgent::removeSessionSegment(ErrorString* errorString, Inspector::Protocol::Replay::SessionIdentifier identifier, int segmentIndex)
{
ASSERT(identifier > 0);
ASSERT(segmentIndex >= 0);
RefPtr<ReplaySession> session = findSession(errorString, identifier);
if (!session)
return;
if (static_cast<size_t>(segmentIndex) >= session->size()) {
*errorString = ASCIILiteral("Invalid segment index.");
return;
}
if (session == m_page.replayController().loadedSession() && sessionState() != WebCore::SessionState::Inactive) {
*errorString = ASCIILiteral("Can't modify a loaded session unless the session is inactive.");
return;
}
session->removeSegment(segmentIndex);
sessionModified(session);
}
/**********************************************************************
*%FUNCTION: relayGotSessionPacket
*%ARGUMENTS:
* iface -- interface on which packet is waiting
*%RETURNS:
* Nothing
*%DESCRIPTION:
* Receives and processes a session packet.
***********************************************************************/
void
relayGotSessionPacket(PPPoEInterface const *iface)
{
PPPoEPacket packet;
int size;
SessionHash *sh;
PPPoESession *ses;
if (receivePacket(iface->sessionSock, &packet, &size) < 0) {
return;
}
/* Ignore unknown code/version */
if (packet.ver != 1 || packet.type != 1) {
return;
}
/* Must be a session packet */
if (packet.code != CODE_SESS) {
syslog(LOG_ERR, "Session packet with code %d", (int) packet.code);
return;
}
/* Ignore session packets whose destination address isn't ours */
if (memcmp(packet.ethHdr.h_dest, iface->mac, ETH_ALEN)) {
return;
}
/* Validate length */
if (ntohs(packet.length) + HDR_SIZE > size) {
syslog(LOG_ERR, "Bogus PPPoE length field (%u)",
(unsigned int) ntohs(packet.length));
return;
}
/* Drop Ethernet frame padding */
if (size > ntohs(packet.length) + HDR_SIZE) {
size = ntohs(packet.length) + HDR_SIZE;
}
/* We're in business! Find the hash */
sh = findSession(packet.ethHdr.h_source, packet.session);
if (!sh) {
/* Don't log this. Someone could be running the client and the
relay on the same box. */
return;
}
/* Relay it */
ses = sh->ses;
ses->epoch = Epoch;
sh = sh->peer;
packet.session = sh->sesNum;
memcpy(packet.ethHdr.h_source, sh->interface->mac, ETH_ALEN);
memcpy(packet.ethHdr.h_dest, sh->peerMac, ETH_ALEN);
#if 0
printf( "Relaying %02x:%02x:%02x:%02x:%02x:%02x(%s:%d) to %02x:%02x:%02x:%02x:%02x:%02x(%s:%d)\n",
sh->peer->peerMac[0], sh->peer->peerMac[1], sh->peer->peerMac[2],
sh->peer->peerMac[3], sh->peer->peerMac[4], sh->peer->peerMac[5],
sh->peer->interface->name, ntohs(sh->peer->sesNum),
sh->peerMac[0], sh->peerMac[1], sh->peerMac[2],
sh->peerMac[3], sh->peerMac[4], sh->peerMac[5],
sh->interface->name, ntohs(sh->sesNum));
#endif
sendPacket(NULL, sh->interface->sessionSock, &packet, size);
}
/**********************************************************************
*%FUNCTION: relayHandlePADS
*%ARGUMENTS:
* iface -- interface on which packet was received
* packet -- the PADS packet
*%RETURNS:
* Nothing
*%DESCRIPTION:
* Receives and processes a PADS packet.
***********************************************************************/
void
relayHandlePADS(PPPoEInterface const *iface,
PPPoEPacket *packet,
int size)
{
PPPoETag tag;
unsigned char *loc;
int ifIndex;
int acIndex;
PPPoESession *ses = NULL;
SessionHash *sh;
/* Can a server legally be behind this interface? */
if (!iface->acOK) {
syslog(LOG_ERR,
"PADS packet from %02x:%02x:%02x:%02x:%02x:%02x on interface %s not permitted",
packet->ethHdr.h_source[0],
packet->ethHdr.h_source[1],
packet->ethHdr.h_source[2],
packet->ethHdr.h_source[3],
packet->ethHdr.h_source[4],
packet->ethHdr.h_source[5],
iface->name);
return;
}
acIndex = iface - Interfaces;
/* Source address must be unicast */
if (NOT_UNICAST(packet->ethHdr.h_source)) {
syslog(LOG_ERR,
"PADS packet from %02x:%02x:%02x:%02x:%02x:%02x on interface %s not from a unicast address",
packet->ethHdr.h_source[0],
packet->ethHdr.h_source[1],
packet->ethHdr.h_source[2],
packet->ethHdr.h_source[3],
packet->ethHdr.h_source[4],
packet->ethHdr.h_source[5],
iface->name);
return;
}
/* Destination address must be interface's MAC address */
if (memcmp(packet->ethHdr.h_dest, iface->mac, ETH_ALEN)) {
return;
}
/* Find relay tag */
loc = findTag(packet, TAG_RELAY_SESSION_ID, &tag);
if (!loc) {
syslog(LOG_ERR,
"PADS packet from %02x:%02x:%02x:%02x:%02x:%02x on interface %s does not have Relay-Session-Id tag",
packet->ethHdr.h_source[0],
packet->ethHdr.h_source[1],
packet->ethHdr.h_source[2],
packet->ethHdr.h_source[3],
packet->ethHdr.h_source[4],
packet->ethHdr.h_source[5],
iface->name);
return;
}
/* If it's the wrong length, ignore it */
if (ntohs(tag.length) != MY_RELAY_TAG_LEN) {
syslog(LOG_ERR,
"PADS packet from %02x:%02x:%02x:%02x:%02x:%02x on interface %s does not have correct length Relay-Session-Id tag",
packet->ethHdr.h_source[0],
packet->ethHdr.h_source[1],
packet->ethHdr.h_source[2],
packet->ethHdr.h_source[3],
packet->ethHdr.h_source[4],
packet->ethHdr.h_source[5],
iface->name);
return;
}
/* Extract interface index */
memcpy(&ifIndex, tag.payload, sizeof(ifIndex));
if (ifIndex < 0 || ifIndex >= NumInterfaces ||
!Interfaces[ifIndex].clientOK ||
iface == &Interfaces[ifIndex]) {
syslog(LOG_ERR,
"PADS packet from %02x:%02x:%02x:%02x:%02x:%02x on interface %s has invalid interface in Relay-Session-Id tag",
packet->ethHdr.h_source[0],
packet->ethHdr.h_source[1],
packet->ethHdr.h_source[2],
packet->ethHdr.h_source[3],
packet->ethHdr.h_source[4],
packet->ethHdr.h_source[5],
iface->name);
return;
}
/* If session ID is zero, it's the AC respoding with an error.
Just relay it; do not create a session */
if (packet->session != htons(0)) {
/* Check for existing session */
sh = findSession(packet->ethHdr.h_source, packet->session);
if (sh) ses = sh->ses;
/* If already an existing session, assume it's a duplicate PADS. Send
the frame, but do not create a new session. Is this the right
thing to do? Arguably, should send an error to the client and
a PADT to the server, because this could happen due to a
server crash and reboot. */
if (!ses) {
/* Create a new session */
ses = createSession(iface, &Interfaces[ifIndex],
packet->ethHdr.h_source,
loc + TAG_HDR_SIZE + sizeof(ifIndex), packet->session);
if (!ses) {
/* Can't allocate session -- send error PADS to client and
PADT to server */
PPPoETag hostUniq, *hu;
if (findTag(packet, TAG_HOST_UNIQ, &hostUniq)) {
hu = &hostUniq;
} else {
hu = NULL;
}
relaySendError(CODE_PADS, htons(0), &Interfaces[ifIndex],
loc + TAG_HDR_SIZE + sizeof(ifIndex),
hu, "RP-PPPoE: Relay: Unable to allocate session");
relaySendError(CODE_PADT, packet->session, iface,
packet->ethHdr.h_source, NULL,
"RP-PPPoE: Relay: Unable to allocate session");
return;
}
}
/* Replace session number */
packet->session = ses->sesNum;
}
/* Remove relay-ID tag */
removeBytes(packet, loc, MY_RELAY_TAG_LEN + TAG_HDR_SIZE);
size -= (MY_RELAY_TAG_LEN + TAG_HDR_SIZE);
/* Set destination address to MAC address in relay ID */
memcpy(packet->ethHdr.h_dest, tag.payload + sizeof(ifIndex), ETH_ALEN);
/* Set source address to MAC address of interface */
memcpy(packet->ethHdr.h_source, Interfaces[ifIndex].mac, ETH_ALEN);
/* Send the PADS to the proper client */
sendPacket(NULL, Interfaces[ifIndex].discoverySock, packet, size);
}
IDE_RC mmtServiceThread::prepareProtocolA5(cmiProtocolContext *aProtocolContext,
cmiProtocol *aProtocol,
void *aSessionOwner,
void *aUserContext)
{
cmpArgDBPrepareA5 *sArg = CMI_PROTOCOL_GET_ARG(*aProtocol, DB, Prepare);
mmcTask *sTask = (mmcTask *)aSessionOwner;
mmtServiceThread *sThread = (mmtServiceThread *)aUserContext;
mmcSession *sSession;
//fix BUG-18284.
mmcStatement *sStatement = NULL;
SChar *sQuery;
UInt sQueryLen;
IDE_RC sRet;
IDE_CLEAR();
IDE_TEST(findSession(sTask, &sSession, sThread) != IDE_SUCCESS);
IDE_TEST(checkSessionState(sSession, MMC_SESSION_STATE_SERVICE) != IDE_SUCCESS);
if (sArg->mStatementID == 0)
{
IDE_TEST(mmcStatementManager::allocStatement(&sStatement, sSession, NULL) != IDE_SUCCESS);
sThread->setStatement(sStatement);
}
else
{
IDE_TEST(findStatement(&sStatement,
sSession,
&sArg->mStatementID,
sThread) != IDE_SUCCESS);
/* PROJ-2223 Altibase Auditing */
mmtAuditManager::auditBySession( sStatement );
IDE_TEST(sStatement->clearPlanTreeText() != IDE_SUCCESS);
IDE_TEST_RAISE(sStatement->getStmtState() >= MMC_STMT_STATE_EXECUTED,
InvalidStatementState);
IDE_TEST(qci::clearStatement(sStatement->getQciStmt(),
sStatement->getSmiStmt(),
QCI_STMT_STATE_INITIALIZED) != IDE_SUCCESS);
sStatement->setStmtState(MMC_STMT_STATE_ALLOC);
}
// bug-34746: query_timeout flag is cleared by other stmt
// query_timeout 확인시 mCurrStmtID로 비교한다
sSession->getInfo()->mCurrStmtID = sStatement->getStmtID();
/* BUG-38472 Query timeout applies to one statement. */
IDU_SESSION_CLR_TIMEOUT( *sSession->getEventFlag() );
sQueryLen = cmtVariableGetSize(&sArg->mStatementString);
IDE_TEST_RAISE(sQueryLen == 0, NullQuery);
IDU_FIT_POINT("mmtServiceThread::prepareProtocolA5::malloc::Query");
IDE_TEST(iduMemMgr::malloc(IDU_MEM_MMC,
sQueryLen + 1,
(void **)&sQuery,
IDU_MEM_IMMEDIATE) != IDE_SUCCESS);
IDE_TEST(cmtVariableGetData(&sArg->mStatementString,
(UChar *)sQuery,
sQueryLen) != IDE_SUCCESS);
sQuery[sQueryLen] = 0;
sStatement->setStmtExecMode(sArg->mMode ? MMC_STMT_EXEC_DIRECT : MMC_STMT_EXEC_PREPARED);
IDE_TEST(sStatement->prepare(sQuery, sQueryLen) != IDE_SUCCESS);
return answerPrepareResult(aProtocolContext, sStatement);
IDE_EXCEPTION(InvalidStatementState);
{
IDE_SET(ideSetErrorCode(mmERR_ABORT_INVALID_STATEMENT_STATE_ERROR));
}
IDE_EXCEPTION(NullQuery);
{
IDE_SET(ideSetErrorCode(mmERR_ABORT_INSUFFICIENT_QUERY_ERROR));
}
IDE_EXCEPTION_END;
{
sRet = sThread->answerErrorResultA5(aProtocolContext,
CMI_PROTOCOL_OPERATION(DB, Prepare),
0);
if (sRet == IDE_SUCCESS)
{
sThread->mErrorFlag = ID_TRUE;
}
//fix BUG-18284.
// do exactly same as CMP_DB_FREE_DROP
if (sArg->mStatementID == 0)
{
if(sStatement != NULL)
{
sThread->setStatement(NULL);
/* BUG-38585 IDE_ASSERT remove */
IDE_ASSERT(sStatement->closeCursor(ID_TRUE) == IDE_SUCCESS);
IDE_ASSERT(mmcStatementManager::freeStatement(sStatement) == IDE_SUCCESS);
}//if
}//if
}
return sRet;
}
IDE_RC mmtServiceThread::freeProtocolA5(cmiProtocolContext *aProtocolContext,
cmiProtocol *aProtocol,
void *aSessionOwner,
void *aUserContext)
{
cmpArgDBFreeA5 *sArg = CMI_PROTOCOL_GET_ARG(*aProtocol, DB, Free);
mmcTask *sTask = (mmcTask *)aSessionOwner;
mmtServiceThread *sThread = (mmtServiceThread *)aUserContext;
mmcSession *sSession;
mmcStatement *sStatement;
IDE_CLEAR();
IDE_TEST(findSession(sTask, &sSession, sThread) != IDE_SUCCESS);
IDE_TEST(checkSessionState(sSession, MMC_SESSION_STATE_SERVICE) != IDE_SUCCESS);
IDE_TEST(findStatement(&sStatement,
sSession,
&sArg->mStatementID,
sThread) != IDE_SUCCESS);
switch (sArg->mMode)
{
case CMP_DB_FREE_CLOSE:
if ((sStatement->getStmtState() >= MMC_STMT_STATE_EXECUTED) &&
(sSession->getExplainPlan() == QCI_EXPLAIN_PLAN_ON))
{
IDE_TEST(sStatement->makePlanTreeText(ID_FALSE) != IDE_SUCCESS);
}
IDE_TEST(sStatement->closeCursor(ID_TRUE) != IDE_SUCCESS);
break;
case CMP_DB_FREE_DROP:
sThread->setStatement(NULL);
IDE_TEST(sStatement->closeCursor(ID_TRUE) != IDE_SUCCESS);
IDE_TEST(mmcStatementManager::freeStatement(sStatement) != IDE_SUCCESS);
break;
default:
IDE_RAISE(InvalidFreeMode);
break;
}
return answerFreeResult(aProtocolContext);
IDE_EXCEPTION(InvalidFreeMode);
{
IDE_SET(ideSetErrorCode(mmERR_ABORT_INVALID_STATEMENT_FREE_MODE));
}
IDE_EXCEPTION_END;
return sThread->answerErrorResultA5(aProtocolContext,
CMI_PROTOCOL_OPERATION(DB, Free),
0);
}