StreamChecker.cpp revision 063e0887ad65d666d23ee3178436ad6507abbd1b 
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
24using namespace clang;
25using namespace ento;
26
27namespace {
28
29struct 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
59class 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
70public:
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
81private:
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
107namespace clang {
108namespace 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
117bool 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
215void StreamChecker::Fopen(CheckerContext &C, const CallExpr *CE) const {
216  OpenFileAux(C, CE);
217}
218
219void StreamChecker::Tmpfile(CheckerContext &C, const CallExpr *CE) const {
220  OpenFileAux(C, CE);
221}
222
223void 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
249void 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
255void 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
261void 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
267void 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
293void 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
299void 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
305void 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
311void 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
317void 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
323void 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
329void 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
335void 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
341const 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
364const 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
397void 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
421void 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
442void 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
463void ento::registerStreamChecker(CheckerManager &mgr) {
464  mgr.registerChecker<StreamChecker>();
465}
466