CGmObjShape::~CGmObjShape()
{
LOG( "destructor: %s\n", GetName() );
Clear();
m_oLstLink.Clear();
DELETE_INSTANCE( m_poEffect );
LIST_DELETE( m_oLstParam, CParam );
}
static void req_cl(struct request_p * r)
{
WRITE_LOCK(&ipct_rpc_udp_lock);
del_timer(&r->timeout);
LIST_DELETE(&request_p_list_udp, r);
WRITE_UNLOCK(&ipct_rpc_udp_lock);
kfree(r);
return;
}
static void delete_request_p(unsigned long request_p_ul)
{
struct request_p *p = (void *)request_p_ul;
WRITE_LOCK(&ipct_rpc_udp_lock);
LIST_DELETE(&request_p_list_udp, p);
WRITE_UNLOCK(&ipct_rpc_udp_lock);
kfree(p);
return;
}
void CGmResMan::Clear()
{
ARRAY_DELETE( m_oArrTex, CGTex2 );
ARRAY_DELETE( m_oArrWav, TWav );
ARRAY_DELETE( m_oArrASource, CASource );
ARRAY_DELETE( m_oArrABuffer, CABuffer );
ARRAY_DELETE( m_oArrMesh, CGMesh );
ARRAY_DELETE( m_oArrModelMD5, CGMeshMD5::CModel );
ARRAY_DELETE( m_oArrAnim3, CGmObjAnim3 );
ARRAY_DELETE( m_oArrLight, CGLight );
for( unsigned int i=0; i<m_oArrLstCurve.GetSize(); ++i )
{
TLstCurve * poLstCurve = m_oArrLstCurve[i];
LIST_DELETE( ( *poLstCurve ), CCurvePathBezier3 );
}
m_oArrLstCurve.Clear();
//ARRAY_DELETE( m_oArrLstCurve, TLstCurve );
//ARRAY_DELETE( m_oArrPhysMaterial, CGmObjPhysMaterial );
LIST_DELETE( m_oLstFileEntry, CFileEntry );
}
/* Noone stores the protocol anywhere; simply delete it. */
void ip_nat_protocol_unregister(struct ip_nat_protocol *proto)
{
WRITE_LOCK(&ip_nat_lock);
LIST_DELETE(&protos, proto);
WRITE_UNLOCK(&ip_nat_lock);
/* Someone could be still looking at the proto in a bh. */
br_write_lock_bh(BR_NETPROTO_LOCK);
br_write_unlock_bh(BR_NETPROTO_LOCK);
MOD_DEC_USE_COUNT;
}
static int check_rpc_packet(const u_int32_t *data, const void *matchinfo,
int *hotdrop, int dir, struct ip_conntrack *ct,
int offset, struct list_head request_p_list)
{
const struct ipt_rpc_info *rpcinfo = matchinfo;
struct request_p *req_p;
u_int32_t xid;
/* Get XID */
xid = *data;
/* This does sanity checking on RPC payloads,
* and permits only the RPC "get port" (3)
* in authorised procedures in client
* communications with the portmapper.
*/
data += 5;
/* Get RPC requestor */
if (IXDR_GET_INT32(data) != 3) {
DEBUGP("RPC packet contains an invalid (non \"get\") requestor. [skip]\n");
if(rpcinfo->strict == 1)
*hotdrop = 1;
return 0;
}
DEBUGP("RPC packet contains a \"get\" requestor. [cont]\n");
data++;
/* Jump Credentials and Verfifier */
data = data + IXDR_GET_INT32(data) + 2;
data = data + IXDR_GET_INT32(data) + 2;
/* Get RPC procedure */
if (match_rpcs((char *)&rpcinfo->c_procs,
rpcinfo->i_procs, IXDR_GET_INT32(data)) == 0) {
DEBUGP("RPC packet contains illegal procedure request [%u]. [drop]\n",
(unsigned int)IXDR_GET_INT32(data));
/* If the RPC conntrack half entry already exists .. */
switch (ct->tuplehash[0].tuple.dst.protonum) {
case IPPROTO_UDP:
WRITE_LOCK(&ipct_rpc_udp_lock);
case IPPROTO_TCP:
WRITE_LOCK(&ipct_rpc_tcp_lock);
}
req_p = LIST_FIND(&request_p_list, request_p_cmp,
struct request_p *, xid,
ct->tuplehash[dir].tuple.src.ip,
ct->tuplehash[dir].tuple.src.u.all);
if (req_p) {
DEBUGP("found req_p for xid=%u proto=%u %u.%u.%u.%u:%u\n",
xid, ct->tuplehash[dir].tuple.dst.protonum,
NIPQUAD(ct->tuplehash[dir].tuple.src.ip),
ntohs(ct->tuplehash[dir].tuple.src.u.all));
/* .. remove it */
if (del_timer(&req_p->timeout))
req_p->timeout.expires = 0;
LIST_DELETE(&request_p_list, req_p);
DEBUGP("RPC req_p removed. [done]\n");
} else {
DEBUGP("no req_p found for xid=%u proto=%u %u.%u.%u.%u:%u\n",
xid, ct->tuplehash[dir].tuple.dst.protonum,
NIPQUAD(ct->tuplehash[dir].tuple.src.ip),
ntohs(ct->tuplehash[dir].tuple.src.u.all));
}
switch (ct->tuplehash[0].tuple.dst.protonum) {
case IPPROTO_UDP:
WRITE_UNLOCK(&ipct_rpc_udp_lock);
case IPPROTO_TCP:
WRITE_UNLOCK(&ipct_rpc_tcp_lock);
}
if(rpcinfo->strict == 1)
*hotdrop = 1;
return 0;
}
bool COrgOp::Load( CStr &roSrc, unsigned int uiIDOffset )
{
CStr oStrLine;
CStr oStrToken;
CList<COp *> oLstPatch;
unsigned int uiIDIn = 0;
unsigned int uiIdxIn = 0;
unsigned int uiCountIn = 0;
unsigned int uiPortIn = 0;
unsigned int uiIndexIn = 0;
unsigned int uiCountOut = 0;
unsigned int uiPortOut = 0;
unsigned int uiInteralInt = 0;
unsigned int uiInteralUInt = 0;
unsigned int uiInteralFlt = 0;
unsigned int i = 0;
unsigned int uiMaxIPortIn = 0;
unsigned int uiMaxIPortOut = 0;
unsigned int uiMaxIInternalInt = 0;
unsigned int uiMaxIInternalUInt = 0;
unsigned int uiMaxIInternalFlt = 0;
COp *poOp = 0;
// <mod date="2010-12-07">
CList<CArray<unsigned int> *> oLstArrID;
CArray<unsigned int> * poArrID = 0;
// </mod>
// Alle Operatoren einlesen, erstellen und pseudo-patchen.
while( 1 )
{
if( !Decode_GetNextLine( oStrLine, roSrc ) )
break;
i = 0;
while( 1 )
{
if( !Decode_GetNextToken( oStrToken, oStrLine ) )
break;
if( !oStrToken.GetSize() )
{
if( i > 1 ) // Komprimierung :: -> :0:
oStrToken = '0';
else if( i == 0 )
ORG_OP_LOG( "Fehler: Klassen-Name nicht vorhanden." );
}
// class
if( i == 0 )
{
poOp = Create( oStrToken );
if( poOp == 0 )
{
ORG_OP_LOG( "Fehler: Unbekannte Klasse: %s\n", oStrToken.GetData() );
return false;
}
oLstPatch.Append( poOp );
}
// instance
else if( i == 1 )
{
#ifdef OP_USE_RUNTIME_INFO
poOp->SetNameInstance( oStrToken );
#endif // OP_USE_RUNTIME_INFO
}
// id
else if( i == 2 )
{
unsigned int uiID;
ORG_OP_SSCANF( oStrToken, "%x", &uiID );
poOp->SetID( uiID + uiIDOffset ); // Um keinen Konflikt zu erzeugen.
}
// flags
else if( i == 3 )
{
unsigned int uiFlags;
ORG_OP_SSCANF( oStrToken, "%x", &uiFlags );
poOp->SetFlags( uiFlags );
}
// count_input
else if ( i == 4 )
{
ORG_OP_SSCANF( oStrToken, "%x", &uiCountIn );
if( poOp->GetFlags() & OP_FLAG_DYNAMIC_INPUTS )
{
poOp->SetCountIn( uiCountIn );
}
else if( poOp->GetCountIn() != uiCountIn )
{
#ifdef OP_USE_RUNTIME_INFO
ORG_OP_LOG( "Fehler: Von Klasse %s werden nicht %d Inputs unterstuetzt! "
"Keine dynamischen Inputs!\n", poOp->GetNameClass(), uiCountIn );
#endif // OP_USE_RUNTIME_INFO
return false;
}
uiPortIn = 0;
uiIndexIn = 0;
uiMaxIPortIn = 3 * uiCountIn + 4 + 1;
// <mod date="2010-12-07">
poArrID = new CArray<unsigned int>( uiCountIn );
oLstArrID.Append( poArrID );
// </mod>
}
// inputs
else if( i < uiMaxIPortIn )
{
unsigned int uiVal;
ORG_OP_SSCANF( oStrToken.GetData(), "%x", &uiVal );
switch( uiIndexIn )
{
case 0: // id
uiIDIn = uiVal;
break;
case 1: // port
uiIdxIn = uiVal;
break;
case 2: // flags
if( uiIDIn )
uiIDIn += uiIDOffset; // Um keinen Konflikt zu erzeugen.
// <mod date="2010-12-07">
poArrID->At( uiPortIn ) = uiIDIn;
poOp->In( uiPortIn ) = COp::CLink( 0, uiIdxIn, uiVal );
//poOp->In( uiPortIn ) = COp::CLink( reinterpret_cast<COp *>( uiIDIn ), uiIdxIn, uiVal );
// </mod>
++uiPortIn;
break;
}
++uiIndexIn;
if( uiIndexIn == 3 )
uiIndexIn = 0;
}
// count_output
else if( i == uiMaxIPortIn )
{
ORG_OP_SSCANF( oStrToken, "%x", &uiCountOut );
if( poOp->GetFlags() & OP_FLAG_DYNAMIC_OUTPUTS )
{
poOp->SetCountOut( uiCountOut );
}
else if( poOp->GetCountOut() != uiCountOut )
{
#ifdef OP_USE_RUNTIME_INFO
ORG_OP_LOG( "Fehler: Von Klasse %s werden nicht %d Outputs unterstuetzt! "
"Keine dynamischen Outputs!\n", poOp->GetNameClass(), uiCountOut );
#endif // OP_USE_RUNTIME_INFO
return false;
}
uiPortOut = 0;
uiMaxIPortOut = uiCountOut + uiMaxIPortIn + 1;
}
// outputs
else if( i < uiMaxIPortOut )
{
double dVal;
ORG_OP_SSCANF( oStrToken.GetData(), "%lf", &dVal );
poOp->Out( uiPortOut ) = dVal;
++uiPortOut;
}
// int internal count
else if( i == uiMaxIPortOut )
{
unsigned int uiCountInternalInt;
ORG_OP_SSCANF( oStrToken, "%x", &uiCountInternalInt );
if( poOp->GetCountInternalInt() != uiCountInternalInt )
{
#ifdef OP_USE_RUNTIME_INFO
ORG_OP_LOG( "Fehler: Von Klasse %s werden nicht %d Int-Interals unterstuetzt!\n", poOp->GetNameClass(), uiCountIn );
#endif // OP_USE_RUNTIME_INFO
return false;
}
uiInteralInt = 0;
uiMaxIInternalInt = uiMaxIPortOut + uiCountInternalInt + 1;
}
// int internals
else if( i < uiMaxIInternalInt )
{
int iVal;
ORG_OP_SSCANF( oStrToken.GetData(), "%d", &iVal );
poOp->SetValueInternalInt( uiInteralInt, iVal );
++uiInteralInt;
}
// uint internal count
else if( i == uiMaxIInternalInt )
{
unsigned int uiCountInternalUInt;
ORG_OP_SSCANF( oStrToken, "%x", &uiCountInternalUInt );
if( poOp->GetCountInternalUInt() != uiCountInternalUInt )
{
#ifdef OP_USE_RUNTIME_INFO
ORG_OP_LOG( "Fehler: Von Klasse %s werden nicht %d UInt-Interals unterstuetzt!\n", poOp->GetNameClass(), uiCountIn );
#endif // OP_USE_RUNTIME_INFO
return false;
}
uiInteralUInt = 0;
uiMaxIInternalUInt = uiMaxIInternalInt + uiCountInternalUInt + 1;
}
// uint internals
else if( i < uiMaxIInternalUInt )
{
unsigned int uiVal;
ORG_OP_SSCANF( oStrToken.GetData(), "%u", &uiVal );
poOp->SetValueInternalUInt( uiInteralUInt, uiVal );
++uiInteralUInt;
}
// flt internal count
else if( i == uiMaxIInternalUInt )
{
unsigned int uiCountInternalFlt;
ORG_OP_SSCANF( oStrToken, "%x", &uiCountInternalFlt );
if( poOp->GetCountInternalFlt() != uiCountInternalFlt )
{
#ifdef OP_USE_RUNTIME_INFO
ORG_OP_LOG( "Fehler: Von Klasse %s werden nicht %d Float-Interals unterstuetzt!\n", poOp->GetNameClass(), uiCountIn );
#endif // OP_USE_RUNTIME_INFO
return false;
}
uiInteralFlt = 0;
uiMaxIInternalFlt = uiMaxIInternalUInt + uiCountInternalFlt + 1;
}
// flt internals
else if( i < uiMaxIInternalFlt )
{
double dVal;
ORG_OP_SSCANF( oStrToken.GetData(), "%lf", &dVal );
poOp->SetValueInternalFlt( uiInteralFlt, dVal );
++uiInteralFlt;
}
else
break;
++i;
}
}
// Pseudo-Patch nun mit echten Verbindungen versehen.
i = oLstPatch.GetSize();
/*
if( i < 2 )
{
ORG_OP_LOG( "Fehler: Weniger als 2 Operatoren eingelesen!\n" );
return false;
}
*/
// Altes Patch löschen.
//Clear();
//m_poOpRootL_ = 0;
//m_poOpRootR_ = 0;
// <mod date="2010-12-07">
oLstArrID.MoveToBack();
// </mod>
while( i )
{
--i;
poOp = oLstPatch[i];
// <mod date="2010-12-07">
oLstArrID.GetPrev( &poArrID );
// </mod>
if( poOp )
{
unsigned int uiIn = poOp->GetCountIn();
while( uiIn )
{
--uiIn;
// <mod date="2010-12-07">
const unsigned int uiTmpIDNext = poArrID->At( uiIn );
//unsigned int uiTmpIDNext =
// reinterpret_cast<unsigned int>( poOp->In( uiIn ).GetOp() );
// </mod>
if( !uiTmpIDNext ) // ID 0 ist ungültig.
continue;
// Ganze Liste durchiterieren, und nach der ID aus dem aktuellen
// Input-Array Ausschau halten!
COp *poOpNext;
oLstPatch.MoveToFront();
while( oLstPatch.GetNext( &poOpNext ) )
{
if( poOpNext->GetID() == uiTmpIDNext )
{
poOp->In( uiIn ).SetOp( poOpNext );
}
}
}
}
//if( i == 0 )
// m_poOpRootL_ = poOp;
//else if ( i == 1 )
// m_poOpRootR_ = poOp;
}
// <mod date="2010-12-07">
LIST_DELETE( oLstArrID, CArray<unsigned int> );
// </mod>
// Alle aufglösten Operatoren in die echte Liste einfügen...
oLstPatch.MoveToFront();
while( oLstPatch.GetNext( &poOp ) )
{
#ifdef OP_USE_USER_DATA
poOp->m_pvData = 0;
#endif // OP_USE_USER_DATA
m_oLstOp.Append( poOp );
}
//UpdateAll();
ValidateAll();
return true;
}
void CGmObjShape::ClearJoints()
{
LIST_DELETE( m_oLstJoint, CGmObjPhysJoint );
}
