void parsingAddress(Address &a)
{
QString line = a.getRawAddressString();
a.setCorrect(false);
int n1=line.indexOf('(');
if (n1>0 && (line.indexOf(')',n1)>0))
{
int n2=line.indexOf(')', n1);
int n3=n2-n1;
a.setAdditional(line.mid(n1+1, n3-1));
line.remove(n1, n3+1);
}
QRegExp reg(BaseRegPattern, Qt::CaseInsensitive);
int pos=reg.indexIn(line);
if(pos==-1)
{
a.setCorrect(false);
// reg.setPattern(PatternForNotCorrect);
// pos=reg.indexIn(line);
// if(pos!=-1)
// {
// QStringList caps = reg.capturedTexts();
// a.setBuildId(caps.at(3));
// a.setStreetId(caps.at(1));
// }
}
else
{
a.setCorrect(true);
QStringList caps = reg.capturedTexts();
a.setBuildId(caps.at(19));
a.setStreetId(caps.at(1));
a.setTypeOfFSubj(caps.at(4));
a.setFsubj(caps.at(3));
a.setDistrict(caps.at(7));
a.setTypeOfCity1(caps.at(9));
a.setCity1(caps.at(10));
a.setTypeOfCity2(caps.at(12));
a.setCity2(caps.at(13));
a.setStreet(caps.at(16));
a.setTypeOfStreet(caps.at(17));
a.setBuild(caps.at(23));
a.setKorp(caps.at(28));
a.setLitera(caps.at(25)+caps.at(26)+caps.at(29));
// if(a.getBuildId()==14042969)
// {
// int n=0;
// foreach (QString s, caps) {
// qDebug().noquote() << "[" << n << "]=" << s;
// n++;
// }
// qDebug().noquote() << a.toString(PARSED);
// assert(0);
// }
}
}
void NetInterface::handlePunch(const Address &theAddress, BitStream *stream)
{
S32 i, j;
NetConnection *conn = nullptr;
Nonce firstNonce;
firstNonce.read(stream);
ByteBuffer b(firstNonce.data, Nonce::NonceSize);
TNLLogMessageV(LogNetInterface, ("Received punch packet from %s - %s", theAddress.toString(), b.encodeBase64()->getBuffer()));
for(i = 0; i < mPendingConnections.size(); i++)
{
conn = mPendingConnections[i];
ConnectionParameters &theParams = conn->getConnectionParameters();
if(conn->getConnectionState() != NetConnection::SendingPunchPackets)
continue;
if((theParams.mIsInitiator && firstNonce != theParams.mServerNonce) ||
(!theParams.mIsInitiator && firstNonce != theParams.mNonce))
continue;
// first see if the address is in the possible addresses list:
for(j = 0; j < theParams.mPossibleAddresses.size(); j++)
if(theAddress == theParams.mPossibleAddresses[j])
break;
// if there was an exact match, just exit the loop, or
// continue on to the next pending if this is not an initiator:
if(j != theParams.mPossibleAddresses.size())
{
if(theParams.mIsInitiator)
break;
else
continue;
}
// if there was no exact match, we may have a funny NAT in the
// middle. But since a packet got through from the remote host
// we'll want to send a punch to the address it came from, as long
// as only the port is not an exact match:
for(j = 0; j < theParams.mPossibleAddresses.size(); j++)
if(theAddress.isEqualAddress(theParams.mPossibleAddresses[j]))
break;
// if the address wasn't even partially in the list, just exit out
if(j == theParams.mPossibleAddresses.size())
continue;
// otherwise, as long as we don't have too many ping addresses,
// add this one to the list:
if(theParams.mPossibleAddresses.size() < 5)
theParams.mPossibleAddresses.push_back(theAddress);
// if this is the initiator of the arranged connection, then
// process the punch packet from the remote host by issueing a
// connection request.
if(theParams.mIsInitiator)
break;
}
if(i == mPendingConnections.size())
return;
ConnectionParameters &theParams = conn->getConnectionParameters();
SymmetricCipher theCipher(theParams.mArrangedSecret);
if(!stream->decryptAndCheckHash(NetConnection::MessageSignatureBytes, stream->getBytePosition(), &theCipher))
return;
Nonce nextNonce;
nextNonce.read(stream);
if(nextNonce != theParams.mNonce)
return;
// see if the connection needs to be authenticated or uses key exchange
if(stream->readFlag())
{
if(stream->readFlag())
{
theParams.mCertificate = new Certificate(stream);
if(!theParams.mCertificate->isValid() || !conn->validateCertficate(theParams.mCertificate, true))
return;
theParams.mPublicKey = theParams.mCertificate->getPublicKey();
}
else
{
theParams.mPublicKey = new AsymmetricKey(stream);
if(!theParams.mPublicKey->isValid() || !conn->validatePublicKey(theParams.mPublicKey, true))
return;
}
if(mPrivateKey.isNull() || mPrivateKey->getKeySize() != theParams.mPublicKey->getKeySize())
{
// we don't have a private key, so generate one for this connection
theParams.mPrivateKey = new AsymmetricKey(theParams.mPublicKey->getKeySize());
}
else
theParams.mPrivateKey = mPrivateKey;
theParams.mSharedSecret = theParams.mPrivateKey->computeSharedSecretKey(theParams.mPublicKey);
//logprintf("shared secret (client) %s", theParams.mSharedSecret->encodeBase64()->getBuffer());
Random::read(theParams.mSymmetricKey, SymmetricCipher::KeySize);
theParams.mUsingCrypto = true;
}
conn->setNetAddress(theAddress);
TNLLogMessageV(LogNetInterface, ("Punch from %s matched nonces - connecting...", theAddress.toString()));
conn->setConnectionState(NetConnection::AwaitingConnectResponse);
conn->mConnectSendCount = 0;
conn->mConnectLastSendTime = getCurrentTime();
sendArrangedConnectRequest(conn);
}
BreakpointLocationSP
BreakpointResolver::AddLocation(Address loc_addr, bool *new_location)
{
loc_addr.Slide(m_offset);
return m_breakpoint->AddLocation(loc_addr, new_location);
}
inline void MacroAssembler::stf(FloatRegisterImpl::Width w, FloatRegister d, const Address& a, int offset) {
relocate(a.rspec(offset));
if (a.has_index()) { assert(offset == 0, ""); stf(w, d, a.base(), a.index() ); }
else { stf(w, d, a.base(), a.disp() + offset); }
}
int main( int argc, char * argv[] )
{
// initialize socket layer
if ( !InitializeSockets() )
{
printf( "failed to initialize sockets\n" );
return 1;
}
// create socket
int port = 30000;
if ( argc == 2 )
port = atoi( argv[1] );
printf( "creating socket on port %d\n", port );
Socket socket;
if ( !socket.Open( port ) )
{
printf( "failed to create socket!\n" );
return 1;
}
// read in addresses.txt to get the set of addresses we will send packets to
vector<Address> addresses;
string line;
ifstream file( "addresses.txt" );
if ( !file.is_open() )
{
printf( "failed to open 'addresses.txt'\n" );
return 1;
}
while ( !file.eof() )
{
getline( file, line );
int a,b,c,d,port;
if ( sscanf( line.c_str(), "%d.%d.%d.%d:%d", &a, &b, &c, &d, &port ) == 5 )
addresses.push_back( Address( a,b,c,d,port ) );
}
file.close();
// send and receive packets until the user ctrl-breaks...
while ( true )
{
const char data[] = "hello world!";
for ( int i = 0; i < (int) addresses.size(); ++i )
socket.Send( addresses[i], data, sizeof( data ) );
while ( true )
{
Address sender;
unsigned char buffer[256];
int bytes_read = socket.Receive( sender, buffer, sizeof( buffer ) );
if ( !bytes_read )
break;
printf( "received packet from %d.%d.%d.%d:%d (%d bytes)\n", sender.GetA(), sender.GetB(), sender.GetC(), sender.GetD(), sender.GetPort(), bytes_read );
}
wait_seconds( 1.0f );
}
// shutdown socket layer
ShutdownSockets();
return 0;
}
// form effective addresses this way:
inline void MacroAssembler::add(const Address& a, Register d, int offset) {
if (a.has_index()) add(a.base(), a.index(), d);
else { add(a.base(), a.disp() + offset, d, a.rspec(offset)); offset = 0; }
if (offset != 0) add(d, offset, d);
}
inline void MacroAssembler::prefetch(const Address& a, PrefetchFcn f, int offset) {
relocate(a.rspec(offset));
assert(!a.has_index(), "");
prefetch(a.base(), a.disp() + offset, f);
}
bool TransactionConflictManager::shouldNackStore(Address addr, uint64 remote_timestamp, MachineID remote_id){
bool existConflict = false;
int remote_proc = L1CacheMachIDToProcessorNum(remote_id);
int remote_thread = 0;
int remote_logical_proc_num = remote_proc * RubyConfig::numberofSMTThreads() + remote_thread;
string conflict_res_policy(XACT_CONFLICT_RES);
if (XACT_EAGER_CD && !XACT_LAZY_VM){
if (XACT_MGR->isInWriteFilterSummary(addr)){
for (int i = 0; i < RubyConfig::numberofSMTThreads(); i++){
setLowestConflictLevel(i, addr, true);
}
if (conflict_res_policy == "TIMESTAMP"){
assert(!OpalInterface::isOpalLoaded());
if (getTimestamp(0) >= remote_timestamp){
XACT_MGR->setAbortFlag(0, addr);
if (ATMTP_ENABLED) {
XACT_MGR->setCPS_coh(0);
}
setEnemyProcessor(0, remote_logical_proc_num);
m_magicWaitingOn[0] = remote_logical_proc_num;
m_magicWaitingTime[0] = remote_timestamp;
m_needMagicWait[0] = true;
// remove this addr from isolation checker
if(XACT_ISOLATION_CHECK){
//cout << "REMOVING ADDR " << addr << " FROM READ SET OF " << getProcID() << endl;
Address temp = addr;
temp.makeLineAddress();
int transactionLevel = XACT_MGR->getTransactionLevel(0);
for(int level=1; level<=transactionLevel; ++level){
g_system_ptr->getXactIsolationChecker()->removeFromWriteSet(getProcID(), temp, level);
}
}
}
}
return true;
} else if (XACT_MGR->isInReadFilterSummary(addr)){
for (int i = 0; i < RubyConfig::numberofSMTThreads(); i++){
setLowestConflictLevel(i, addr, true);
}
if (conflict_res_policy == "HYBRID" || conflict_res_policy == "TIMESTAMP"){
assert(!OpalInterface::isOpalLoaded());
if (getTimestamp(0) >= remote_timestamp){
XACT_MGR->setAbortFlag(0, addr);
if (ATMTP_ENABLED) {
XACT_MGR->setCPS_coh(0);
}
setEnemyProcessor(0, remote_logical_proc_num);
// remove this addr from isolation checker
if(XACT_ISOLATION_CHECK){
//cout << "REMOVING ADDR " << addr << " FROM READ SET OF " << getProcID() << endl;
Address temp = addr;
temp.makeLineAddress();
int transactionLevel = XACT_MGR->getTransactionLevel(0);
for(int level=1; level<=transactionLevel; ++level){
g_system_ptr->getXactIsolationChecker()->removeFromReadSet(getProcID(), temp, level);
}
}
return false;
} else {
return true;
}
}
return true;
}
return false;
} else if (XACT_EAGER_CD && XACT_LAZY_VM){
if (XACT_MGR->isInWriteFilterSummary(addr) ||
XACT_MGR->isInReadFilterSummary(addr)){
assert(!OpalInterface::isOpalLoaded());
if (XACT_MGR->isTokenOwner(0)) return true;
if (conflict_res_policy == "BASE"){
int proc = getLogicalProcID(0);
//cout << "Proc " << proc << " STORE SETTING ABORT FLAG PC = " << SIMICS_get_program_counter(proc) << " Remote Proc = " << remote_logical_proc_num << " RemotePC = " << SIMICS_get_program_counter(remote_logical_proc_num) << " addr = " << addr << endl;
XACT_MGR->setAbortFlag(0, addr);
if (ATMTP_ENABLED) {
XACT_MGR->setCPS_coh(0);
}
setEnemyProcessor(0, remote_logical_proc_num);
// remove this addr from isolation checker
if(XACT_ISOLATION_CHECK){
//cout << "REMOVING ADDR " << addr << " FROM READ SET OF " << getProcID() << endl;
Address temp = addr;
temp.makeLineAddress();
if(XACT_MGR->isInWriteFilterSummary(addr)){
int transactionLevel = XACT_MGR->getTransactionLevel(0);
for(int level=1; level<=transactionLevel; ++level){
g_system_ptr->getXactIsolationChecker()->removeFromWriteSet(getProcID(), temp, level);
}
}
if(XACT_MGR->isInReadFilterSummary(addr)){
int transactionLevel = XACT_MGR->getTransactionLevel(0);
for(int level=1; level<=transactionLevel; ++level){
g_system_ptr->getXactIsolationChecker()->removeFromReadSet(getProcID(), temp, level);
}
}
}
return false;
} else if (conflict_res_policy == "TIMESTAMP"){
if (getTimestamp(0) >= remote_timestamp){
XACT_MGR->setAbortFlag(0, addr);
if (ATMTP_ENABLED) {
XACT_MGR->setCPS_coh(0);
}
setEnemyProcessor(0, remote_logical_proc_num);
// remove this addr from isolation checker
if(XACT_ISOLATION_CHECK){
//cout << "REMOVING ADDR " << addr << " FROM READ SET OF " << getProcID() << endl;
Address temp = addr;
temp.makeLineAddress();
if(XACT_MGR->isInWriteFilterSummary(addr)){
int transactionLevel = XACT_MGR->getTransactionLevel(0);
for(int level=1; level<=transactionLevel; ++level){
g_system_ptr->getXactIsolationChecker()->removeFromWriteSet(getProcID(), temp, level);
}
}
if(XACT_MGR->isInReadFilterSummary(addr)){
int transactionLevel = XACT_MGR->getTransactionLevel(0);
for(int level=1; level<=transactionLevel; ++level){
g_system_ptr->getXactIsolationChecker()->removeFromReadSet(getProcID(), temp, level);
}
}
}
return false;
}
return true;
} else if (conflict_res_policy == "CYCLE"){
return true;
} else {
assert(0);
}
}
return false;
} else {
// for LL systems
if (XACT_MGR->isInReadFilterSummary(addr) ||
XACT_MGR->isInWriteFilterSummary(addr)){
if (conflict_res_policy != "BASE"){
cout << "XACT_CONFLICT_RES: " << conflict_res_policy << endl;
assert(0);
}
assert(!OpalInterface::isOpalLoaded());
if (XACT_MGR->isTokenOwner(0)) return true;
if (XACT_MGR->isInReadFilterSummary(addr)){
XACT_MGR->setAbortFlag(0, addr);
if (ATMTP_ENABLED) {
XACT_MGR->setCPS_coh(0);
}
setEnemyProcessor(0, remote_logical_proc_num);
}
return false;
}
return false;
}
assert(0);
return false;
}
/// Locates the address of the rendezvous structure. Returns the address on
/// success and LLDB_INVALID_ADDRESS on failure.
static addr_t ResolveRendezvousAddress(Process *process) {
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
addr_t info_location;
addr_t info_addr;
Status error;
if (!process) {
if (log)
log->Printf("%s null process provided", __FUNCTION__);
return LLDB_INVALID_ADDRESS;
}
// Try to get it from our process. This might be a remote process and might
// grab it via some remote-specific mechanism.
info_location = process->GetImageInfoAddress();
if (log)
log->Printf("%s info_location = 0x%" PRIx64, __FUNCTION__, info_location);
// If the process fails to return an address, fall back to seeing if the
// local object file can help us find it.
if (info_location == LLDB_INVALID_ADDRESS) {
Target *target = &process->GetTarget();
if (target) {
ObjectFile *obj_file = target->GetExecutableModule()->GetObjectFile();
Address addr = obj_file->GetImageInfoAddress(target);
if (addr.IsValid()) {
info_location = addr.GetLoadAddress(target);
if (log)
log->Printf(
"%s resolved via direct object file approach to 0x%" PRIx64,
__FUNCTION__, info_location);
} else {
if (log)
log->Printf("%s FAILED - direct object file approach did not yield a "
"valid address",
__FUNCTION__);
}
}
}
if (info_location == LLDB_INVALID_ADDRESS) {
if (log)
log->Printf("%s FAILED - invalid info address", __FUNCTION__);
return LLDB_INVALID_ADDRESS;
}
if (log)
log->Printf("%s reading pointer (%" PRIu32 " bytes) from 0x%" PRIx64,
__FUNCTION__, process->GetAddressByteSize(), info_location);
info_addr = process->ReadPointerFromMemory(info_location, error);
if (error.Fail()) {
if (log)
log->Printf("%s FAILED - could not read from the info location: %s",
__FUNCTION__, error.AsCString());
return LLDB_INVALID_ADDRESS;
}
if (info_addr == 0) {
if (log)
log->Printf("%s FAILED - the rendezvous address contained at 0x%" PRIx64
" returned a null value",
__FUNCTION__, info_location);
return LLDB_INVALID_ADDRESS;
}
return info_addr;
}
//dump method
void TVF::dump(Address& a, unsigned length, const unsigned char* data) {
Address lowBound;
Address upBound(1);
unsigned index = 0;
if(length > index && a == lowBound) {
_cutoffFrequency = data[index];
index++;
++a;
}
++lowBound;
++upBound;
if(length > index && a == lowBound) {
_resonance = data[index];
index++;
++a;
}
++lowBound;
++upBound;
if(length > index && a == lowBound) {
_cutoffPointKeyFollow = (FracKeyFollow)data[index];
index++;
++a;
}
++lowBound;
upBound += DUMP_KEYBIAS_LENGTH;
if(length > index && a >= lowBound && a < upBound) {
Address la = a - lowBound;
Address prela = la;
BaseKeyBias::dump(la, length - index, &data[index]);
Address diffa = la - prela;
index += diffa.toInt();
a += diffa;
}
lowBound += DUMP_KEYBIAS_LENGTH;
++upBound;
if(length > index && a == lowBound) {
_ENVDepth = data[index];
index++;
++a;
}
++lowBound;
++upBound;
if(length > index && a == lowBound) {
_velocityRange = data[index];
index++;
++a;
}
++lowBound;
++upBound;
if(length > index && a == lowBound) {
_depthKeyFollow = data[index];
index++;
++a;
}
++lowBound;
++upBound;
if(length > index && a == lowBound) {
_timeKeyFollow = data[index];
index++;
++a;
}
++lowBound;
upBound += DUMP_ENVELOPE_LENGTH;
if(length > index && a >= lowBound && a < upBound) {
Address la = a - lowBound;
Address prela = la;
BaseEnvelope::dump(la, length - index, &data[index]);
Address diffa = la - prela;
index += diffa.toInt();
a += diffa;
}
lowBound += DUMP_ENVELOPE_LENGTH;
upBound += DUMP_MODULATION_LENGTH;
if(length > index && a >= lowBound && a < upBound) {
Address la = a - lowBound;
Address prela = la;
BaseModulation::dump(la, length - index, &data[index]);
Address diffa = la - prela;
index += diffa.toInt();
a += diffa;
}
lowBound += DUMP_MODULATION_LENGTH;
if(length > index && a == lowBound) {
_aftertouchRange = (char)data[index] - 7;
++a;
}
}
QString Log::collectArg(const QString &msg, Address a)
{
return msg.arg(a.toString());
}
Address CodeGenFunction::emitAddrOfImagComponent(Address addr,
QualType complexType) {
QualType eltType = complexType->castAs<ComplexType>()->getElementType();
CharUnits offset = getContext().getTypeSizeInChars(eltType);
return Builder.CreateStructGEP(addr, 1, offset, addr.getName() + ".imagp");
}
Address CodeGenFunction::emitAddrOfRealComponent(Address addr,
QualType complexType) {
CharUnits offset = CharUnits::Zero();
return Builder.CreateStructGEP(addr, 0, offset, addr.getName() + ".realp");
}
void CompilerDriver_pix::pixNetworkZoneChecks(Firewall *fw,
list<FWObject*> &all_interfaces)
{
multimap<string, FWObject*> netzone_objects;
Helper helper(NULL);
for (std::list<FWObject*>::iterator i=all_interfaces.begin(); i!=all_interfaces.end(); ++i)
{
Interface *iface = dynamic_cast<Interface*>(*i);
assert(iface);
if (iface->getOptionsObject()->getBool("cluster_interface")) continue;
if (iface->isDedicatedFailover()) continue;
if (iface->isUnprotected()) continue;
/*
* in PIX, we need network zones to be defined for all
* interfaces
*/
string netzone_id = iface->getStr("network_zone");
if (netzone_id=="")
{
QString err("Network zone definition is missing for interface '%1' (%2)");
abort(fw, NULL, NULL,
err.arg(iface->getName().c_str())
.arg(iface->getLabel().c_str()).toStdString());
throw FatalErrorInSingleRuleCompileMode();
}
FWObject *netzone = objdb->findInIndex(
FWObjectDatabase::getIntId(netzone_id));
if (netzone==NULL)
{
QString err("Network zone points at nonexisting object for "
"interface '%1' (%2)");
abort(fw, NULL, NULL,
err.arg(iface->getName().c_str())
.arg(iface->getLabel().c_str()).toStdString());
throw FatalErrorInSingleRuleCompileMode();
}
/*
* netzone may be a group, in which case we need to expand it
* (recursively).
*
* 1. We create new temporary object (type Group).
*
* 2. put it in the database somewhere
*
* 3. add all objects that belong to the network zone to this
* group. We add objects directly, not as a reference.
*
* 4. finally replace reference to the old network zone object in the
* interface with reference to this new group.
*
* 5. we store ID of the original network zone object
* using iface->setStr("orig_netzone_id")
*
* This ensures netzones do not contain other groups and do not
* require any recursive expanding anymore. Since objects were added
* to netzones directly, we do not need to bother with dereferencing,
* too.
*/
list<FWObject*> ol;
helper.expand_group_recursive(netzone, ol);
FWObject *nz = objdb->createObjectGroup();
assert(nz!=NULL);
nz->setName("netzone_" + iface->getLabel());
objdb->add(nz);
for (list<FWObject*>::iterator j=ol.begin(); j!=ol.end(); ++j)
{
Address *addr = Address::cast(*j);
if (addr == NULL || addr->getAddressPtr() == NULL)
{
QString err("Network zone of interface '%1' uses object '%2' "
"that is not an address");
abort(fw, NULL, NULL,
err.arg(iface->getLabel().c_str())
.arg((*j)->getName().c_str()).toStdString());
throw FatalErrorInSingleRuleCompileMode();
}
/*
Commented out for SF bug 3213019
currently we do not support ipv6 with PIX/ASA and FWSM. If user
creates a group to be used as network zone object and places ipv6
address in it, this address should be ignored while compiling the
policy but this should not be an error. Compiler uses network zone
group to do various address matching operations when it tries to
determine an interface for a rule where user did not specify
one. Since we never (should) have ipv6 in policy and nat rules,
compiler is not going to have anything to compare to ipv6 address in
the network zone even if there is one and this ipv6 address is going
to be ignored.
if (addr->getAddressPtr()->isV6())
{
QString err("Network zone of interface '%1' uses object '%2' "
"that is IPv6 address");
abort(fw, NULL, NULL,
err.arg(iface->getLabel().c_str())
.arg((*j)->getName().c_str()).toStdString());
throw FatalErrorInSingleRuleCompileMode();
}
*/
netzone_objects.insert(
pair<string,FWObject*>(iface->getLabel(),*j));
nz->addRef(*j);
}
iface->setStr("orig_netzone_id", netzone_id );
iface->setStr("network_zone",
FWObjectDatabase::getStringId(nz->getId()) );
}
/*
* the same object (network or host) can not belong to network zones
* of two different interfaces. Map netzone_objects holds pairs
* interface_id/object. We just make sure the same object does not
* appear in two pairs with different interfaces.
*/
multimap<string,FWObject*>::iterator k;
for (k=netzone_objects.begin(); k!=netzone_objects.end(); ++k)
{
multimap<string,FWObject*>::iterator l;
l=k;
++l;
for ( ; l!=netzone_objects.end(); ++l)
{
if ( l->second->getId() == k->second->getId() )
{
if (k->first==l->first)
{
QString err("Object %1 is used more than once in network "
"zone of interface '%2'");
abort(fw, NULL, NULL,
err.arg(l->second->getName().c_str())
.arg(k->first.c_str()).toStdString());
throw FatalErrorInSingleRuleCompileMode();
} else
{
QString err("Object %1 is used in network zones of "
"interfaces '%2' and '%3'");
abort(fw, NULL, NULL,
err.arg(l->second->getName().c_str())
.arg(k->first.c_str())
.arg(l->first.c_str()).toStdString());
throw FatalErrorInSingleRuleCompileMode();
}
}
}
}
}
// The operator == checks for exact equality only (same section, same offset)
bool
lldb_private::operator== (const Address& a, const Address& rhs)
{
return a.GetOffset() == rhs.GetOffset() &&
a.GetSection() == rhs.GetSection();
}
inline unsigned long hashCode() const throw() { return ((unsigned long)reporter.toInt() + (unsigned long)scope); }
// The operator != checks for exact inequality only (differing section, or
// different offset)
bool
lldb_private::operator!= (const Address& a, const Address& rhs)
{
return a.GetOffset() != rhs.GetOffset() ||
a.GetSection() != rhs.GetSection();
}
Address* Address::clone()
{
Address * ad = new Address(hostname_, port_);
ad->setHWAddr(macaddr_);
return ad;
}
inline void MacroAssembler::ldx( const Address& a, Register d, int offset) {
if (a.has_index()) { assert(offset == 0, ""); ldx( a.base(), a.index(), d); }
else { ldx( a.base(), a.disp() + offset, d); }
}
int RecordManager::deleteRecord(const vector<char>& key, string fileName, int recordSize, int n){
//cout << "deleterecord begin{" << endl;
vector<char> nextBlock;
vector<char> nextOffset;
vector<char> delBlock;
vector<char> delOffset;
/*vector<char> delEndBlock;
vector<char> delEndOffset;*/
vector<char> headRecord;
vector<char> lastRecord;
vector<char> delRecord;
vector<char> delEndRecord;
Address head;
Address lastAddr;
Address delAddr;
int attrNum=0;
int headSize;
if (recordSize < 20)
headSize = 20;
else
headSize = recordSize;
head.setAddr(fileName, 0, 0);
headRecord = bmanager.read(head, headSize);
//找到待删记录的上一条记录
lastAddr = findLastRecord(fileName, key, recordSize,0);
if (lastAddr.isNullAddr()){//找不到此记录
//cout << "isnull!" << endl;
return 0;
}
int lastRecordSize = 0;
if (lastAddr.isHead()){//如果lastRecord为head 那么recordSize有问题
//cout << "is head!" << endl;
lastRecordSize = headSize;
lastRecord = headRecord;
}
else{
lastRecordSize = recordSize;
lastRecord = bmanager.read(lastAddr, lastRecordSize);
}
//printvc(lastRecord);
//cout << "lastrecordsize: " << lastRecordSize << endl;
//得到待删的记录
setNextAddr(lastRecord, nextBlock, nextOffset, lastRecordSize - 8);
delBlock = nextBlock;
delOffset = nextOffset;
delAddr.setAddr(fileName, char4ToInt(delBlock), char4ToInt(delOffset));
delRecord = bmanager.read(delAddr, recordSize);
//printvc(delRecord);
if (delRecord.size()>50)
attrNum = delRecord[50];//获得此表的attr数，只有在delete table时用到
delEndRecord = delRecord;
Address delEndAddr = delAddr;
for (int i = 0; i < n - 1; i++){//删除连续的n条
setNextAddr(delEndRecord, nextBlock, nextOffset, recordSize - 8);
//delEndBlock = nextBlock;
//delEndOffset = nextOffset;
delEndAddr.setAddr(fileName, char4ToInt(nextBlock), char4ToInt(nextOffset));
delEndRecord = bmanager.read(delAddr, recordSize);
}
//将del上一条记录指向delEnd的下一条记录
setNextAddr(delEndRecord, nextBlock, nextOffset, recordSize - 8);
if (lastAddr.isHead()){
updateRecordPoint(headRecord, nextBlock, nextOffset, headSize - 8);
}
else{
updateRecordPoint(lastRecord, nextBlock, nextOffset, lastRecordSize - 8);
bmanager.write(lastAddr, lastRecord);
}
//修改delete链
setNextAddr(headRecord, nextBlock, nextOffset, headSize - 16);//第一条被删记录
updateRecordPoint(delEndRecord, nextBlock, nextOffset, recordSize - 8);//将delEndRecord指向第一条被删记录
bmanager.write(delEndAddr, delEndRecord);//update过的都要写回！！
updateRecordPoint(headRecord, delBlock, delOffset, headSize - 16);//head指向delRecord
decSize(headRecord, n);
bmanager.write(head,headRecord);
//cout << "}deleterecord end 1" << endl;
return attrNum;
}
inline void MacroAssembler::stx(Register d, const Address& a, int offset) {
if (a.has_index()) { assert(offset == 0, ""); stx(d, a.base(), a.index() ); }
else { stx(d, a.base(), a.disp() + offset); }
}
FWObject* AddressObjectMaker::createAddress(ObjectSignature &sig)
{
ObjectSignature signature = sig;
InetAddr netmask(signature.netmask.toStdString());
if ( netmask == InetAddr::getAllOnes() )
{
QString name;
try
{
signature.type_name = IPv4::TYPENAME;
FWObject *obj = findMatchingObject(signature);
if (obj) return obj;
InetAddr obj_addr(sig.address.toStdString()); // testing if string converts to an address
name = QString("h-") + sig.address;
Address *a = Address::cast(
ObjectMaker::createObject(IPv4::TYPENAME, name.toStdString()));
a->setAddress(obj_addr);
a->setNetmask(InetAddr(InetAddr::getAllOnes()));
return a;
} catch(FWException &ex)
{
// address text line can not be converted to ipv4 address.
// Since parsers do not understand ipv6 yet, assume this
// is a host address and create DNSName object
signature.type_name = DNSName::TYPENAME;
FWObject *obj = findMatchingObject(signature);
if (obj) return obj;
name = sig.address;
DNSName *da = DNSName::cast(
ObjectMaker::createObject(DNSName::TYPENAME, name.toStdString()));
da->setSourceName(sig.address.toStdString());
da->setRunTime(true);
return da;
}
} else
{
signature.type_name = Network::TYPENAME;
FWObject *obj = findMatchingObject(signature);
if (obj) return obj;
QString name = QString("net-%1/%2")
.arg(signature.address).arg(signature.netmask);
Network *net = Network::cast(
ObjectMaker::createObject(Network::TYPENAME, name.toStdString()));
try
{
net->setAddress( InetAddr(sig.address.toStdString()) );
} catch (FWException &ex)
{
error_tracker->registerError(
QString("Error converting address '%1'").arg(sig.address));
}
// we have already verified netmask above
net->setNetmask(netmask);
return net;
}
return nullptr;
}
inline void MacroAssembler::swap(const Address& a, Register d, int offset) {
relocate(a.rspec(offset));
if (a.has_index()) { assert(offset == 0, ""); swap(a.base(), a.index(), d ); }
else { swap(a.base(), a.disp() + offset, d); }
}
bool
ItaniumABILanguageRuntime::GetDynamicTypeAndAddress (ValueObject &in_value,
lldb::DynamicValueType use_dynamic,
TypeAndOrName &class_type_or_name,
Address &dynamic_address)
{
// For Itanium, if the type has a vtable pointer in the object, it will be at offset 0
// in the object. That will point to the "address point" within the vtable (not the beginning of the
// vtable.) We can then look up the symbol containing this "address point" and that symbol's name
// demangled will contain the full class name.
// The second pointer above the "address point" is the "offset_to_top". We'll use that to get the
// start of the value object which holds the dynamic type.
//
// Only a pointer or reference type can have a different dynamic and static type:
if (CouldHaveDynamicValue (in_value))
{
// FIXME: Can we get the Clang Type and ask it if the thing is really virtual? That would avoid false positives,
// at the cost of not looking for the dynamic type of objects if DWARF->Clang gets it wrong.
// First job, pull out the address at 0 offset from the object.
AddressType address_type;
lldb::addr_t original_ptr = in_value.GetPointerValue(&address_type);
if (original_ptr == LLDB_INVALID_ADDRESS)
return false;
Target *target = in_value.GetUpdatePoint().GetTargetSP().get();
Process *process = in_value.GetUpdatePoint().GetProcessSP().get();
char memory_buffer[16];
DataExtractor data(memory_buffer, sizeof(memory_buffer),
process->GetByteOrder(),
process->GetAddressByteSize());
size_t address_byte_size = process->GetAddressByteSize();
Error error;
size_t bytes_read = process->ReadMemory (original_ptr,
memory_buffer,
address_byte_size,
error);
if (!error.Success() || (bytes_read != address_byte_size))
{
return false;
}
uint32_t offset_ptr = 0;
lldb::addr_t vtable_address_point = data.GetAddress (&offset_ptr);
if (offset_ptr == 0)
return false;
// Now find the symbol that contains this address:
SymbolContext sc;
Address address_point_address;
if (target && !target->GetSectionLoadList().IsEmpty())
{
if (target->GetSectionLoadList().ResolveLoadAddress (vtable_address_point, address_point_address))
{
target->GetImages().ResolveSymbolContextForAddress (address_point_address, eSymbolContextSymbol, sc);
Symbol *symbol = sc.symbol;
if (symbol != NULL)
{
const char *name = symbol->GetMangled().GetDemangledName().AsCString();
if (strstr(name, vtable_demangled_prefix) == name)
{
// We are a C++ class, that's good. Get the class name and look it up:
const char *class_name = name + strlen(vtable_demangled_prefix);
class_type_or_name.SetName (class_name);
TypeList class_types;
uint32_t num_matches = target->GetImages().FindTypes (sc,
ConstString(class_name),
true,
UINT32_MAX,
class_types);
if (num_matches == 1)
{
class_type_or_name.SetTypeSP(class_types.GetTypeAtIndex(0));
}
else if (num_matches > 1)
{
for (size_t i = 0; i < num_matches; i++)
{
lldb::TypeSP this_type(class_types.GetTypeAtIndex(i));
if (this_type)
{
if (ClangASTContext::IsCXXClassType(this_type->GetClangFullType()))
{
// There can only be one type with a given name,
// so we've just found duplicate definitions, and this
// one will do as well as any other.
// We don't consider something to have a dynamic type if
// it is the same as the static type. So compare against
// the value we were handed:
clang::ASTContext *in_ast_ctx = in_value.GetClangAST ();
clang::ASTContext *this_ast_ctx = this_type->GetClangAST ();
if (in_ast_ctx != this_ast_ctx
|| !ClangASTContext::AreTypesSame (in_ast_ctx,
in_value.GetClangType(),
this_type->GetClangFullType()))
{
class_type_or_name.SetTypeSP (this_type);
return true;
}
return false;
}
}
}
}
else
return false;
// The offset_to_top is two pointers above the address.
Address offset_to_top_address = address_point_address;
int64_t slide = -2 * ((int64_t) target->GetArchitecture().GetAddressByteSize());
offset_to_top_address.Slide (slide);
Error error;
lldb::addr_t offset_to_top_location = offset_to_top_address.GetLoadAddress(target);
size_t bytes_read = process->ReadMemory (offset_to_top_location,
memory_buffer,
address_byte_size,
error);
if (!error.Success() || (bytes_read != address_byte_size))
{
return false;
}
offset_ptr = 0;
int64_t offset_to_top = data.GetMaxS64(&offset_ptr, process->GetAddressByteSize());
// So the dynamic type is a value that starts at offset_to_top
// above the original address.
lldb::addr_t dynamic_addr = original_ptr + offset_to_top;
if (!target->GetSectionLoadList().ResolveLoadAddress (dynamic_addr, dynamic_address))
{
dynamic_address.SetOffset(dynamic_addr);
dynamic_address.SetSection(NULL);
}
return true;
}
}
}
}
}
return false;
}
void NetInterface::handleArrangedConnectRequest(const Address &theAddress, BitStream *stream)
{
S32 i, j;
NetConnection *conn = nullptr;
Nonce nonce, serverNonce;
nonce.read(stream);
// see if the connection is in the main connection table.
// If the connection is in the connection table and it has
// the same initiatorSequence, we'll just resend the connect
// acceptance packet, assuming that the last time we sent it
// it was dropped.
NetConnection *oldConnection = findConnection(theAddress);
if(oldConnection)
{
ConnectionParameters &cp = oldConnection->getConnectionParameters();
if(cp.mNonce == nonce)
{
sendConnectAccept(oldConnection);
return;
}
}
for(i = 0; i < mPendingConnections.size(); i++)
{
conn = mPendingConnections[i];
ConnectionParameters &theParams = conn->getConnectionParameters();
if(conn->getConnectionState() != NetConnection::SendingPunchPackets || theParams.mIsInitiator)
continue;
if(nonce != theParams.mNonce)
continue;
for(j = 0; j < theParams.mPossibleAddresses.size(); j++)
if(theAddress.isEqualAddress(theParams.mPossibleAddresses[j]))
break;
if(j != theParams.mPossibleAddresses.size())
break;
}
if(i == mPendingConnections.size())
return;
ConnectionParameters &theParams = conn->getConnectionParameters();
SymmetricCipher theCipher(theParams.mArrangedSecret);
if(!stream->decryptAndCheckHash(NetConnection::MessageSignatureBytes, stream->getBytePosition(), &theCipher))
return;
stream->setBytePosition(stream->getBytePosition());
serverNonce.read(stream);
if(serverNonce != theParams.mServerNonce)
return;
if(stream->readFlag())
{
if(mPrivateKey.isNull())
return;
theParams.mUsingCrypto = true;
theParams.mPublicKey = new AsymmetricKey(stream);
theParams.mPrivateKey = mPrivateKey;
size_t decryptPos = stream->getBytePosition();
stream->setBytePosition(decryptPos);
theParams.mSharedSecret = theParams.mPrivateKey->computeSharedSecretKey(theParams.mPublicKey);
SymmetricCipher theCipher(theParams.mSharedSecret);
if(!stream->decryptAndCheckHash(NetConnection::MessageSignatureBytes, decryptPos, &theCipher))
return;
// now read the first part of the connection's session (symmetric) key
stream->read(SymmetricCipher::KeySize, theParams.mSymmetricKey);
Random::read(theParams.mInitVector, SymmetricCipher::KeySize);
}
U32 connectSequence;
theParams.mDebugObjectSizes = stream->readFlag();
stream->read(&connectSequence);
TNLLogMessageV(LogNetInterface, ("Received Arranged Connect Request"));
if(oldConnection)
disconnect(oldConnection, NetConnection::ReasonSelfDisconnect, "");
conn->setNetAddress(theAddress);
conn->setInitialRecvSequence(connectSequence);
if(theParams.mUsingCrypto)
conn->setSymmetricCipher(new SymmetricCipher(theParams.mSymmetricKey, theParams.mInitVector));
const char *errorString = NULL;
if(!conn->readConnectRequest(stream, &errorString))
{
sendConnectReject(&theParams, theAddress, errorString);
removePendingConnection(conn);
return;
}
addConnection(conn);
removePendingConnection(conn);
conn->setConnectionState(NetConnection::Connected);
conn->onConnectionEstablished();
sendConnectAccept(conn);
}
void Server::ProcessData(NetworkPacket *pkt)
{
DSTACK(__FUNCTION_NAME);
// Environment is locked first.
//MutexAutoLock envlock(m_env_mutex);
ScopeProfiler sp(g_profiler, "Server::ProcessData");
auto peer_id = pkt->getPeerId();
std::string addr_s;
try{
Address address = getPeerAddress(peer_id);
addr_s = address.serializeString();
// drop player if is ip is banned
if(m_banmanager->isIpBanned(addr_s)){
std::string ban_name = m_banmanager->getBanName(addr_s);
infostream<<"Server: A banned client tried to connect from "
<<addr_s<<"; banned name was "
<<ban_name<<std::endl;
// This actually doesn't seem to transfer to the client
DenyAccess(peer_id, std::string("Your ip is banned. Banned name was ") + ban_name);
return;
}
}
catch(con::PeerNotFoundException &e)
{
/*
* no peer for this packet found
* most common reason is peer timeout, e.g. peer didn't
* respond for some time, your server was overloaded or
* things like that.
*/
verbosestream<<"Server::ProcessData(): Canceling: peer "
<<peer_id<<" not found"<<std::endl;
return;
}
try
{
auto datasize = pkt->getSize();
if(datasize < 2)
return;
int command;
MsgpackPacketSafe packet;
msgpack::unpacked msg;
if (!con::parse_msgpack_packet(pkt->getString(0), datasize, &packet, &command, &msg)) {
verbosestream<<"Server: Ignoring broken packet from " <<addr_s<<" (peer_id="<<peer_id<<") size="<<datasize<<std::endl;
return;
}
if(command == TOSERVER_INIT_LEGACY)
{
RemoteClient* client = getClient(peer_id, CS_Created);
// If net_proto_version is set, this client has already been handled
if(client->getState() > CS_Created)
{
verbosestream<<"Server: Ignoring multiple TOSERVER_INITs from "
<<addr_s<<" (peer_id="<<peer_id<<")"<<std::endl;
return;
}
verbosestream<<"Server: Got TOSERVER_INIT from "<<addr_s<<" (peer_id="
<<peer_id<<")"<<std::endl;
// Do not allow multiple players in simple singleplayer mode.
// This isn't a perfect way to do it, but will suffice for now
if(m_simple_singleplayer_mode && m_clients.getClientIDs().size() > 1){
infostream<<"Server: Not allowing another client ("<<addr_s
<<") to connect in simple singleplayer mode"<<std::endl;
DenyAccess(peer_id, "Running in simple singleplayer mode.");
return;
}
// First byte after command is maximum supported
// serialization version
u8 client_max;
packet[TOSERVER_INIT_LEGACY_FMT].convert(&client_max);
u8 our_max = SER_FMT_VER_HIGHEST_READ;
// Use the highest version supported by both
int deployed = std::min(client_max, our_max);
// If it's lower than the lowest supported, give up.
if (deployed < SER_FMT_VER_LOWEST_READ)
deployed = SER_FMT_VER_INVALID;
if (deployed == SER_FMT_VER_INVALID)
{
actionstream<<"Server: A mismatched client tried to connect from "
<<addr_s<<std::endl;
infostream<<"Server: Cannot negotiate serialization version with "
<<addr_s<<std::endl;
DenyAccess(peer_id, std::string(
"Your client's version is not supported.\n"
"Server version is ")
+ (g_version_string) + "."
);
return;
}
client->setPendingSerializationVersion(deployed);
/*
Read and check network protocol version
*/
u16 min_net_proto_version = 0;
packet[TOSERVER_INIT_LEGACY_PROTOCOL_VERSION_MIN].convert(&min_net_proto_version);
u16 max_net_proto_version = min_net_proto_version;
packet[TOSERVER_INIT_LEGACY_PROTOCOL_VERSION_MAX].convert(&max_net_proto_version);
packet.convert_safe(TOSERVER_INIT_LEGACY_PROTOCOL_VERSION_FM, &client->net_proto_version_fm);
// Start with client's maximum version
u16 net_proto_version = max_net_proto_version;
// Figure out a working version if it is possible at all
if(max_net_proto_version >= SERVER_PROTOCOL_VERSION_MIN ||
min_net_proto_version <= SERVER_PROTOCOL_VERSION_MAX)
{
// If maximum is larger than our maximum, go with our maximum
if(max_net_proto_version > SERVER_PROTOCOL_VERSION_MAX)
net_proto_version = SERVER_PROTOCOL_VERSION_MAX;
// Else go with client's maximum
else
net_proto_version = max_net_proto_version;
}
verbosestream<<"Server: "<<addr_s<<": Protocol version: min: "
<<min_net_proto_version<<", max: "<<max_net_proto_version
<<", chosen: "<<net_proto_version<<std::endl;
client->net_proto_version = net_proto_version;
if(net_proto_version < SERVER_PROTOCOL_VERSION_MIN ||
net_proto_version > SERVER_PROTOCOL_VERSION_MAX)
{
actionstream<<"Server: A mismatched client tried to connect from "
<<addr_s<<std::endl;
DenyAccess(peer_id, std::string(
"Your client's version is not supported.\n"
"Server version is ")
+ (g_version_string) + ",\n"
+ "server's PROTOCOL_VERSION is "
+ itos(SERVER_PROTOCOL_VERSION_MIN)
+ "..."
+ itos(SERVER_PROTOCOL_VERSION_MAX)
+ ", client's PROTOCOL_VERSION is "
+ itos(min_net_proto_version)
+ "..."
+ itos(max_net_proto_version)
);
return;
}
if(g_settings->getBool("strict_protocol_version_checking"))
{
if(net_proto_version != LATEST_PROTOCOL_VERSION)
{
actionstream<<"Server: A mismatched (strict) client tried to "
<<"connect from "<<addr_s<<std::endl;
DenyAccess(peer_id, std::string(
"Your client's version is not supported.\n"
"Server version is ")
+ (g_version_string) + ",\n"
+ "server's PROTOCOL_VERSION (strict) is "
+ itos(LATEST_PROTOCOL_VERSION)
+ ", client's PROTOCOL_VERSION is "
+ itos(min_net_proto_version)
+ "..."
+ itos(max_net_proto_version)
);
return;
}
}
/*
Set up player
*/
// Get player name
std::string playername;
packet[TOSERVER_INIT_LEGACY_NAME].convert(&playername);
if(playername.empty())
{
actionstream<<"Server: Player with an empty name "
<<"tried to connect from "<<addr_s<<std::endl;
DenyAccess(peer_id, "Empty name");
return;
}
if(!g_settings->getBool("enable_any_name") && string_allowed(playername, PLAYERNAME_ALLOWED_CHARS)==false)
{
actionstream<<"Server: Player with an invalid name ["<<playername
<<"] tried to connect from "<<addr_s<<std::endl;
DenyAccess(peer_id, "Name contains unallowed characters");
return;
}
if(!isSingleplayer() && playername == "singleplayer")
{
actionstream<<"Server: Player with the name \"singleplayer\" "
<<"tried to connect from "<<addr_s<<std::endl;
DenyAccess(peer_id, "Name is not allowed");
return;
}
{
std::string reason;
if(m_script->on_prejoinplayer(playername, addr_s, &reason))
{
actionstream<<"Server: Player with the name \""<<playername<<"\" "
<<"tried to connect from "<<addr_s<<" "
<<"but it was disallowed for the following reason: "
<<reason<<std::endl;
DenyAccess(peer_id, reason);
return;
}
}
infostream<<"Server: New connection: \""<<playername<<"\" from "
<<addr_s<<" (peer_id="<<peer_id<<")"<<std::endl;
// Get password
std::string given_password;
packet[TOSERVER_INIT_LEGACY_PASSWORD].convert(&given_password);
if(!base64_is_valid(given_password.c_str())){
actionstream<<"Server: "<<playername
<<" supplied invalid password hash"<<std::endl;
DenyAccess(peer_id, "Invalid password hash");
return;
}
// Enforce user limit.
// Don't enforce for users that have some admin right
if(m_clients.getClientIDs(CS_Created).size() >= g_settings->getU16("max_users") &&
!checkPriv(playername, "server") &&
!checkPriv(playername, "ban") &&
!checkPriv(playername, "privs") &&
!checkPriv(playername, "password") &&
playername != g_settings->get("name"))
{
actionstream<<"Server: "<<playername<<" tried to join, but there"
<<" are already max_users="
<<g_settings->getU16("max_users")<<" players."<<std::endl;
DenyAccess(peer_id, "Too many users.");
return;
}
std::string checkpwd; // Password hash to check against
bool has_auth = m_script->getAuth(playername, &checkpwd, NULL);
// If no authentication info exists for user, create it
if(!has_auth){
if(!isSingleplayer() &&
g_settings->getBool("disallow_empty_password") &&
given_password == ""){
actionstream<<"Server: "<<playername
<<" supplied empty password"<<std::endl;
DenyAccess(peer_id, "Empty passwords are "
"disallowed. Set a password and try again.");
return;
}
std::string raw_default_password = g_settings->get("default_password");
std::string initial_password =
translatePassword(playername, raw_default_password);
// If default_password is empty, allow any initial password
if (raw_default_password.length() == 0)
initial_password = given_password;
m_script->createAuth(playername, initial_password);
}
has_auth = m_script->getAuth(playername, &checkpwd, NULL);
if(!has_auth){
actionstream<<"Server: "<<playername<<" cannot be authenticated"
<<" (auth handler does not work?)"<<std::endl;
DenyAccess(peer_id, "Not allowed to login");
return;
}
if(given_password != checkpwd){
actionstream<<"Server: "<<playername<<" supplied wrong password"
<<std::endl;
DenyAccess(peer_id, "Wrong password");
return;
}
RemotePlayer *player =
static_cast<RemotePlayer*>(m_env->getPlayer(playername.c_str()));
if(player && player->peer_id != 0){
errorstream<<"Server: "<<playername<<": Failed to emerge player"
<<" (player allocated to an another client)"<<std::endl;
DenyAccess(peer_id, "Another client is connected with this "
"name. If your client closed unexpectedly, try again in "
"a minute.");
}
m_clients.setPlayerName(peer_id,playername);
/*
Answer with a TOCLIENT_INIT
*/
{
MSGPACK_PACKET_INIT(TOCLIENT_INIT_LEGACY, 5);
PACK(TOCLIENT_INIT_DEPLOYED, deployed);
PACK(TOCLIENT_INIT_SEED, m_env->getServerMap().getSeed());
PACK(TOCLIENT_INIT_STEP, g_settings->getFloat("dedicated_server_step"));
//if (player) //todo : remake me
// PACK(TOCLIENT_INIT_POS, player->getPosition());
Settings params;
m_emerge->params.save(params);
PACK(TOCLIENT_INIT_MAP_PARAMS, params);
PACK(TOCLIENT_INIT_PROTOCOL_VERSION_FM, SERVER_PROTOCOL_VERSION_FM);
// Send as reliable
m_clients.send(peer_id, 0, buffer, true);
m_clients.event(peer_id, CSE_InitLegacy);
}
return;
}
if(command == TOSERVER_INIT2)
{
verbosestream<<"Server: Got TOSERVER_INIT2 from "
<<peer_id<<std::endl;
m_clients.event(peer_id, CSE_GotInit2);
u16 protocol_version = m_clients.getProtocolVersion(peer_id);
///// begin compatibility code
PlayerSAO* playersao = NULL;
if (protocol_version <= 22) {
playersao = StageTwoClientInit(peer_id);
if (playersao == NULL) {
errorstream
<< "TOSERVER_INIT2 stage 2 client init failed for peer "
<< peer_id << std::endl;
return;
}
}
///// end compatibility code
/*
Send some initialization data
*/
infostream<<"Server: Sending content to "
<<getPlayerName(peer_id)<<std::endl;
// Send player movement settings
SendMovement(peer_id);
// Send item definitions
SendItemDef(peer_id, m_itemdef, protocol_version);
// Send node definitions
SendNodeDef(peer_id, m_nodedef, protocol_version);
m_clients.event(peer_id, CSE_SetDefinitionsSent);
// Send media announcement
sendMediaAnnouncement(peer_id);
// Send detached inventories
sendDetachedInventories(peer_id);
// Send time of day
u16 time = m_env->getTimeOfDay();
float time_speed = g_settings->getFloat("time_speed");
SendTimeOfDay(peer_id, time, time_speed);
///// begin compatibility code
if (protocol_version <= 22) {
m_clients.event(peer_id, CSE_SetClientReady);
m_script->on_joinplayer(playersao);
}
///// end compatibility code
// Warnings about protocol version can be issued here
if(getClient(peer_id)->net_proto_version < LATEST_PROTOCOL_VERSION)
{
SendChatMessage(peer_id, "# Server: WARNING: YOUR CLIENT'S "
"VERSION MAY NOT BE FULLY COMPATIBLE WITH THIS SERVER!");
}
return;
}
u8 peer_ser_ver = getClient(peer_id, CS_InitDone)->serialization_version;
u16 peer_proto_ver = getClient(peer_id, CS_InitDone)->net_proto_version;
if(peer_ser_ver == SER_FMT_VER_INVALID)
{
errorstream<<"Server::ProcessData(): Canceling: Peer"
" serialization format invalid or not initialized."
" Skipping incoming command="<<command<<std::endl;
return;
}
/* Handle commands relate to client startup */
if(command == TOSERVER_REQUEST_MEDIA) {
std::vector<std::string> tosend;
packet[TOSERVER_REQUEST_MEDIA_FILES].convert(&tosend);
sendRequestedMedia(peer_id, tosend);
return;
}
else if(command == TOSERVER_RECEIVED_MEDIA) {
return;
}
else if(command == TOSERVER_CLIENT_READY) {
// clients <= protocol version 22 did not send ready message,
// they're already initialized
if (peer_proto_ver <= 22) {
infostream << "Client sent message not expected by a "
<< "client using protocol version <= 22,"
<< "disconnecting peer_id: " << peer_id << std::endl;
m_con.DisconnectPeer(peer_id);
return;
}
PlayerSAO* playersao = StageTwoClientInit(peer_id);
// If failed, cancel
if (playersao == NULL) {
errorstream
<< "TOSERVER_CLIENT_READY stage 2 client init failed for peer_id: "
<< peer_id << std::endl;
m_con.DisconnectPeer(peer_id);
return;
}
int version_patch = 0, version_tweak = 0;
packet.convert_safe(TOSERVER_CLIENT_READY_VERSION_PATCH, &version_patch);
packet.convert_safe(TOSERVER_CLIENT_READY_VERSION_TWEAK, &version_tweak);
if (version_tweak) {} //no warn todo remove
m_clients.setClientVersion(
peer_id,
packet[TOSERVER_CLIENT_READY_VERSION_MAJOR].as<int>(),
packet[TOSERVER_CLIENT_READY_VERSION_MINOR].as<int>(),
version_patch,
//version_tweak,
packet[TOSERVER_CLIENT_READY_VERSION_STRING].as<std::string>()
);
m_clients.event(peer_id, CSE_SetClientReady);
m_script->on_joinplayer(playersao);
stat.add("join", playersao->getPlayer()->getName());
}
if (m_clients.getClientState(peer_id) < CS_Active)
{
if (command == TOSERVER_PLAYERPOS) return;
errorstream<<"Got packet command: " << command << " for peer id "
<< peer_id << " but client isn't active yet. Dropping packet "
<<std::endl;
return;
}
Player *player = m_env->getPlayer(peer_id);
if(player == NULL) {
/*
verbosestream<<"Server::ProcessData(): Canceling: "
"No player for peer_id="<<peer_id
<< " disconnecting peer!" <<std::endl;
*/
m_con.DisconnectPeer(peer_id);
return;
}
PlayerSAO *playersao = player->getPlayerSAO();
if(playersao == NULL) {
errorstream<<"Server::ProcessData(): Canceling: "
"No player object for peer_id="<<peer_id
<< " disconnecting peer!" <<std::endl;
m_con.DisconnectPeer(peer_id);
return;
}
if(command == TOSERVER_PLAYERPOS)
{
// If player is dead we don't care of this packet
if (player->hp != 0 && playersao->m_ms_from_last_respawn > 1000)
player->setPosition(packet[TOSERVER_PLAYERPOS_POSITION].as<v3f>());
player->setSpeed(packet[TOSERVER_PLAYERPOS_SPEED].as<v3f>());
player->setPitch(modulo360f(packet[TOSERVER_PLAYERPOS_PITCH].as<f32>()));
player->setYaw(modulo360f(packet[TOSERVER_PLAYERPOS_YAW].as<f32>()));
u32 keyPressed = packet[TOSERVER_PLAYERPOS_KEY_PRESSED].as<u32>();
player->keyPressed = keyPressed;
{
std::lock_guard<std::mutex> lock(player->control_mutex);
player->control.up = (bool)(keyPressed&1);
player->control.down = (bool)(keyPressed&2);
player->control.left = (bool)(keyPressed&4);
player->control.right = (bool)(keyPressed&8);
player->control.jump = (bool)(keyPressed&16);
player->control.aux1 = (bool)(keyPressed&32);
player->control.sneak = (bool)(keyPressed&64);
player->control.LMB = (bool)(keyPressed&128);
player->control.RMB = (bool)(keyPressed&256);
}
auto old_pos = playersao->m_last_good_position;
if(playersao->checkMovementCheat()){
// Call callbacks
m_script->on_cheat(playersao, "moved_too_fast");
SendMovePlayer(peer_id);
}
else if (playersao->m_ms_from_last_respawn > 3000) {
auto dist = (old_pos/BS).getDistanceFrom(playersao->m_last_good_position/BS);
if (dist)
stat.add("move", playersao->getPlayer()->getName(), dist);
}
if (playersao->m_ms_from_last_respawn > 2000) {
auto obj = playersao; // copypasted from server step:
auto uptime = m_uptime.get();
if (!obj->m_uptime_last) // not very good place, but minimum modifications
obj->m_uptime_last = uptime - 0.1;
if (uptime - obj->m_uptime_last > 0.5) {
obj->step(uptime - obj->m_uptime_last, true); //todo: maybe limit count per time
obj->m_uptime_last = uptime;
}
}
/*infostream<<"Server::ProcessData(): Moved player "<<peer_id<<" to "
<<"("<<position.X<<","<<position.Y<<","<<position.Z<<")"
<<" pitch="<<pitch<<" yaw="<<yaw<<std::endl;*/
}
else if(command == TOSERVER_DELETEDBLOCKS)
{
std::vector<v3s16> deleted_blocks;
packet[TOSERVER_DELETEDBLOCKS_DATA].convert(&deleted_blocks);
RemoteClient *client = getClient(peer_id);
for (auto &block : deleted_blocks)
client->SetBlockDeleted(block);
}
else if(command == TOSERVER_INVENTORY_ACTION)
{
std::string datastring;
packet[TOSERVER_INVENTORY_ACTION_DATA].convert(&datastring);
std::istringstream is(datastring, std::ios_base::binary);
// Create an action
InventoryAction *a = InventoryAction::deSerialize(is);
if(a == NULL)
{
infostream<<"TOSERVER_INVENTORY_ACTION: "
<<"InventoryAction::deSerialize() returned NULL"
<<std::endl;
return;
}
// If something goes wrong, this player is to blame
RollbackScopeActor rollback_scope(m_rollback,
std::string("player:")+player->getName());
/*
Note: Always set inventory not sent, to repair cases
where the client made a bad prediction.
*/
/*
Handle restrictions and special cases of the move action
*/
if(a->getType() == IACTION_MOVE)
{
IMoveAction *ma = (IMoveAction*)a;
ma->from_inv.applyCurrentPlayer(player->getName());
ma->to_inv.applyCurrentPlayer(player->getName());
setInventoryModified(ma->from_inv, false);
setInventoryModified(ma->to_inv, false);
bool from_inv_is_current_player =
(ma->from_inv.type == InventoryLocation::PLAYER) &&
(ma->from_inv.name == player->getName());
bool to_inv_is_current_player =
(ma->to_inv.type == InventoryLocation::PLAYER) &&
(ma->to_inv.name == player->getName());
/*
Disable moving items out of craftpreview
*/
if(ma->from_list == "craftpreview")
{
infostream<<"Ignoring IMoveAction from "
<<(ma->from_inv.dump())<<":"<<ma->from_list
<<" to "<<(ma->to_inv.dump())<<":"<<ma->to_list
<<" because src is "<<ma->from_list<<std::endl;
delete a;
return;
}
/*
Disable moving items into craftresult and craftpreview
*/
if(ma->to_list == "craftpreview" || ma->to_list == "craftresult")
{
infostream<<"Ignoring IMoveAction from "
<<(ma->from_inv.dump())<<":"<<ma->from_list
<<" to "<<(ma->to_inv.dump())<<":"<<ma->to_list
<<" because dst is "<<ma->to_list<<std::endl;
delete a;
return;
}
// Disallow moving items in elsewhere than player's inventory
// if not allowed to interact
if(!checkPriv(player->getName(), "interact") &&
(!from_inv_is_current_player ||
!to_inv_is_current_player))
{
infostream<<"Cannot move outside of player's inventory: "
<<"No interact privilege"<<std::endl;
delete a;
return;
}
}
/*
Handle restrictions and special cases of the drop action
*/
else if(a->getType() == IACTION_DROP)
{
IDropAction *da = (IDropAction*)a;
da->from_inv.applyCurrentPlayer(player->getName());
setInventoryModified(da->from_inv, false);
/*
Disable dropping items out of craftpreview
*/
if(da->from_list == "craftpreview")
{
infostream<<"Ignoring IDropAction from "
<<(da->from_inv.dump())<<":"<<da->from_list
<<" because src is "<<da->from_list<<std::endl;
delete a;
return;
}
// Disallow dropping items if not allowed to interact
if(!checkPriv(player->getName(), "interact"))
{
delete a;
return;
}
stat.add("drop", player->getName());
}
/*
Handle restrictions and special cases of the craft action
*/
else if(a->getType() == IACTION_CRAFT)
{
ICraftAction *ca = (ICraftAction*)a;
ca->craft_inv.applyCurrentPlayer(player->getName());
setInventoryModified(ca->craft_inv, false);
//bool craft_inv_is_current_player =
// (ca->craft_inv.type == InventoryLocation::PLAYER) &&
// (ca->craft_inv.name == player->getName());
// Disallow crafting if not allowed to interact
if(!checkPriv(player->getName(), "interact"))
{
infostream<<"Cannot craft: "
<<"No interact privilege"<<std::endl;
delete a;
return;
}
stat.add("craft", player->getName());
}
// Do the action
a->apply(this, playersao, this);
// Eat the action
delete a;
SendInventory(playersao);
}
else if(command == TOSERVER_CHAT_MESSAGE)
{
std::string message = packet[TOSERVER_CHAT_MESSAGE_DATA].as<std::string>();
// If something goes wrong, this player is to blame
RollbackScopeActor rollback_scope(m_rollback,
std::string("player:")+player->getName());
// Get player name of this client
std::string name = player->getName();
// Run script hook
bool ate = m_script->on_chat_message(player->getName(), message);
// If script ate the message, don't proceed
if(ate)
return;
// Line to send to players
std::string line;
// Whether to send to other players
bool send_to_others = false;
// Commands are implemented in Lua, so only catch invalid
// commands that were not "eaten" and send an error back
if(message[0] == '/')
{
message = message.substr(1);
if(message.length() == 0)
line += "-!- Empty command";
else
// TODO: str_split(message, ' ')[0]
line += "-!- Invalid command: " + message;
}
else
{
if(checkPriv(player->getName(), "shout")){
line += "<";
line += name;
line += "> ";
line += message;
send_to_others = true;
} else
line += "-!- You don't have permission to shout.";
}
if(!line.empty())
{
if(send_to_others) {
stat.add("chat", player->getName());
actionstream<<"CHAT: "<<line<<std::endl;
SendChatMessage(PEER_ID_INEXISTENT, line);
} else
SendChatMessage(peer_id, line);
}
}
else if(command == TOSERVER_DAMAGE)
{
u8 damage = packet[TOSERVER_DAMAGE_VALUE].as<u8>();
if(g_settings->getBool("enable_damage"))
{
actionstream<<player->getName()<<" damaged by "
<<(int)damage<<" hp at "<<PP(player->getPosition()/BS)
<<std::endl;
playersao->setHP(playersao->getHP() - damage);
SendPlayerHPOrDie(playersao);
stat.add("damage", player->getName(), damage);
}
}
else if(command == TOSERVER_BREATH)
{
/*
* If player is dead, we don't need to update the breath
* He is dead !
*/
if (!player->isDead()) {
playersao->setBreath(packet[TOSERVER_BREATH_VALUE].as<u16>());
SendPlayerBreath(peer_id);
}
}
else if(command == TOSERVER_CHANGE_PASSWORD)
{
std::string oldpwd, newpwd;
packet[TOSERVER_CHANGE_PASSWORD_OLD].convert(&oldpwd);
packet[TOSERVER_CHANGE_PASSWORD_NEW].convert(&newpwd);
if(!base64_is_valid(newpwd)){
infostream<<"Server: "<<player->getName()<<" supplied invalid password hash"<<std::endl;
// Wrong old password supplied!!
SendChatMessage(peer_id, "Invalid new password hash supplied. Password NOT changed.");
return;
}
infostream<<"Server: Client requests a password change from "
<<"'"<<oldpwd<<"' to '"<<newpwd<<"'"<<std::endl;
std::string playername = player->getName();
std::string checkpwd;
m_script->getAuth(playername, &checkpwd, NULL);
if(oldpwd != checkpwd)
{
infostream<<"Server: invalid old password"<<std::endl;
// Wrong old password supplied!!
SendChatMessage(peer_id, "Invalid old password supplied. Password NOT changed.");
return;
}
bool success = m_script->setPassword(playername, newpwd);
if(success){
actionstream<<player->getName()<<" changes password"<<std::endl;
SendChatMessage(peer_id, "Password change successful.");
} else {
actionstream<<player->getName()<<" tries to change password but "
<<"it fails"<<std::endl;
SendChatMessage(peer_id, "Password change failed or inavailable.");
}
}
else if(command == TOSERVER_PLAYERITEM)
{
u16 item = packet[TOSERVER_PLAYERITEM_VALUE].as<u16>();
playersao->setWieldIndex(item);
}
else if(command == TOSERVER_RESPAWN)
{
if(!player->isDead())
return;
RespawnPlayer(peer_id);
actionstream << player->getName() << " respawns at "
<< PP(player->getPosition()/BS) << std::endl;
// ActiveObject is added to environment in AsyncRunStep after
// the previous addition has been successfully removed
}
else if(command == TOSERVER_INTERACT)
{
u8 action;
u16 item_i;
PointedThing pointed;
packet[TOSERVER_INTERACT_ACTION].convert(&action);
packet[TOSERVER_INTERACT_ITEM].convert(&item_i);
packet[TOSERVER_INTERACT_POINTED_THING].convert(&pointed);
if(player->hp == 0)
{
verbosestream<<"TOSERVER_INTERACT: "<<player->getName()
<<" tried to interact, but is dead!"<<std::endl;
return;
}
#if !ENABLE_THREADS
auto lock = m_env->getMap().m_nothread_locker.lock_unique_rec();
#endif
v3f player_pos = playersao->getLastGoodPosition();
// Update wielded item
playersao->setWieldIndex(item_i);
// Get pointed to node (undefined if not POINTEDTYPE_NODE)
v3s16 p_under = pointed.node_undersurface;
v3s16 p_above = pointed.node_abovesurface;
// Get pointed to object (NULL if not POINTEDTYPE_OBJECT)
ServerActiveObject *pointed_object = NULL;
if(pointed.type == POINTEDTHING_OBJECT)
{
pointed_object = m_env->getActiveObject(pointed.object_id);
if(pointed_object == NULL)
{
verbosestream<<"TOSERVER_INTERACT: "
"pointed object is NULL"<<std::endl;
return;
}
}
v3f pointed_pos_under = player_pos;
v3f pointed_pos_above = player_pos;
if(pointed.type == POINTEDTHING_NODE)
{
pointed_pos_under = intToFloat(p_under, BS);
pointed_pos_above = intToFloat(p_above, BS);
}
else if(pointed.type == POINTEDTHING_OBJECT)
{
pointed_pos_under = pointed_object->getBasePosition();
pointed_pos_above = pointed_pos_under;
}
/*
Check that target is reasonably close
(only when digging or placing things)
*/
if(action == 0 || action == 2 || action == 3)
{
float d = player_pos.getDistanceFrom(pointed_pos_under);
float max_d = BS * 14; // Just some large enough value
if(d > max_d){
actionstream<<"Player "<<player->getName()
<<" tried to access "<<pointed.dump()
<<" from too far: "
<<"d="<<d<<", max_d="<<max_d
<<". ignoring."<<std::endl;
// Re-send block to revert change on client-side
RemoteClient *client = getClient(peer_id);
v3s16 blockpos = getNodeBlockPos(floatToInt(pointed_pos_under, BS));
client->SetBlockNotSent(blockpos);
// Call callbacks
m_script->on_cheat(playersao, "interacted_too_far");
// Do nothing else
return;
}
}
/*
Make sure the player is allowed to do it
*/
if(!checkPriv(player->getName(), "interact"))
{
actionstream<<player->getName()<<" attempted to interact with "
<<pointed.dump()<<" without 'interact' privilege"
<<std::endl;
// Re-send block to revert change on client-side
RemoteClient *client = getClient(peer_id);
// Digging completed -> under
if(action == 2){
v3s16 blockpos = getNodeBlockPos(floatToInt(pointed_pos_under, BS));
client->SetBlockNotSent(blockpos);
}
// Placement -> above
if(action == 3){
v3s16 blockpos = getNodeBlockPos(floatToInt(pointed_pos_above, BS));
client->SetBlockNotSent(blockpos);
}
stat.add("interact_denied", player->getName());
return;
}
/*
If something goes wrong, this player is to blame
*/
RollbackScopeActor rollback_scope(m_rollback,
std::string("player:")+player->getName());
/*
0: start digging or punch object
*/
if(action == 0)
{
if(pointed.type == POINTEDTHING_NODE)
{
/*
NOTE: This can be used in the future to check if
somebody is cheating, by checking the timing.
*/
MapNode n(CONTENT_IGNORE);
bool pos_ok;
n = m_env->getMap().getNodeNoEx(p_under, &pos_ok);
if (pos_ok)
n = m_env->getMap().getNodeNoEx(p_under, &pos_ok);
if (!pos_ok) {
infostream<<"Server: Not punching: Node not found."
<<" Adding block to emerge queue."
<<std::endl;
m_emerge->enqueueBlockEmerge(peer_id, getNodeBlockPos(p_above), false);
}
if(n.getContent() != CONTENT_IGNORE)
m_script->node_on_punch(p_under, n, playersao, pointed);
// Cheat prevention
playersao->noCheatDigStart(p_under);
}
else if(pointed.type == POINTEDTHING_OBJECT)
{
// Skip if object has been removed
if(pointed_object->m_removed)
return;
actionstream<<player->getName()<<" punches object "
<<pointed.object_id<<": "
<<pointed_object->getDescription()<<std::endl;
ItemStack punchitem = playersao->getWieldedItem();
ToolCapabilities toolcap =
punchitem.getToolCapabilities(m_itemdef);
v3f dir = (pointed_object->getBasePosition() -
(player->getPosition() + player->getEyeOffset())
).normalize();
float time_from_last_punch =
playersao->resetTimeFromLastPunch();
s16 src_original_hp = pointed_object->getHP();
s16 dst_origin_hp = playersao->getHP();
pointed_object->punch(dir, &toolcap, playersao,
time_from_last_punch);
// If the object is a player and its HP changed
if (src_original_hp != pointed_object->getHP() &&
pointed_object->getType() == ACTIVEOBJECT_TYPE_PLAYER) {
SendPlayerHPOrDie(((PlayerSAO*)pointed_object));
}
// If the puncher is a player and its HP changed
if (dst_origin_hp != playersao->getHP()) {
SendPlayerHPOrDie(playersao);
}
stat.add("punch", player->getName());
}
} // action == 0
/*
1: stop digging
*/
else if(action == 1)
{
} // action == 1
/*
2: Digging completed
*/
else if(action == 2)
{
// Only digging of nodes
if(pointed.type == POINTEDTHING_NODE)
{
bool pos_ok;
MapNode n = m_env->getMap().getNodeNoEx(p_under, &pos_ok);
if (!pos_ok) {
infostream << "Server: Not finishing digging: Node not found."
<< " Adding block to emerge queue."
<< std::endl;
m_emerge->enqueueBlockEmerge(peer_id, getNodeBlockPos(p_above), false);
}
/* Cheat prevention */
bool is_valid_dig = true;
if(!isSingleplayer() && !g_settings->getBool("disable_anticheat"))
{
v3s16 nocheat_p = playersao->getNoCheatDigPos();
float nocheat_t = playersao->getNoCheatDigTime();
playersao->noCheatDigEnd();
// If player didn't start digging this, ignore dig
if(nocheat_p != p_under){
infostream<<"Server: NoCheat: "<<player->getName()
<<" started digging "
<<PP(nocheat_p)<<" and completed digging "
<<PP(p_under)<<"; not digging."<<std::endl;
is_valid_dig = false;
// Call callbacks
m_script->on_cheat(playersao, "finished_unknown_dig");
}
// Get player's wielded item
ItemStack playeritem;
InventoryList *mlist = playersao->getInventory()->getList("main");
if(mlist != NULL)
playeritem = mlist->getItem(playersao->getWieldIndex());
ToolCapabilities playeritem_toolcap =
playeritem.getToolCapabilities(m_itemdef);
// Get diggability and expected digging time
DigParams params = getDigParams(m_nodedef->get(n).groups,
&playeritem_toolcap);
// If can't dig, try hand
if(!params.diggable){
const ItemDefinition &hand = m_itemdef->get("");
const ToolCapabilities *tp = hand.tool_capabilities;
if(tp)
params = getDigParams(m_nodedef->get(n).groups, tp);
}
// If can't dig, ignore dig
if(!params.diggable){
infostream<<"Server: NoCheat: "<<player->getName()
<<" completed digging "<<PP(p_under)
<<", which is not diggable with tool. not digging."
<<std::endl;
is_valid_dig = false;
// Call callbacks
m_script->on_cheat(playersao, "dug_unbreakable");
}
// Check digging time
// If already invalidated, we don't have to
if(!is_valid_dig){
// Well not our problem then
}
// Clean and long dig
else if(params.time > 2.0 && nocheat_t * 1.2 > params.time){
// All is good, but grab time from pool; don't care if
// it's actually available
playersao->getDigPool().grab(params.time);
}
// Short or laggy dig
// Try getting the time from pool
else if(playersao->getDigPool().grab(params.time)){
// All is good
}
// Dig not possible
else{
infostream<<"Server: NoCheat: "<<player->getName()
<<" completed digging "<<PP(p_under)
<<"too fast; not digging."<<std::endl;
is_valid_dig = false;
// Call callbacks
m_script->on_cheat(playersao, "dug_too_fast");
}
}
/* Actually dig node */
if(is_valid_dig && n.getContent() != CONTENT_IGNORE)
{
m_script->node_on_dig(p_under, n, playersao);
stat.add("dig", player->getName());
stat.add("dig_"+ m_nodedef->get(n).name , player->getName());
}
v3s16 blockpos = getNodeBlockPos(floatToInt(pointed_pos_under, BS));
RemoteClient *client = getClient(peer_id);
// Send unusual result (that is, node not being removed)
if(m_env->getMap().getNodeNoEx(p_under).getContent() != CONTENT_AIR)
{
// Re-send block to revert change on client-side
client->SetBlockNotSent(blockpos);
}
else {
client->ResendBlockIfOnWire(blockpos);
}
}
} // action == 2
/*
3: place block or right-click object
*/
else if(action == 3)
{
ItemStack item = playersao->getWieldedItem();
// Reset build time counter
if(pointed.type == POINTEDTHING_NODE &&
item.getDefinition(m_itemdef).type == ITEM_NODE)
getClient(peer_id)->m_time_from_building = 0.0;
if(pointed.type == POINTEDTHING_OBJECT)
{
// Right click object
// Skip if object has been removed
if(pointed_object->m_removed)
return;
/* android bug - too many
actionstream<<player->getName()<<" right-clicks object "
<<pointed.object_id<<": "
<<pointed_object->getDescription()<<std::endl;
*/
// Do stuff
pointed_object->rightClick(playersao);
}
else if(m_script->item_OnPlace(
item, playersao, pointed))
{
// Placement was handled in lua
// Apply returned ItemStack
if (playersao->setWieldedItem(item)) {
SendInventory(playersao);
}
stat.add("place", player->getName());
//stat.add("place_" + item.name, player->getName());
}
// If item has node placement prediction, always send the
// blocks to make sure the client knows what exactly happened
RemoteClient *client = getClient(peer_id);
v3s16 blockpos = getNodeBlockPos(floatToInt(pointed_pos_above, BS));
v3s16 blockpos2 = getNodeBlockPos(floatToInt(pointed_pos_under, BS));
if(item.getDefinition(m_itemdef).node_placement_prediction != "") {
client->SetBlockNotSent(blockpos);
if(blockpos2 != blockpos) {
client->SetBlockNotSent(blockpos2);
}
}
else {
client->ResendBlockIfOnWire(blockpos);
if(blockpos2 != blockpos) {
client->ResendBlockIfOnWire(blockpos2);
}
}
} // action == 3
/*
4: use
*/
else if(action == 4)
{
ItemStack item = playersao->getWieldedItem();
actionstream<<player->getName()<<" uses "<<item.name
<<", pointing at "<<pointed.dump()<<std::endl;
if(m_script->item_OnUse(
item, playersao, pointed))
{
// Apply returned ItemStack
if (playersao->setWieldedItem(item)) {
SendInventory(playersao);
}
stat.add("use", player->getName());
stat.add("use_" + item.name, player->getName());
}
} // action == 4
/*
Catch invalid actions
*/
else
{
infostream<<"WARNING: Server: Invalid action "
<<action<<std::endl;
}
}
else if(command == TOSERVER_REMOVED_SOUNDS)
{
std::vector<s32> removed_ids;
packet[TOSERVER_REMOVED_SOUNDS_IDS].convert(&removed_ids);
for (auto id : removed_ids) {
std::map<s32, ServerPlayingSound>::iterator i =
m_playing_sounds.find(id);
if(i == m_playing_sounds.end())
continue;
ServerPlayingSound &psound = i->second;
psound.clients.erase(peer_id);
if(psound.clients.empty())
m_playing_sounds.erase(i);
}
}
else if(command == TOSERVER_NODEMETA_FIELDS)
{
v3s16 p = packet[TOSERVER_NODEMETA_FIELDS_POS].as<v3s16>();
std::string formname = packet[TOSERVER_NODEMETA_FIELDS_FORMNAME].as<std::string>();
std::map<std::string, std::string> fields;
packet[TOSERVER_NODEMETA_FIELDS_DATA].convert(&fields);
// If something goes wrong, this player is to blame
RollbackScopeActor rollback_scope(m_rollback,
std::string("player:")+player->getName());
// Check the target node for rollback data; leave others unnoticed
RollbackNode rn_old(&m_env->getMap(), p, this);
m_script->node_on_receive_fields(p, formname, fields,playersao);
// Report rollback data
RollbackNode rn_new(&m_env->getMap(), p, this);
if(rollback() && rn_new != rn_old){
RollbackAction action;
action.setSetNode(p, rn_old, rn_new);
rollback()->reportAction(action);
}
}
else if(command == TOSERVER_INVENTORY_FIELDS)
{
std::string formname;
std::map<std::string, std::string> fields;
packet[TOSERVER_INVENTORY_FIELDS_FORMNAME].convert(&formname);
packet[TOSERVER_INVENTORY_FIELDS_DATA].convert(&fields);
m_script->on_playerReceiveFields(playersao, formname, fields);
}
else if(command == TOSERVER_DRAWCONTROL)
{
auto client = getClient(peer_id);
auto lock = client->lock_unique_rec();
client->wanted_range = packet[TOSERVER_DRAWCONTROL_WANTED_RANGE].as<u32>();
client->range_all = packet[TOSERVER_DRAWCONTROL_RANGE_ALL].as<u32>();
client->farmesh = packet[TOSERVER_DRAWCONTROL_FARMESH].as<u8>();
client->fov = packet[TOSERVER_DRAWCONTROL_FOV].as<f32>();
//client->block_overflow = packet[TOSERVER_DRAWCONTROL_BLOCK_OVERFLOW].as<bool>();
}
else
{
infostream<<"Server::ProcessData(): Ignoring "
"unknown command "<<command<<std::endl;
}
} //try
catch(SendFailedException &e)
{
errorstream<<"Server::ProcessData(): SendFailedException: "
<<"what="<<e.what()
<<std::endl;
}
}
bool BreakpointManager::has(Address const &address) const {
if (!address.valid())
return false;
return (_sites.find(address) != _sites.end());
}
void FormatDisassembly::_FormatAddress(Address const& rAddress, u32 Flags)
{
if (rAddress.GetBase() != 0x0 && rAddress.GetBaseSize() != 0x0)
m_rPrintData.AppendImmediate(rAddress.GetBase(), rAddress.GetBaseSize()).AppendOperator(":");
m_rPrintData.AppendImmediate(rAddress.GetOffset(), rAddress.GetOffsetSize()).AppendSpace(8);
}
// get_player_information(name)
int ModApiServer::l_get_player_information(lua_State *L)
{
NO_MAP_LOCK_REQUIRED;
const char * name = luaL_checkstring(L, 1);
RemotePlayer *player = dynamic_cast<ServerEnvironment *>(getEnv(L))->getPlayer(name);
if (player == NULL) {
lua_pushnil(L); // no such player
return 1;
}
Address addr;
try
{
addr = getServer(L)->getPeerAddress(player->getPeerId());
} catch(const con::PeerNotFoundException &) {
dstream << FUNCTION_NAME << ": peer was not found" << std::endl;
lua_pushnil(L); // error
return 1;
}
float min_rtt,max_rtt,avg_rtt,min_jitter,max_jitter,avg_jitter;
ClientState state;
u32 uptime;
u16 prot_vers;
u8 ser_vers,major,minor,patch;
std::string vers_string;
#define ERET(code) \
if (!(code)) { \
dstream << FUNCTION_NAME << ": peer was not found" << std::endl; \
lua_pushnil(L); /* error */ \
return 1; \
}
ERET(getServer(L)->getClientConInfo(player->getPeerId(), con::MIN_RTT, &min_rtt))
ERET(getServer(L)->getClientConInfo(player->getPeerId(), con::MAX_RTT, &max_rtt))
ERET(getServer(L)->getClientConInfo(player->getPeerId(), con::AVG_RTT, &avg_rtt))
ERET(getServer(L)->getClientConInfo(player->getPeerId(), con::MIN_JITTER,
&min_jitter))
ERET(getServer(L)->getClientConInfo(player->getPeerId(), con::MAX_JITTER,
&max_jitter))
ERET(getServer(L)->getClientConInfo(player->getPeerId(), con::AVG_JITTER,
&avg_jitter))
ERET(getServer(L)->getClientInfo(player->getPeerId(), &state, &uptime, &ser_vers,
&prot_vers, &major, &minor, &patch, &vers_string))
lua_newtable(L);
int table = lua_gettop(L);
lua_pushstring(L,"address");
lua_pushstring(L, addr.serializeString().c_str());
lua_settable(L, table);
lua_pushstring(L,"ip_version");
if (addr.getFamily() == AF_INET) {
lua_pushnumber(L, 4);
} else if (addr.getFamily() == AF_INET6) {
lua_pushnumber(L, 6);
} else {
lua_pushnumber(L, 0);
}
lua_settable(L, table);
lua_pushstring(L,"min_rtt");
lua_pushnumber(L, min_rtt);
lua_settable(L, table);
lua_pushstring(L,"max_rtt");
lua_pushnumber(L, max_rtt);
lua_settable(L, table);
lua_pushstring(L,"avg_rtt");
lua_pushnumber(L, avg_rtt);
lua_settable(L, table);
lua_pushstring(L,"min_jitter");
lua_pushnumber(L, min_jitter);
lua_settable(L, table);
lua_pushstring(L,"max_jitter");
lua_pushnumber(L, max_jitter);
lua_settable(L, table);
lua_pushstring(L,"avg_jitter");
lua_pushnumber(L, avg_jitter);
lua_settable(L, table);
lua_pushstring(L,"connection_uptime");
lua_pushnumber(L, uptime);
lua_settable(L, table);
lua_pushstring(L,"protocol_version");
lua_pushnumber(L, prot_vers);
lua_settable(L, table);
#ifndef NDEBUG
lua_pushstring(L,"serialization_version");
lua_pushnumber(L, ser_vers);
lua_settable(L, table);
lua_pushstring(L,"major");
lua_pushnumber(L, major);
lua_settable(L, table);
lua_pushstring(L,"minor");
lua_pushnumber(L, minor);
lua_settable(L, table);
lua_pushstring(L,"patch");
lua_pushnumber(L, patch);
lua_settable(L, table);
lua_pushstring(L,"version_string");
lua_pushstring(L, vers_string.c_str());
lua_settable(L, table);
lua_pushstring(L,"state");
lua_pushstring(L,ClientInterface::state2Name(state).c_str());
lua_settable(L, table);
#endif
#undef ERET
return 1;
}
bool
SymbolContext::GetParentOfInlinedScope (const Address &curr_frame_pc,
SymbolContext &next_frame_sc,
Address &next_frame_pc) const
{
next_frame_sc.Clear(false);
next_frame_pc.Clear();
if (block)
{
//const addr_t curr_frame_file_addr = curr_frame_pc.GetFileAddress();
// In order to get the parent of an inlined function we first need to
// see if we are in an inlined block as "this->block" could be an
// inlined block, or a parent of "block" could be. So lets check if
// this block or one of this blocks parents is an inlined function.
Block *curr_inlined_block = block->GetContainingInlinedBlock();
if (curr_inlined_block)
{
// "this->block" is contained in an inline function block, so to
// get the scope above the inlined block, we get the parent of the
// inlined block itself
Block *next_frame_block = curr_inlined_block->GetParent();
// Now calculate the symbol context of the containing block
next_frame_block->CalculateSymbolContext (&next_frame_sc);
// If we get here we weren't able to find the return line entry using the nesting of the blocks and
// the line table. So just use the call site info from our inlined block.
AddressRange range;
if (curr_inlined_block->GetRangeContainingAddress (curr_frame_pc, range))
{
// To see there this new frame block it, we need to look at the
// call site information from
const InlineFunctionInfo* curr_inlined_block_inlined_info = curr_inlined_block->GetInlinedFunctionInfo();
next_frame_pc = range.GetBaseAddress();
next_frame_sc.line_entry.range.GetBaseAddress() = next_frame_pc;
next_frame_sc.line_entry.file = curr_inlined_block_inlined_info->GetCallSite().GetFile();
next_frame_sc.line_entry.line = curr_inlined_block_inlined_info->GetCallSite().GetLine();
next_frame_sc.line_entry.column = curr_inlined_block_inlined_info->GetCallSite().GetColumn();
return true;
}
else
{
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_SYMBOLS));
if (log)
{
log->Printf ("warning: inlined block 0x%8.8" PRIx64 " doesn't have a range that contains file address 0x%" PRIx64,
curr_inlined_block->GetID(), curr_frame_pc.GetFileAddress());
}
#ifdef LLDB_CONFIGURATION_DEBUG
else
{
ObjectFile *objfile = NULL;
if (module_sp)
{
SymbolVendor *symbol_vendor = module_sp->GetSymbolVendor();
if (symbol_vendor)
{
SymbolFile *symbol_file = symbol_vendor->GetSymbolFile();
if (symbol_file)
objfile = symbol_file->GetObjectFile();
}
}
if (objfile)
{
Host::SystemLog (Host::eSystemLogWarning,
"warning: inlined block 0x%8.8" PRIx64 " doesn't have a range that contains file address 0x%" PRIx64 " in %s\n",
curr_inlined_block->GetID(),
curr_frame_pc.GetFileAddress(),
objfile->GetFileSpec().GetPath().c_str());
}
else
{
Host::SystemLog (Host::eSystemLogWarning,
"warning: inlined block 0x%8.8" PRIx64 " doesn't have a range that contains file address 0x%" PRIx64 "\n",
curr_inlined_block->GetID(),
curr_frame_pc.GetFileAddress());
}
}
#endif
}
}
}
return false;
}
