contrib/llvm/tools/clang/lib/StaticAnalyzer/Checkers/StreamChecker.cpp

   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/BugReporter/BugType.h"
  16 #include "clang/StaticAnalyzer/Core/Checker.h"
  17 #include "clang/StaticAnalyzer/Core/CheckerManager.h"
  18 #include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.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   mutable IdentifierInfo *II_fopen, *II_tmpfile, *II_fclose, *II_fread,
  62                  *II_fwrite,
  63                  *II_fseek, *II_ftell, *II_rewind, *II_fgetpos, *II_fsetpos,
  64                  *II_clearerr, *II_feof, *II_ferror, *II_fileno;
  65   mutable std::unique_ptr<BuiltinBug> BT_nullfp, BT_illegalwhence,
  66       BT_doubleclose, BT_ResourceLeak;
  67
  68 public:
  69   StreamChecker()
  70     : II_fopen(nullptr), II_tmpfile(nullptr), II_fclose(nullptr),
  71       II_fread(nullptr), II_fwrite(nullptr), II_fseek(nullptr),
  72       II_ftell(nullptr), II_rewind(nullptr), II_fgetpos(nullptr),
  73       II_fsetpos(nullptr), II_clearerr(nullptr), II_feof(nullptr),
  74       II_ferror(nullptr), II_fileno(nullptr) {}
  75
  76   bool evalCall(const CallExpr *CE, CheckerContext &C) const;
  77   void checkDeadSymbols(SymbolReaper &SymReaper, CheckerContext &C) const;
  78
  79 private:
  80   void Fopen(CheckerContext &C, const CallExpr *CE) const;
  81   void Tmpfile(CheckerContext &C, const CallExpr *CE) const;
  82   void Fclose(CheckerContext &C, const CallExpr *CE) const;
  83   void Fread(CheckerContext &C, const CallExpr *CE) const;
  84   void Fwrite(CheckerContext &C, const CallExpr *CE) const;
  85   void Fseek(CheckerContext &C, const CallExpr *CE) const;
  86   void Ftell(CheckerContext &C, const CallExpr *CE) const;
  87   void Rewind(CheckerContext &C, const CallExpr *CE) const;
  88   void Fgetpos(CheckerContext &C, const CallExpr *CE) const;
  89   void Fsetpos(CheckerContext &C, const CallExpr *CE) const;
  90   void Clearerr(CheckerContext &C, const CallExpr *CE) const;
  91   void Feof(CheckerContext &C, const CallExpr *CE) const;
  92   void Ferror(CheckerContext &C, const CallExpr *CE) const;
  93   void Fileno(CheckerContext &C, const CallExpr *CE) const;
  94
  95   void OpenFileAux(CheckerContext &C, const CallExpr *CE) const;
  96
  97   ProgramStateRef CheckNullStream(SVal SV, ProgramStateRef state,
  98                                  CheckerContext &C) const;
  99   ProgramStateRef CheckDoubleClose(const CallExpr *CE, ProgramStateRef state,
 100                                  CheckerContext &C) const;
 101 };
 102
 103 } // end anonymous namespace
 104
 105 REGISTER_MAP_WITH_PROGRAMSTATE(StreamMap, SymbolRef, StreamState)
 106
 107
 108 bool StreamChecker::evalCall(const CallExpr *CE, CheckerContext &C) const {
 109   const FunctionDecl *FD = C.getCalleeDecl(CE);
 110   if (!FD || FD->getKind() != Decl::Function)
 111     return false;
 112
 113   ASTContext &Ctx = C.getASTContext();
 114   if (!II_fopen)
 115     II_fopen = &Ctx.Idents.get("fopen");
 116   if (!II_tmpfile)
 117     II_tmpfile = &Ctx.Idents.get("tmpfile");
 118   if (!II_fclose)
 119     II_fclose = &Ctx.Idents.get("fclose");
 120   if (!II_fread)
 121     II_fread = &Ctx.Idents.get("fread");
 122   if (!II_fwrite)
 123     II_fwrite = &Ctx.Idents.get("fwrite");
 124   if (!II_fseek)
 125     II_fseek = &Ctx.Idents.get("fseek");
 126   if (!II_ftell)
 127     II_ftell = &Ctx.Idents.get("ftell");
 128   if (!II_rewind)
 129     II_rewind = &Ctx.Idents.get("rewind");
 130   if (!II_fgetpos)
 131     II_fgetpos = &Ctx.Idents.get("fgetpos");
 132   if (!II_fsetpos)
 133     II_fsetpos = &Ctx.Idents.get("fsetpos");
 134   if (!II_clearerr)
 135     II_clearerr = &Ctx.Idents.get("clearerr");
 136   if (!II_feof)
 137     II_feof = &Ctx.Idents.get("feof");
 138   if (!II_ferror)
 139     II_ferror = &Ctx.Idents.get("ferror");
 140   if (!II_fileno)
 141     II_fileno = &Ctx.Idents.get("fileno");
 142
 143   if (FD->getIdentifier() == II_fopen) {
 144     Fopen(C, CE);
 145     return true;
 146   }
 147   if (FD->getIdentifier() == II_tmpfile) {
 148     Tmpfile(C, CE);
 149     return true;
 150   }
 151   if (FD->getIdentifier() == II_fclose) {
 152     Fclose(C, CE);
 153     return true;
 154   }
 155   if (FD->getIdentifier() == II_fread) {
 156     Fread(C, CE);
 157     return true;
 158   }
 159   if (FD->getIdentifier() == II_fwrite) {
 160     Fwrite(C, CE);
 161     return true;
 162   }
 163   if (FD->getIdentifier() == II_fseek) {
 164     Fseek(C, CE);
 165     return true;
 166   }
 167   if (FD->getIdentifier() == II_ftell) {
 168     Ftell(C, CE);
 169     return true;
 170   }
 171   if (FD->getIdentifier() == II_rewind) {
 172     Rewind(C, CE);
 173     return true;
 174   }
 175   if (FD->getIdentifier() == II_fgetpos) {
 176     Fgetpos(C, CE);
 177     return true;
 178   }
 179   if (FD->getIdentifier() == II_fsetpos) {
 180     Fsetpos(C, CE);
 181     return true;
 182   }
 183   if (FD->getIdentifier() == II_clearerr) {
 184     Clearerr(C, CE);
 185     return true;
 186   }
 187   if (FD->getIdentifier() == II_feof) {
 188     Feof(C, CE);
 189     return true;
 190   }
 191   if (FD->getIdentifier() == II_ferror) {
 192     Ferror(C, CE);
 193     return true;
 194   }
 195   if (FD->getIdentifier() == II_fileno) {
 196     Fileno(C, CE);
 197     return true;
 198   }
 199
 200   return false;
 201 }
 202
 203 void StreamChecker::Fopen(CheckerContext &C, const CallExpr *CE) const {
 204   OpenFileAux(C, CE);
 205 }
 206
 207 void StreamChecker::Tmpfile(CheckerContext &C, const CallExpr *CE) const {
 208   OpenFileAux(C, CE);
 209 }
 210
 211 void StreamChecker::OpenFileAux(CheckerContext &C, const CallExpr *CE) const {
 212   ProgramStateRef state = C.getState();
 213   SValBuilder &svalBuilder = C.getSValBuilder();
 214   const LocationContext *LCtx = C.getPredecessor()->getLocationContext();
 215   DefinedSVal RetVal = svalBuilder.conjureSymbolVal(nullptr, CE, LCtx,
 216                                                     C.blockCount())
 217       .castAs<DefinedSVal>();
 218   state = state->BindExpr(CE, C.getLocationContext(), RetVal);
 219
 220   ConstraintManager &CM = C.getConstraintManager();
 221   // Bifurcate the state into two: one with a valid FILE* pointer, the other
 222   // with a NULL.
 223   ProgramStateRef stateNotNull, stateNull;
 224   std::tie(stateNotNull, stateNull) = CM.assumeDual(state, RetVal);
 225
 226   if (SymbolRef Sym = RetVal.getAsSymbol()) {
 227     // if RetVal is not NULL, set the symbol's state to Opened.
 228     stateNotNull =
 229       stateNotNull->set<StreamMap>(Sym,StreamState::getOpened(CE));
 230     stateNull =
 231       stateNull->set<StreamMap>(Sym, StreamState::getOpenFailed(CE));
 232
 233     C.addTransition(stateNotNull);
 234     C.addTransition(stateNull);
 235   }
 236 }
 237
 238 void StreamChecker::Fclose(CheckerContext &C, const CallExpr *CE) const {
 239   ProgramStateRef state = CheckDoubleClose(CE, C.getState(), C);
 240   if (state)
 241     C.addTransition(state);
 242 }
 243
 244 void StreamChecker::Fread(CheckerContext &C, const CallExpr *CE) const {
 245   ProgramStateRef state = C.getState();
 246   if (!CheckNullStream(state->getSVal(CE->getArg(3), C.getLocationContext()),
 247                        state, C))
 248     return;
 249 }
 250
 251 void StreamChecker::Fwrite(CheckerContext &C, const CallExpr *CE) const {
 252   ProgramStateRef state = C.getState();
 253   if (!CheckNullStream(state->getSVal(CE->getArg(3), C.getLocationContext()),
 254                        state, C))
 255     return;
 256 }
 257
 258 void StreamChecker::Fseek(CheckerContext &C, const CallExpr *CE) const {
 259   ProgramStateRef state = C.getState();
 260   if (!(state = CheckNullStream(state->getSVal(CE->getArg(0),
 261                                                C.getLocationContext()), state, C)))
 262     return;
 263   // Check the legality of the 'whence' argument of 'fseek'.
 264   SVal Whence = state->getSVal(CE->getArg(2), C.getLocationContext());
 265   Optional<nonloc::ConcreteInt> CI = Whence.getAs<nonloc::ConcreteInt>();
 266
 267   if (!CI)
 268     return;
 269
 270   int64_t x = CI->getValue().getSExtValue();
 271   if (x >= 0 && x <= 2)
 272     return;
 273
 274   if (ExplodedNode *N = C.addTransition(state)) {
 275     if (!BT_illegalwhence)
 276       BT_illegalwhence.reset(
 277           new BuiltinBug(this, "Illegal whence argument",
 278                          "The whence argument to fseek() should be "
 279                          "SEEK_SET, SEEK_END, or SEEK_CUR."));
 280     BugReport *R = new BugReport(*BT_illegalwhence,
 281                                  BT_illegalwhence->getDescription(), N);
 282     C.emitReport(R);
 283   }
 284 }
 285
 286 void StreamChecker::Ftell(CheckerContext &C, const CallExpr *CE) const {
 287   ProgramStateRef state = C.getState();
 288   if (!CheckNullStream(state->getSVal(CE->getArg(0), C.getLocationContext()),
 289                        state, C))
 290     return;
 291 }
 292
 293 void StreamChecker::Rewind(CheckerContext &C, const CallExpr *CE) const {
 294   ProgramStateRef state = C.getState();
 295   if (!CheckNullStream(state->getSVal(CE->getArg(0), C.getLocationContext()),
 296                        state, C))
 297     return;
 298 }
 299
 300 void StreamChecker::Fgetpos(CheckerContext &C, const CallExpr *CE) const {
 301   ProgramStateRef state = C.getState();
 302   if (!CheckNullStream(state->getSVal(CE->getArg(0), C.getLocationContext()),
 303                        state, C))
 304     return;
 305 }
 306
 307 void StreamChecker::Fsetpos(CheckerContext &C, const CallExpr *CE) const {
 308   ProgramStateRef state = C.getState();
 309   if (!CheckNullStream(state->getSVal(CE->getArg(0), C.getLocationContext()),
 310                        state, C))
 311     return;
 312 }
 313
 314 void StreamChecker::Clearerr(CheckerContext &C, const CallExpr *CE) const {
 315   ProgramStateRef state = C.getState();
 316   if (!CheckNullStream(state->getSVal(CE->getArg(0), C.getLocationContext()),
 317                        state, C))
 318     return;
 319 }
 320
 321 void StreamChecker::Feof(CheckerContext &C, const CallExpr *CE) const {
 322   ProgramStateRef state = C.getState();
 323   if (!CheckNullStream(state->getSVal(CE->getArg(0), C.getLocationContext()),
 324                        state, C))
 325     return;
 326 }
 327
 328 void StreamChecker::Ferror(CheckerContext &C, const CallExpr *CE) const {
 329   ProgramStateRef state = C.getState();
 330   if (!CheckNullStream(state->getSVal(CE->getArg(0), C.getLocationContext()),
 331                        state, C))
 332     return;
 333 }
 334
 335 void StreamChecker::Fileno(CheckerContext &C, const CallExpr *CE) const {
 336   ProgramStateRef state = C.getState();
 337   if (!CheckNullStream(state->getSVal(CE->getArg(0), C.getLocationContext()),
 338                        state, C))
 339     return;
 340 }
 341
 342 ProgramStateRef StreamChecker::CheckNullStream(SVal SV, ProgramStateRef state,
 343                                     CheckerContext &C) const {
 344   Optional<DefinedSVal> DV = SV.getAs<DefinedSVal>();
 345   if (!DV)
 346     return nullptr;
 347
 348   ConstraintManager &CM = C.getConstraintManager();
 349   ProgramStateRef stateNotNull, stateNull;
 350   std::tie(stateNotNull, stateNull) = CM.assumeDual(state, *DV);
 351
 352   if (!stateNotNull && stateNull) {
 353     if (ExplodedNode *N = C.generateSink(stateNull)) {
 354       if (!BT_nullfp)
 355         BT_nullfp.reset(new BuiltinBug(this, "NULL stream pointer",
 356                                        "Stream pointer might be NULL."));
 357       BugReport *R =new BugReport(*BT_nullfp, BT_nullfp->getDescription(), N);
 358       C.emitReport(R);
 359     }
 360     return nullptr;
 361   }
 362   return stateNotNull;
 363 }
 364
 365 ProgramStateRef StreamChecker::CheckDoubleClose(const CallExpr *CE,
 366                                                ProgramStateRef state,
 367                                                CheckerContext &C) const {
 368   SymbolRef Sym =
 369     state->getSVal(CE->getArg(0), C.getLocationContext()).getAsSymbol();
 370   if (!Sym)
 371     return state;
 372
 373   const StreamState *SS = state->get<StreamMap>(Sym);
 374
 375   // If the file stream is not tracked, return.
 376   if (!SS)
 377     return state;
 378
 379   // Check: Double close a File Descriptor could cause undefined behaviour.
 380   // Conforming to man-pages
 381   if (SS->isClosed()) {
 382     ExplodedNode *N = C.generateSink();
 383     if (N) {
 384       if (!BT_doubleclose)
 385         BT_doubleclose.reset(new BuiltinBug(
 386             this, "Double fclose", "Try to close a file Descriptor already"
 387                                    " closed. Cause undefined behaviour."));
 388       BugReport *R = new BugReport(*BT_doubleclose,
 389                                    BT_doubleclose->getDescription(), N);
 390       C.emitReport(R);
 391     }
 392     return nullptr;
 393   }
 394
 395   // Close the File Descriptor.
 396   return state->set<StreamMap>(Sym, StreamState::getClosed(CE));
 397 }
 398
 399 void StreamChecker::checkDeadSymbols(SymbolReaper &SymReaper,
 400                                      CheckerContext &C) const {
 401   // TODO: Clean up the state.
 402   for (SymbolReaper::dead_iterator I = SymReaper.dead_begin(),
 403          E = SymReaper.dead_end(); I != E; ++I) {
 404     SymbolRef Sym = *I;
 405     ProgramStateRef state = C.getState();
 406     const StreamState *SS = state->get<StreamMap>(Sym);
 407     if (!SS)
 408       continue;
 409
 410     if (SS->isOpened()) {
 411       ExplodedNode *N = C.generateSink();
 412       if (N) {
 413         if (!BT_ResourceLeak)
 414           BT_ResourceLeak.reset(new BuiltinBug(
 415               this, "Resource Leak",
 416               "Opened File never closed. Potential Resource leak."));
 417         BugReport *R = new BugReport(*BT_ResourceLeak,
 418                                      BT_ResourceLeak->getDescription(), N);
 419         C.emitReport(R);
 420       }
 421     }
 422   }
 423 }
 424
 425 void ento::registerStreamChecker(CheckerManager &mgr) {
 426   mgr.registerChecker<StreamChecker>();
 427 }