Home | History | Annotate | Download | only in Checkers 
      1 //===-- SimpleStreamChecker.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 // Defines a checker for proper use of fopen/fclose APIs.
     11 //   - If a file has been closed with fclose, it should not be accessed again.
     12 //   Accessing a closed file results in undefined behavior.
     13 //   - If a file was opened with fopen, it must be closed with fclose before
     14 //   the execution ends. Failing to do so results in a resource leak.
     15 //
     16 //===----------------------------------------------------------------------===//
     17 
     18 #include "ClangSACheckers.h"
     19 #include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
     20 #include "clang/StaticAnalyzer/Core/Checker.h"
     21 #include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
     22 #include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
     23 
     24 using namespace clang;
     25 using namespace ento;
     26 
     27 namespace {
     28 typedef SmallVector<SymbolRef, 2> SymbolVector;
     29 
     30 struct StreamState {
     31 private:
     32   enum Kind { Opened, Closed } K;
     33   StreamState(Kind InK) : K(InK) { }
     34 
     35 public:
     36   bool isOpened() const { return K == Opened; }
     37   bool isClosed() const { return K == Closed; }
     38 
     39   static StreamState getOpened() { return StreamState(Opened); }
     40   static StreamState getClosed() { return StreamState(Closed); }
     41 
     42   bool operator==(const StreamState &X) const {
     43     return K == X.K;
     44   }
     45   void Profile(llvm::FoldingSetNodeID &ID) const {
     46     ID.AddInteger(K);
     47   }
     48 };
     49 
     50 class SimpleStreamChecker : public Checker<check::PostCall,
     51                                            check::PreCall,
     52                                            check::DeadSymbols,
     53                                            check::PointerEscape> {
     54 
     55   mutable IdentifierInfo *IIfopen, *IIfclose;
     56 
     57   OwningPtr<BugType> DoubleCloseBugType;
     58   OwningPtr<BugType> LeakBugType;
     59 
     60   void initIdentifierInfo(ASTContext &Ctx) const;
     61 
     62   void reportDoubleClose(SymbolRef FileDescSym,
     63                          const CallEvent &Call,
     64                          CheckerContext &C) const;
     65 
     66   void reportLeaks(SymbolVector LeakedStreams,
     67                    CheckerContext &C,
     68                    ExplodedNode *ErrNode) const;
     69 
     70   bool guaranteedNotToCloseFile(const CallEvent &Call) const;
     71 
     72 public:
     73   SimpleStreamChecker();
     74 
     75   /// Process fopen.
     76   void checkPostCall(const CallEvent &Call, CheckerContext &C) const;
     77   /// Process fclose.
     78   void checkPreCall(const CallEvent &Call, CheckerContext &C) const;
     79 
     80   void checkDeadSymbols(SymbolReaper &SymReaper, CheckerContext &C) const;
     81 
     82   /// Stop tracking addresses which escape.
     83   ProgramStateRef checkPointerEscape(ProgramStateRef State,
     84                                     const InvalidatedSymbols &Escaped,
     85                                     const CallEvent *Call,
     86                                     PointerEscapeKind Kind) const;
     87 };
     88 
     89 } // end anonymous namespace
     90 
     91 /// The state of the checker is a map from tracked stream symbols to their
     92 /// state. Let's store it in the ProgramState.
     93 REGISTER_MAP_WITH_PROGRAMSTATE(StreamMap, SymbolRef, StreamState)
     94 
     95 namespace {
     96 class StopTrackingCallback : public SymbolVisitor {
     97   ProgramStateRef state;
     98 public:
     99   StopTrackingCallback(ProgramStateRef st) : state(st) {}
    100   ProgramStateRef getState() const { return state; }
    101 
    102   bool VisitSymbol(SymbolRef sym) {
    103     state = state->remove<StreamMap>(sym);
    104     return true;
    105   }
    106 };
    107 } // end anonymous namespace
    108 
    109 
    110 SimpleStreamChecker::SimpleStreamChecker() : IIfopen(0), IIfclose(0) {
    111   // Initialize the bug types.
    112   DoubleCloseBugType.reset(new BugType("Double fclose",
    113                                        "Unix Stream API Error"));
    114 
    115   LeakBugType.reset(new BugType("Resource Leak",
    116                                 "Unix Stream API Error"));
    117   // Sinks are higher importance bugs as well as calls to assert() or exit(0).
    118   LeakBugType->setSuppressOnSink(true);
    119 }
    120 
    121 void SimpleStreamChecker::checkPostCall(const CallEvent &Call,
    122                                         CheckerContext &C) const {
    123   initIdentifierInfo(C.getASTContext());
    124 
    125   if (!Call.isGlobalCFunction())
    126     return;
    127 
    128   if (Call.getCalleeIdentifier() != IIfopen)
    129     return;
    130 
    131   // Get the symbolic value corresponding to the file handle.
    132   SymbolRef FileDesc = Call.getReturnValue().getAsSymbol();
    133   if (!FileDesc)
    134     return;
    135 
    136   // Generate the next transition (an edge in the exploded graph).
    137   ProgramStateRef State = C.getState();
    138   State = State->set<StreamMap>(FileDesc, StreamState::getOpened());
    139   C.addTransition(State);
    140 }
    141 
    142 void SimpleStreamChecker::checkPreCall(const CallEvent &Call,
    143                                        CheckerContext &C) const {
    144   initIdentifierInfo(C.getASTContext());
    145 
    146   if (!Call.isGlobalCFunction())
    147     return;
    148 
    149   if (Call.getCalleeIdentifier() != IIfclose)
    150     return;
    151 
    152   if (Call.getNumArgs() != 1)
    153     return;
    154 
    155   // Get the symbolic value corresponding to the file handle.
    156   SymbolRef FileDesc = Call.getArgSVal(0).getAsSymbol();
    157   if (!FileDesc)
    158     return;
    159 
    160   // Check if the stream has already been closed.
    161   ProgramStateRef State = C.getState();
    162   const StreamState *SS = State->get<StreamMap>(FileDesc);
    163   if (SS && SS->isClosed()) {
    164     reportDoubleClose(FileDesc, Call, C);
    165     return;
    166   }
    167 
    168   // Generate the next transition, in which the stream is closed.
    169   State = State->set<StreamMap>(FileDesc, StreamState::getClosed());
    170   C.addTransition(State);
    171 }
    172 
    173 static bool isLeaked(SymbolRef Sym, const StreamState &SS,
    174                      bool IsSymDead, ProgramStateRef State) {
    175   if (IsSymDead && SS.isOpened()) {
    176     // If a symbol is NULL, assume that fopen failed on this path.
    177     // A symbol should only be considered leaked if it is non-null.
    178     ConstraintManager &CMgr = State->getConstraintManager();
    179     ConditionTruthVal OpenFailed = CMgr.isNull(State, Sym);
    180     return !OpenFailed.isConstrainedTrue();
    181   }
    182   return false;
    183 }
    184 
    185 void SimpleStreamChecker::checkDeadSymbols(SymbolReaper &SymReaper,
    186                                            CheckerContext &C) const {
    187   ProgramStateRef State = C.getState();
    188   SymbolVector LeakedStreams;
    189   StreamMapTy TrackedStreams = State->get<StreamMap>();
    190   for (StreamMapTy::iterator I = TrackedStreams.begin(),
    191                              E = TrackedStreams.end(); I != E; ++I) {
    192     SymbolRef Sym = I->first;
    193     bool IsSymDead = SymReaper.isDead(Sym);
    194 
    195     // Collect leaked symbols.
    196     if (isLeaked(Sym, I->second, IsSymDead, State))
    197       LeakedStreams.push_back(Sym);
    198 
    199     // Remove the dead symbol from the streams map.
    200     if (IsSymDead)
    201       State = State->remove<StreamMap>(Sym);
    202   }
    203 
    204   ExplodedNode *N = C.addTransition(State);
    205   reportLeaks(LeakedStreams, C, N);
    206 }
    207 
    208 void SimpleStreamChecker::reportDoubleClose(SymbolRef FileDescSym,
    209                                             const CallEvent &Call,
    210                                             CheckerContext &C) const {
    211   // We reached a bug, stop exploring the path here by generating a sink.
    212   ExplodedNode *ErrNode = C.generateSink();
    213   // If we've already reached this node on another path, return.
    214   if (!ErrNode)
    215     return;
    216 
    217   // Generate the report.
    218   BugReport *R = new BugReport(*DoubleCloseBugType,
    219       "Closing a previously closed file stream", ErrNode);
    220   R->addRange(Call.getSourceRange());
    221   R->markInteresting(FileDescSym);
    222   C.emitReport(R);
    223 }
    224 
    225 void SimpleStreamChecker::reportLeaks(SymbolVector LeakedStreams,
    226                                                CheckerContext &C,
    227                                                ExplodedNode *ErrNode) const {
    228   // Attach bug reports to the leak node.
    229   // TODO: Identify the leaked file descriptor.
    230   for (SmallVector<SymbolRef, 2>::iterator
    231       I = LeakedStreams.begin(), E = LeakedStreams.end(); I != E; ++I) {
    232     BugReport *R = new BugReport(*LeakBugType,
    233         "Opened file is never closed; potential resource leak", ErrNode);
    234     R->markInteresting(*I);
    235     C.emitReport(R);
    236   }
    237 }
    238 
    239 bool SimpleStreamChecker::guaranteedNotToCloseFile(const CallEvent &Call) const{
    240   // If it's not in a system header, assume it might close a file.
    241   if (!Call.isInSystemHeader())
    242     return false;
    243 
    244   // Handle cases where we know a buffer's /address/ can escape.
    245   if (Call.argumentsMayEscape())
    246     return false;
    247 
    248   // Note, even though fclose closes the file, we do not list it here
    249   // since the checker is modeling the call.
    250 
    251   return true;
    252 }
    253 
    254 // If the pointer we are tracking escaped, do not track the symbol as
    255 // we cannot reason about it anymore.
    256 ProgramStateRef
    257 SimpleStreamChecker::checkPointerEscape(ProgramStateRef State,
    258                                         const InvalidatedSymbols &Escaped,
    259                                         const CallEvent *Call,
    260                                         PointerEscapeKind Kind) const {
    261   // If we know that the call cannot close a file, there is nothing to do.
    262   if ((Kind == PSK_DirectEscapeOnCall ||
    263        Kind == PSK_IndirectEscapeOnCall) &&
    264       guaranteedNotToCloseFile(*Call)) {
    265     return State;
    266   }
    267 
    268   for (InvalidatedSymbols::const_iterator I = Escaped.begin(),
    269                                           E = Escaped.end();
    270                                           I != E; ++I) {
    271     SymbolRef Sym = *I;
    272 
    273     // The symbol escaped. Optimistically, assume that the corresponding file
    274     // handle will be closed somewhere else.
    275     State = State->remove<StreamMap>(Sym);
    276   }
    277   return State;
    278 }
    279 
    280 void SimpleStreamChecker::initIdentifierInfo(ASTContext &Ctx) const {
    281   if (IIfopen)
    282     return;
    283   IIfopen = &Ctx.Idents.get("fopen");
    284   IIfclose = &Ctx.Idents.get("fclose");
    285 }
    286 
    287 void ento::registerSimpleStreamChecker(CheckerManager &mgr) {
    288   mgr.registerChecker<SimpleStreamChecker>();
    289 }
    290