void MakeSmartPtrCheck::registerMatchers(ast_matchers::MatchFinder *Finder) {
if (!isLanguageVersionSupported(getLangOpts()))
return;
// Calling make_smart_ptr from within a member function of a type with a
// private or protected constructor would be ill-formed.
auto CanCallCtor = unless(has(ignoringImpCasts(
cxxConstructExpr(hasDeclaration(decl(unless(isPublic())))))));
Finder->addMatcher(
cxxBindTemporaryExpr(has(ignoringParenImpCasts(
cxxConstructExpr(
hasType(getSmartPointerTypeMatcher()), argumentCountIs(1),
hasArgument(0,
cxxNewExpr(hasType(pointsTo(qualType(hasCanonicalType(
equalsBoundNode(PointerType))))),
CanCallCtor)
.bind(NewExpression)),
unless(isInTemplateInstantiation()))
.bind(ConstructorCall)))),
this);
Finder->addMatcher(
cxxMemberCallExpr(
thisPointerType(getSmartPointerTypeMatcher()),
callee(cxxMethodDecl(hasName("reset"))),
hasArgument(0, cxxNewExpr(CanCallCtor).bind(NewExpression)),
unless(isInTemplateInstantiation()))
.bind(ResetCall),
this);
}
void UseEqualsDeleteCheck::registerMatchers(MatchFinder *Finder) {
auto PrivateSpecialFn = cxxMethodDecl(
isPrivate(),
anyOf(cxxConstructorDecl(anyOf(isDefaultConstructor(),
isCopyConstructor(), isMoveConstructor())),
cxxMethodDecl(
anyOf(isCopyAssignmentOperator(), isMoveAssignmentOperator())),
cxxDestructorDecl()));
Finder->addMatcher(
cxxMethodDecl(
PrivateSpecialFn,
unless(anyOf(hasBody(stmt()), isDefaulted(), isDeleted(),
ast_matchers::isTemplateInstantiation(),
// Ensure that all methods except private special member
// functions are defined.
hasParent(cxxRecordDecl(hasMethod(unless(
anyOf(PrivateSpecialFn, hasBody(stmt()), isPure(),
isDefaulted(), isDeleted()))))))))
.bind(SpecialFunction),
this);
Finder->addMatcher(
cxxMethodDecl(isDeleted(), unless(isPublic())).bind(DeletedNotPublic),
this);
}
QString Modification::accessModifierString() const {
if (isPrivate()) return "private";
if (isProtected()) return "protected";
if (isPublic()) return "public";
if (isFriendly()) return "friendly";
return QString();
}
BOOL LLParcel::allowModifyBy(const LLUUID &agent_id, const LLUUID &group_id) const
{
if (agent_id == LLUUID::null)
{
// system always can enter
return TRUE;
}
else if (isPublic())
{
return TRUE;
}
else if (agent_id == mOwnerID)
{
// owner can always perform operations
return TRUE;
}
else if (mParcelFlags & PF_CREATE_OBJECTS)
{
return TRUE;
}
else if ((mParcelFlags & PF_CREATE_GROUP_OBJECTS)
&& group_id.notNull() )
{
return (getGroupID() == group_id);
}
return FALSE;
}
std::unique_ptr<Info> emitInfo(const NamespaceDecl *D, const FullComment *FC,
int LineNumber, llvm::StringRef File,
bool PublicOnly) {
if (PublicOnly && ((D->isAnonymousNamespace()) ||
!isPublic(D->getAccess(), D->getLinkageInternal())))
return nullptr;
auto I = llvm::make_unique<NamespaceInfo>();
populateInfo(*I, D, FC);
return std::unique_ptr<Info>{std::move(I)};
}
void ContainerSizeEmptyCheck::registerMatchers(MatchFinder *Finder) {
// Only register the matchers for C++; the functionality currently does not
// provide any benefit to other languages, despite being benign.
if (!getLangOpts().CPlusPlus)
return;
const auto ValidContainer = cxxRecordDecl(isSameOrDerivedFrom(
namedDecl(
has(cxxMethodDecl(
isConst(), parameterCountIs(0), isPublic(), hasName("size"),
returns(qualType(isInteger(), unless(booleanType()))))
.bind("size")),
has(cxxMethodDecl(isConst(), parameterCountIs(0), isPublic(),
hasName("empty"), returns(booleanType()))
.bind("empty")))
.bind("container")));
const auto WrongUse = anyOf(
hasParent(binaryOperator(
matchers::isComparisonOperator(),
hasEitherOperand(ignoringImpCasts(anyOf(
integerLiteral(equals(1)), integerLiteral(equals(0))))))
.bind("SizeBinaryOp")),
hasParent(implicitCastExpr(
hasImplicitDestinationType(booleanType()),
anyOf(
hasParent(unaryOperator(hasOperatorName("!")).bind("NegOnSize")),
anything()))),
hasParent(explicitCastExpr(hasDestinationType(booleanType()))));
Finder->addMatcher(
cxxMemberCallExpr(on(expr(anyOf(hasType(ValidContainer),
hasType(pointsTo(ValidContainer)),
hasType(references(ValidContainer))))
.bind("STLObject")),
callee(cxxMethodDecl(hasName("size"))), WrongUse)
.bind("SizeCallExpr"),
this);
}
std::unique_ptr<Info> emitInfo(const RecordDecl *D, const FullComment *FC,
int LineNumber, llvm::StringRef File,
bool PublicOnly) {
if (PublicOnly && !isPublic(D->getAccess(), D->getLinkageInternal()))
return nullptr;
auto I = llvm::make_unique<RecordInfo>();
populateSymbolInfo(*I, D, FC, LineNumber, File);
I->TagType = D->getTagKind();
parseFields(*I, D, PublicOnly);
if (const auto *C = dyn_cast<CXXRecordDecl>(D))
parseBases(*I, C);
return std::unique_ptr<Info>{std::move(I)};
}
int UtlCryptoKeyRsa::decrypt(const unsigned char* pSrc,
int srcLen,
unsigned char* pDest,
int* pDestLen) const
{
if (isPrivate())
return decryptPrivate(pSrc, srcLen, pDest, pDestLen);
else if (isPublic())
return decryptPublic(pSrc, srcLen, pDest, pDestLen);
if (pDestLen)
*pDestLen = 0;
return 0; // TODO: Set lastError?
}
void print_access(u2 flags) {
if(isPublic(flags))
printf("public ");
if(isPrivate(flags))
printf("private ");
if(isProtected(flags))
printf("protected ");
if(isFinal(flags))
printf("final ");
if(isAbstract(flags))
printf("abstract ");
if(isStatic(flags))
printf("static ");
}
void SizeofContainerCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(
expr(unless(isInTemplateInstantiation()),
expr(sizeOfExpr(has(ignoringParenImpCasts(
expr(hasType(hasCanonicalType(hasDeclaration(cxxRecordDecl(
matchesName("^(::std::|::string)"),
unless(matchesName("^::std::(bitset|array)$")),
hasMethod(cxxMethodDecl(hasName("size"), isPublic(),
isConst())))))))))))
.bind("sizeof"),
// Ignore ARRAYSIZE(<array of containers>) pattern.
unless(hasAncestor(binaryOperator(
anyOf(hasOperatorName("/"), hasOperatorName("%")),
hasLHS(ignoringParenCasts(sizeOfExpr(expr()))),
hasRHS(ignoringParenCasts(equalsBoundNode("sizeof"))))))),
this);
}
std::unique_ptr<Info> emitInfo(const FunctionDecl *D, const FullComment *FC,
int LineNumber, llvm::StringRef File,
bool PublicOnly) {
if (PublicOnly && !isPublic(D->getAccess(), D->getLinkageInternal()))
return nullptr;
FunctionInfo Func;
populateFunctionInfo(Func, D, FC, LineNumber, File);
Func.Access = clang::AccessSpecifier::AS_none;
// Wrap in enclosing scope
auto I = llvm::make_unique<NamespaceInfo>();
if (!Func.Namespace.empty())
I->USR = Func.Namespace[0].USR;
else
I->USR = SymbolID();
I->ChildFunctions.emplace_back(std::move(Func));
return std::unique_ptr<Info>{std::move(I)};
}
void LLParcel::clearSale()
{
mSaleTimerExpires.setTimerExpirySec(0.0);
mSaleTimerExpires.stop();
if(isPublic())
{
mStatus = OS_NONE;
}
else
{
mStatus = OS_LEASED;
}
mAuthBuyerID.setNull();
setForSale(FALSE);
setAuctionID(0);
setPreviousOwnerID(LLUUID::null);
setPreviouslyGroupOwned(FALSE);
setSellWithObjects(FALSE);
}
std::unique_ptr<Info> emitInfo(const CXXMethodDecl *D, const FullComment *FC,
int LineNumber, llvm::StringRef File,
bool PublicOnly) {
if (PublicOnly && !isPublic(D->getAccess(), D->getLinkageInternal()))
return nullptr;
FunctionInfo Func;
populateFunctionInfo(Func, D, FC, LineNumber, File);
Func.IsMethod = true;
SymbolID ParentUSR = getUSRForDecl(D->getParent());
Func.Parent = Reference{ParentUSR, D->getParent()->getNameAsString(),
InfoType::IT_record};
Func.Access = D->getAccess();
// Wrap in enclosing scope
auto I = llvm::make_unique<RecordInfo>();
I->USR = ParentUSR;
I->ChildFunctions.emplace_back(std::move(Func));
return std::unique_ptr<Info>{std::move(I)};
}
static void parseFields(RecordInfo &I, const RecordDecl *D, bool PublicOnly) {
for (const FieldDecl *F : D->fields()) {
if (PublicOnly && !isPublic(F->getAccessUnsafe(), F->getLinkageInternal()))
continue;
if (const auto *T = getDeclForType(F->getTypeSourceInfo()->getType())) {
// Use getAccessUnsafe so that we just get the default AS_none if it's not
// valid, as opposed to an assert.
if (const auto *N = dyn_cast<EnumDecl>(T)) {
I.Members.emplace_back(getUSRForDecl(T), N->getNameAsString(),
InfoType::IT_enum, F->getNameAsString(),
N->getAccessUnsafe());
continue;
} else if (const auto *N = dyn_cast<RecordDecl>(T)) {
I.Members.emplace_back(getUSRForDecl(T), N->getNameAsString(),
InfoType::IT_record, F->getNameAsString(),
N->getAccessUnsafe());
continue;
}
}
I.Members.emplace_back(F->getTypeSourceInfo()->getType().getAsString(),
F->getNameAsString(), F->getAccessUnsafe());
}
}
std::unique_ptr<Info> emitInfo(const EnumDecl *D, const FullComment *FC,
int LineNumber, llvm::StringRef File,
bool PublicOnly) {
if (PublicOnly && !isPublic(D->getAccess(), D->getLinkageInternal()))
return nullptr;
EnumInfo Enum;
populateSymbolInfo(Enum, D, FC, LineNumber, File);
Enum.Scoped = D->isScoped();
parseEnumerators(Enum, D);
// Wrap in enclosing scope
if (!Enum.Namespace.empty()) {
switch (Enum.Namespace[0].RefType) {
case InfoType::IT_namespace: {
auto I = llvm::make_unique<NamespaceInfo>();
I->USR = Enum.Namespace[0].USR;
I->ChildEnums.emplace_back(std::move(Enum));
return std::unique_ptr<Info>{std::move(I)};
}
case InfoType::IT_record: {
auto I = llvm::make_unique<RecordInfo>();
I->USR = Enum.Namespace[0].USR;
I->ChildEnums.emplace_back(std::move(Enum));
return std::unique_ptr<Info>{std::move(I)};
}
default:
break;
}
}
// Put in global namespace
auto I = llvm::make_unique<NamespaceInfo>();
I->USR = SymbolID();
I->ChildEnums.emplace_back(std::move(Enum));
return std::unique_ptr<Info>{std::move(I)};
}
void CibIdMgr::assignIds(CibCompound* compound,
const CibHelper& helper,
const CibParams& cibParams,
bool forGenericProxy)
{
// if (!compound->isShared())
// return;
if (compound->isTemplated())
{
compound->forEachTemplateInstance(
[&](CibCompound* ins) { this->assignIds(ins, helper, cibParams, forGenericProxy); });
return;
}
if (compound->name().empty())
return;
// Dummy loop
do
{
if (!forGenericProxy && !compound->needsBridging() && !compound->isShared())
break;
if (forGenericProxy && (!compound->needsGenericProxyDefinition() || compound->getAllVirtualMethods().empty()))
break;
const auto className = forGenericProxy ? compound->longName() + "::__zz_cib_GenericProxy" : compound->longName();
CibIdData* cibIdData = nullptr;
auto itr = cibIdTable_.find(className);
if (itr == cibIdTable_.end())
{
auto clsId = nextClassId_++;
if (compound->isTemplateInstance())
compound->setNsName("__zz_cib_Class" + std::to_string(clsId));
else if (isCppFile(compound))
compound->setNsName(cibParams.globalNsName());
const auto classNsName =
forGenericProxy ? compound->fullNsName() + "::__zz_cib_GenericProxy" : compound->fullNsName();
cibIdData = addClass(className, classNsName, clsId);
}
else
{
cibIdData = &itr->second;
if (compound->isNsNameEmpty())
{
if (isCppFile(compound))
compound->setNsName(cibParams.globalNsName());
else if (compound->isTemplateInstance())
compound->setNsName(cibIdData->getFullNsName());
}
}
const auto& methods = forGenericProxy ? compound->getAllVirtualMethods() : compound->getNeedsBridgingMethods();
auto addMethod = [&](const CibFunctionHelper& func) {
auto&& sig = func.signature(helper);
if (!cibIdData->hasMethod(func.signature(helper)))
cibIdData->addMethod(sig, func.procName());
};
for (auto& func : methods)
addMethod(func);
if (forGenericProxy)
addMethod(compound->dtor());
if (!forGenericProxy)
{
compound->forEachAncestor(CppAccessType::kPublic, [compound, &cibIdData, &cibParams](const CibCompound* parent) {
if (parent->isShared() || !parent->isEmpty())
{
auto castMethodName = compound->castToBaseName(parent, cibParams);
if (!cibIdData->hasMethod(castMethodName))
cibIdData->addMethod(castMethodName, castMethodName);
}
return false;
});
if (compound->isFacadeLike())
{
if (!cibIdData->hasMethod("__zz_cib_get_class_id"))
cibIdData->addMethod("__zz_cib_get_class_id", "__zz_cib_get_class_id");
}
if (compound->needsGenericProxyDefinition())
{
if (!cibIdData->hasMethod("__zz_cib_release_proxy"))
cibIdData->addMethod("__zz_cib_release_proxy", "__zz_cib_release_proxy");
}
}
} while (false);
for (auto& mem : compound->members())
{
if (isPublic(mem) && isNamespaceLike(mem))
{
assignIds(CibCompoundEPtr(mem), helper, cibParams, forGenericProxy);
}
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void FilterMaker::updateSourceList()
{
QString filterName = this->filterName->text();
QString pluginDir = this->pluginDir->text();
QString pluginName = QFileInfo(pluginDir).baseName();
QString sourceListPath = pluginDir + "/" + pluginName + "Filters/SourceList.cmake";
sourceListPath = QDir::toNativeSeparators(sourceListPath);
QFile source(sourceListPath);
source.open(QFile::ReadOnly);
QString contents = source.readAll();
source.close();
QString namespaceStr = createNamespaceString();
// Check to make sure we don't already have this filter in the namespace
if (contents.contains(namespaceStr) == true)
{
return;
}
bool keepGoing = false;
QStringList outLines;
QStringList list = contents.split(QRegExp("\\n"));
QStringListIterator sourceLines(list);
QString searchString = "set(_PublicFilters";
if (!isPublic())
{
searchString = "set(_PrivateFilters";
}
while (sourceLines.hasNext())
{
QString line = sourceLines.next();
if (line.contains(searchString) && !keepGoing)
{
outLines.push_back(line);
while (sourceLines.hasNext())
{
line = sourceLines.next();
if (line.contains(filterName) && !keepGoing)
{
outLines.push_back(line);
keepGoing = true;
}
else if (line.contains(")"))
{
// We never found the filter name so lets add it back in
if (!keepGoing)
{
outLines.push_back(" " + filterName);
}
outLines.push_back(line);
keepGoing = true;
break;
}
else
{
outLines.push_back(line);
}
}
}
else
{
outLines.push_back(line);
}
}
source.remove();
if (source.open(QIODevice::WriteOnly))
{
source.write(outLines.join("\n").toLatin1().data());
source.close();
}
}
void PortMapping::run(void)
{
std::unique_lock<std::mutex> lock(mMutex);
if(!mEnabled) return;
Set<Address> addresses;
Network::Instance->overlay()->getAddresses(addresses);
bool hasIpv4 = false;
bool hasPublicIpv4 = false;
auto it = addresses.begin();
while(it != addresses.end())
{
hasIpv4|= it->isIpv4();
hasPublicIpv4|= (it->isIpv4() && it->isPublic());
++it;
}
if(!hasIpv4 || hasPublicIpv4)
{
mProtocol.reset();
return;
}
LogDebug("PortMapping", "Potential NAT detected");
if(mProtocol)
{
bool success = false;
try {
if(mProtocol->check(mExternalHost) && !mExternalHost.empty())
success = true;
}
catch(const Exception &e)
{
LogWarn("PortMapping", e.what());
}
if(!success) mProtocol.reset();
}
if(!mProtocol)
{
LogDebug("PortMapping", "Probing protocols...");
mExternalHost.clear();
for(int i=0; i<2; ++i) // TODO: FreeboxAPI is disabled for now
{
try {
switch(i)
{
case 0: mProtocol = std::make_shared<NatPMP>(); break;
case 1: mProtocol = std::make_shared<UPnP>(); break;
case 2: mProtocol = std::make_shared<FreeboxAPI>(); break;
}
if(mProtocol->check(mExternalHost) && !mExternalHost.empty())
break;
}
catch(const Exception &e)
{
LogWarn("PortMapping", e.what());
}
mProtocol = NULL;
}
if(mProtocol) LogInfo("PortMapping", "Port mapping is available, external address is " + mExternalHost);
else LogInfo("PortMapping", "Port mapping is not available");
}
if(mProtocol)
{
for(auto it = mMap.begin(); it != mMap.end(); ++it)
{
if(!it->second.external) it->second.external = it->second.suggested;
if(!mProtocol->add(it->first.protocol, it->first.port, it->second.external))
LogWarn("PortMapping", String("Mapping failed for ") + (it->first.protocol == TCP ? "TCP" : "UDP") + " port " + String::number(it->second.suggested));
}
}
}
