Analyzer detected a potential error of recurrent resource deallocation. Under certain circumstances this code may turn into a security defect. The resource mentioned could be a memory space, some file or, for example, an HBRUSH object.
Let's review the example of incorrect code:
float *p1 = (float *)malloc(N * sizeof(float)); float *p2 = (float *)malloc(K * sizeof(float)); ... free(p1); free(p1);
There is a misprint in application's source code which causes the double deallocation of same memory space. It is hard to predict the consequences of such code's execution. It's possible that such a program would crash. Or it will continue its execution but memory leak will occur.
Moreover, this code is a security defect and may lead to a vulnerability. For example, the 'malloc' ('dmalloc') function by Doug Lea that is used in some libraries as 'malloc' by default, is subject to the vulnerability. There are several conditions needed for the appearance of the vulnerability, related to the double memory freeing: memory blocks, contiguously-allocated with the freed ones, should not be free, and the list of the free memory blocks should be empty. In this case it is possible to create an exploit. Despite the fact that vulnerabilities of this kind are hard to exploit because of its specific memory configuration, there are real examples of the vulnerable code that was successfully hacked.
The correct example:
float *p1 = (float *)malloc(N * sizeof(float)); float *p2 = (float *)malloc(K * sizeof(float)); ... free(p1); free(p2);
Sometimes an error of double resource deallocation is not a dangerous one:
vector<unsigned> m_arrStack; ... m_arrStack.clear(); m_arrBlock.clear(); m_arrStack.clear();
Accidently the array is emptied twice. The code operates correctly but still it should be reviewed and corrected. During its study, it could be discovered that another array dissaalocation should have been performed nevertheless.
The correct example:
vector<unsigned> m_arrStack; ... m_arrStack.clear(); m_arrBlock.clear();