1 //===-- StreamChecker.cpp -----------------------------------------*- C++ -*--// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file defines checkers that model and check stream handling functions. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "ClangSACheckers.h" 15 #include "clang/StaticAnalyzer/Core/Checker.h" 16 #include "clang/StaticAnalyzer/Core/CheckerManager.h" 17 #include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h" 18 #include "clang/StaticAnalyzer/Core/BugReporter/BugType.h" 19 #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h" 20 #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramStateTrait.h" 21 #include "clang/StaticAnalyzer/Core/PathSensitive/SymbolManager.h" 22 #include "llvm/ADT/ImmutableMap.h" 23 24 using namespace clang; 25 using namespace ento; 26 27 namespace { 28 29 struct StreamState { 30 enum Kind { Opened, Closed, OpenFailed, Escaped } K; 31 const Stmt *S; 32 33 StreamState(Kind k, const Stmt *s) : K(k), S(s) {} 34 35 bool isOpened() const { return K == Opened; } 36 bool isClosed() const { return K == Closed; } 37 //bool isOpenFailed() const { return K == OpenFailed; } 38 //bool isEscaped() const { return K == Escaped; } 39 40 bool operator==(const StreamState &X) const { 41 return K == X.K && S == X.S; 42 } 43 44 static StreamState getOpened(const Stmt *s) { return StreamState(Opened, s); } 45 static StreamState getClosed(const Stmt *s) { return StreamState(Closed, s); } 46 static StreamState getOpenFailed(const Stmt *s) { 47 return StreamState(OpenFailed, s); 48 } 49 static StreamState getEscaped(const Stmt *s) { 50 return StreamState(Escaped, s); 51 } 52 53 void Profile(llvm::FoldingSetNodeID &ID) const { 54 ID.AddInteger(K); 55 ID.AddPointer(S); 56 } 57 }; 58 59 class StreamChecker : public Checker<eval::Call, 60 check::DeadSymbols, 61 check::EndPath, 62 check::PreStmt<ReturnStmt> > { 63 mutable IdentifierInfo *II_fopen, *II_tmpfile, *II_fclose, *II_fread, 64 *II_fwrite, 65 *II_fseek, *II_ftell, *II_rewind, *II_fgetpos, *II_fsetpos, 66 *II_clearerr, *II_feof, *II_ferror, *II_fileno; 67 mutable llvm::OwningPtr<BuiltinBug> BT_nullfp, BT_illegalwhence, 68 BT_doubleclose, BT_ResourceLeak; 69 70 public: 71 StreamChecker() 72 : II_fopen(0), II_tmpfile(0) ,II_fclose(0), II_fread(0), II_fwrite(0), 73 II_fseek(0), II_ftell(0), II_rewind(0), II_fgetpos(0), II_fsetpos(0), 74 II_clearerr(0), II_feof(0), II_ferror(0), II_fileno(0) {} 75 76 bool evalCall(const CallExpr *CE, CheckerContext &C) const; 77 void checkDeadSymbols(SymbolReaper &SymReaper, CheckerContext &C) const; 78 void checkEndPath(CheckerContext &Ctx) const; 79 void checkPreStmt(const ReturnStmt *S, CheckerContext &C) const; 80 81 private: 82 void Fopen(CheckerContext &C, const CallExpr *CE) const; 83 void Tmpfile(CheckerContext &C, const CallExpr *CE) const; 84 void Fclose(CheckerContext &C, const CallExpr *CE) const; 85 void Fread(CheckerContext &C, const CallExpr *CE) const; 86 void Fwrite(CheckerContext &C, const CallExpr *CE) const; 87 void Fseek(CheckerContext &C, const CallExpr *CE) const; 88 void Ftell(CheckerContext &C, const CallExpr *CE) const; 89 void Rewind(CheckerContext &C, const CallExpr *CE) const; 90 void Fgetpos(CheckerContext &C, const CallExpr *CE) const; 91 void Fsetpos(CheckerContext &C, const CallExpr *CE) const; 92 void Clearerr(CheckerContext &C, const CallExpr *CE) const; 93 void Feof(CheckerContext &C, const CallExpr *CE) const; 94 void Ferror(CheckerContext &C, const CallExpr *CE) const; 95 void Fileno(CheckerContext &C, const CallExpr *CE) const; 96 97 void OpenFileAux(CheckerContext &C, const CallExpr *CE) const; 98 99 const ProgramState *CheckNullStream(SVal SV, const ProgramState *state, 100 CheckerContext &C) const; 101 const ProgramState *CheckDoubleClose(const CallExpr *CE, const ProgramState *state, 102 CheckerContext &C) const; 103 }; 104 105 } // end anonymous namespace 106 107 namespace clang { 108 namespace ento { 109 template <> 110 struct ProgramStateTrait<StreamState> 111 : public ProgramStatePartialTrait<llvm::ImmutableMap<SymbolRef, StreamState> > { 112 static void *GDMIndex() { static int x; return &x; } 113 }; 114 } 115 } 116 117 bool StreamChecker::evalCall(const CallExpr *CE, CheckerContext &C) const { 118 const ProgramState *state = C.getState(); 119 const Expr *Callee = CE->getCallee(); 120 SVal L = state->getSVal(Callee); 121 const FunctionDecl *FD = L.getAsFunctionDecl(); 122 if (!FD) 123 return false; 124 125 ASTContext &Ctx = C.getASTContext(); 126 if (!II_fopen) 127 II_fopen = &Ctx.Idents.get("fopen"); 128 if (!II_tmpfile) 129 II_tmpfile = &Ctx.Idents.get("tmpfile"); 130 if (!II_fclose) 131 II_fclose = &Ctx.Idents.get("fclose"); 132 if (!II_fread) 133 II_fread = &Ctx.Idents.get("fread"); 134 if (!II_fwrite) 135 II_fwrite = &Ctx.Idents.get("fwrite"); 136 if (!II_fseek) 137 II_fseek = &Ctx.Idents.get("fseek"); 138 if (!II_ftell) 139 II_ftell = &Ctx.Idents.get("ftell"); 140 if (!II_rewind) 141 II_rewind = &Ctx.Idents.get("rewind"); 142 if (!II_fgetpos) 143 II_fgetpos = &Ctx.Idents.get("fgetpos"); 144 if (!II_fsetpos) 145 II_fsetpos = &Ctx.Idents.get("fsetpos"); 146 if (!II_clearerr) 147 II_clearerr = &Ctx.Idents.get("clearerr"); 148 if (!II_feof) 149 II_feof = &Ctx.Idents.get("feof"); 150 if (!II_ferror) 151 II_ferror = &Ctx.Idents.get("ferror"); 152 if (!II_fileno) 153 II_fileno = &Ctx.Idents.get("fileno"); 154 155 if (FD->getIdentifier() == II_fopen) { 156 Fopen(C, CE); 157 return true; 158 } 159 if (FD->getIdentifier() == II_tmpfile) { 160 Tmpfile(C, CE); 161 return true; 162 } 163 if (FD->getIdentifier() == II_fclose) { 164 Fclose(C, CE); 165 return true; 166 } 167 if (FD->getIdentifier() == II_fread) { 168 Fread(C, CE); 169 return true; 170 } 171 if (FD->getIdentifier() == II_fwrite) { 172 Fwrite(C, CE); 173 return true; 174 } 175 if (FD->getIdentifier() == II_fseek) { 176 Fseek(C, CE); 177 return true; 178 } 179 if (FD->getIdentifier() == II_ftell) { 180 Ftell(C, CE); 181 return true; 182 } 183 if (FD->getIdentifier() == II_rewind) { 184 Rewind(C, CE); 185 return true; 186 } 187 if (FD->getIdentifier() == II_fgetpos) { 188 Fgetpos(C, CE); 189 return true; 190 } 191 if (FD->getIdentifier() == II_fsetpos) { 192 Fsetpos(C, CE); 193 return true; 194 } 195 if (FD->getIdentifier() == II_clearerr) { 196 Clearerr(C, CE); 197 return true; 198 } 199 if (FD->getIdentifier() == II_feof) { 200 Feof(C, CE); 201 return true; 202 } 203 if (FD->getIdentifier() == II_ferror) { 204 Ferror(C, CE); 205 return true; 206 } 207 if (FD->getIdentifier() == II_fileno) { 208 Fileno(C, CE); 209 return true; 210 } 211 212 return false; 213 } 214 215 void StreamChecker::Fopen(CheckerContext &C, const CallExpr *CE) const { 216 OpenFileAux(C, CE); 217 } 218 219 void StreamChecker::Tmpfile(CheckerContext &C, const CallExpr *CE) const { 220 OpenFileAux(C, CE); 221 } 222 223 void StreamChecker::OpenFileAux(CheckerContext &C, const CallExpr *CE) const { 224 const ProgramState *state = C.getState(); 225 unsigned Count = C.getCurrentBlockCount(); 226 SValBuilder &svalBuilder = C.getSValBuilder(); 227 DefinedSVal RetVal = 228 cast<DefinedSVal>(svalBuilder.getConjuredSymbolVal(0, CE, Count)); 229 state = state->BindExpr(CE, RetVal); 230 231 ConstraintManager &CM = C.getConstraintManager(); 232 // Bifurcate the state into two: one with a valid FILE* pointer, the other 233 // with a NULL. 234 const ProgramState *stateNotNull, *stateNull; 235 llvm::tie(stateNotNull, stateNull) = CM.assumeDual(state, RetVal); 236 237 if (SymbolRef Sym = RetVal.getAsSymbol()) { 238 // if RetVal is not NULL, set the symbol's state to Opened. 239 stateNotNull = 240 stateNotNull->set<StreamState>(Sym,StreamState::getOpened(CE)); 241 stateNull = 242 stateNull->set<StreamState>(Sym, StreamState::getOpenFailed(CE)); 243 244 C.generateNode(stateNotNull); 245 C.generateNode(stateNull); 246 } 247 } 248 249 void StreamChecker::Fclose(CheckerContext &C, const CallExpr *CE) const { 250 const ProgramState *state = CheckDoubleClose(CE, C.getState(), C); 251 if (state) 252 C.generateNode(state); 253 } 254 255 void StreamChecker::Fread(CheckerContext &C, const CallExpr *CE) const { 256 const ProgramState *state = C.getState(); 257 if (!CheckNullStream(state->getSVal(CE->getArg(3)), state, C)) 258 return; 259 } 260 261 void StreamChecker::Fwrite(CheckerContext &C, const CallExpr *CE) const { 262 const ProgramState *state = C.getState(); 263 if (!CheckNullStream(state->getSVal(CE->getArg(3)), state, C)) 264 return; 265 } 266 267 void StreamChecker::Fseek(CheckerContext &C, const CallExpr *CE) const { 268 const ProgramState *state = C.getState(); 269 if (!(state = CheckNullStream(state->getSVal(CE->getArg(0)), state, C))) 270 return; 271 // Check the legality of the 'whence' argument of 'fseek'. 272 SVal Whence = state->getSVal(CE->getArg(2)); 273 const nonloc::ConcreteInt *CI = dyn_cast<nonloc::ConcreteInt>(&Whence); 274 275 if (!CI) 276 return; 277 278 int64_t x = CI->getValue().getSExtValue(); 279 if (x >= 0 && x <= 2) 280 return; 281 282 if (ExplodedNode *N = C.generateNode(state)) { 283 if (!BT_illegalwhence) 284 BT_illegalwhence.reset(new BuiltinBug("Illegal whence argument", 285 "The whence argument to fseek() should be " 286 "SEEK_SET, SEEK_END, or SEEK_CUR.")); 287 BugReport *R = new BugReport(*BT_illegalwhence, 288 BT_illegalwhence->getDescription(), N); 289 C.EmitReport(R); 290 } 291 } 292 293 void StreamChecker::Ftell(CheckerContext &C, const CallExpr *CE) const { 294 const ProgramState *state = C.getState(); 295 if (!CheckNullStream(state->getSVal(CE->getArg(0)), state, C)) 296 return; 297 } 298 299 void StreamChecker::Rewind(CheckerContext &C, const CallExpr *CE) const { 300 const ProgramState *state = C.getState(); 301 if (!CheckNullStream(state->getSVal(CE->getArg(0)), state, C)) 302 return; 303 } 304 305 void StreamChecker::Fgetpos(CheckerContext &C, const CallExpr *CE) const { 306 const ProgramState *state = C.getState(); 307 if (!CheckNullStream(state->getSVal(CE->getArg(0)), state, C)) 308 return; 309 } 310 311 void StreamChecker::Fsetpos(CheckerContext &C, const CallExpr *CE) const { 312 const ProgramState *state = C.getState(); 313 if (!CheckNullStream(state->getSVal(CE->getArg(0)), state, C)) 314 return; 315 } 316 317 void StreamChecker::Clearerr(CheckerContext &C, const CallExpr *CE) const { 318 const ProgramState *state = C.getState(); 319 if (!CheckNullStream(state->getSVal(CE->getArg(0)), state, C)) 320 return; 321 } 322 323 void StreamChecker::Feof(CheckerContext &C, const CallExpr *CE) const { 324 const ProgramState *state = C.getState(); 325 if (!CheckNullStream(state->getSVal(CE->getArg(0)), state, C)) 326 return; 327 } 328 329 void StreamChecker::Ferror(CheckerContext &C, const CallExpr *CE) const { 330 const ProgramState *state = C.getState(); 331 if (!CheckNullStream(state->getSVal(CE->getArg(0)), state, C)) 332 return; 333 } 334 335 void StreamChecker::Fileno(CheckerContext &C, const CallExpr *CE) const { 336 const ProgramState *state = C.getState(); 337 if (!CheckNullStream(state->getSVal(CE->getArg(0)), state, C)) 338 return; 339 } 340 341 const ProgramState *StreamChecker::CheckNullStream(SVal SV, const ProgramState *state, 342 CheckerContext &C) const { 343 const DefinedSVal *DV = dyn_cast<DefinedSVal>(&SV); 344 if (!DV) 345 return 0; 346 347 ConstraintManager &CM = C.getConstraintManager(); 348 const ProgramState *stateNotNull, *stateNull; 349 llvm::tie(stateNotNull, stateNull) = CM.assumeDual(state, *DV); 350 351 if (!stateNotNull && stateNull) { 352 if (ExplodedNode *N = C.generateSink(stateNull)) { 353 if (!BT_nullfp) 354 BT_nullfp.reset(new BuiltinBug("NULL stream pointer", 355 "Stream pointer might be NULL.")); 356 BugReport *R =new BugReport(*BT_nullfp, BT_nullfp->getDescription(), N); 357 C.EmitReport(R); 358 } 359 return 0; 360 } 361 return stateNotNull; 362 } 363 364 const ProgramState *StreamChecker::CheckDoubleClose(const CallExpr *CE, 365 const ProgramState *state, 366 CheckerContext &C) const { 367 SymbolRef Sym = state->getSVal(CE->getArg(0)).getAsSymbol(); 368 if (!Sym) 369 return state; 370 371 const StreamState *SS = state->get<StreamState>(Sym); 372 373 // If the file stream is not tracked, return. 374 if (!SS) 375 return state; 376 377 // Check: Double close a File Descriptor could cause undefined behaviour. 378 // Conforming to man-pages 379 if (SS->isClosed()) { 380 ExplodedNode *N = C.generateSink(); 381 if (N) { 382 if (!BT_doubleclose) 383 BT_doubleclose.reset(new BuiltinBug("Double fclose", 384 "Try to close a file Descriptor already" 385 " closed. Cause undefined behaviour.")); 386 BugReport *R = new BugReport(*BT_doubleclose, 387 BT_doubleclose->getDescription(), N); 388 C.EmitReport(R); 389 } 390 return NULL; 391 } 392 393 // Close the File Descriptor. 394 return state->set<StreamState>(Sym, StreamState::getClosed(CE)); 395 } 396 397 void StreamChecker::checkDeadSymbols(SymbolReaper &SymReaper, 398 CheckerContext &C) const { 399 for (SymbolReaper::dead_iterator I = SymReaper.dead_begin(), 400 E = SymReaper.dead_end(); I != E; ++I) { 401 SymbolRef Sym = *I; 402 const ProgramState *state = C.getState(); 403 const StreamState *SS = state->get<StreamState>(Sym); 404 if (!SS) 405 return; 406 407 if (SS->isOpened()) { 408 ExplodedNode *N = C.generateSink(); 409 if (N) { 410 if (!BT_ResourceLeak) 411 BT_ResourceLeak.reset(new BuiltinBug("Resource Leak", 412 "Opened File never closed. Potential Resource leak.")); 413 BugReport *R = new BugReport(*BT_ResourceLeak, 414 BT_ResourceLeak->getDescription(), N); 415 C.EmitReport(R); 416 } 417 } 418 } 419 } 420 421 void StreamChecker::checkEndPath(CheckerContext &Ctx) const { 422 const ProgramState *state = Ctx.getState(); 423 typedef llvm::ImmutableMap<SymbolRef, StreamState> SymMap; 424 SymMap M = state->get<StreamState>(); 425 426 for (SymMap::iterator I = M.begin(), E = M.end(); I != E; ++I) { 427 StreamState SS = I->second; 428 if (SS.isOpened()) { 429 ExplodedNode *N = Ctx.generateNode(state); 430 if (N) { 431 if (!BT_ResourceLeak) 432 BT_ResourceLeak.reset(new BuiltinBug("Resource Leak", 433 "Opened File never closed. Potential Resource leak.")); 434 BugReport *R = new BugReport(*BT_ResourceLeak, 435 BT_ResourceLeak->getDescription(), N); 436 Ctx.EmitReport(R); 437 } 438 } 439 } 440 } 441 442 void StreamChecker::checkPreStmt(const ReturnStmt *S, CheckerContext &C) const { 443 const Expr *RetE = S->getRetValue(); 444 if (!RetE) 445 return; 446 447 const ProgramState *state = C.getState(); 448 SymbolRef Sym = state->getSVal(RetE).getAsSymbol(); 449 450 if (!Sym) 451 return; 452 453 const StreamState *SS = state->get<StreamState>(Sym); 454 if(!SS) 455 return; 456 457 if (SS->isOpened()) 458 state = state->set<StreamState>(Sym, StreamState::getEscaped(S)); 459 460 C.generateNode(state); 461 } 462 463 void ento::registerStreamChecker(CheckerManager &mgr) { 464 mgr.registerChecker<StreamChecker>(); 465 } 466