- issue 17: Heap corruption.
- issue 23: Handles invalidated when realloc called.
- issue 24: cfstore_find returns error when "previous" parameter is NULL.
- issue 25: Memory leak when out of memory.
With respect to issues 17 and 23:
- A code defect existed for correctly updating cfstore_file_t data structures
under the following conditions:
-- the KV memory area contained some KV's.
-- cfstore calls realloc() to increase the size of the KV area in
memory because:
* A new KV was being added to the KV area, or
* the size of a pre-existing KV was being increased.
-- The returned address from realloc() has changed from before the
call (i.e. the location in memory of the KV area has changed)
e.g. the presence of heap memory objects directly above the KV memory
area in the memory address space causes realloc() to move the KV area
so the newly increased area can be accommodated at contiguous addresses.
-- In this scenario, the cfstore_file_t (structures for open files) head pointers
do not get correctly updated.
-- The defect was fixed by correctly updating the cfstore_file_t:: head pointer.
-- A new add_del test case was added to the scenario where a new KV is being added
to the KV area.
-- A new create test case was added to the scenario where the size of a
pre-existing KV is being increased in size.
- A code defect for suppling a NULL handle as the previous argument to the Find() method
(issue 24).
-- Supply a null handle is valid, but it was being used to check for a valid hkey,
which was incorrect.
-- A new test case was added to check the case of supplying a NULL previous argument
works correctly.
- A code defect for a memory leak under the following conditions (issue 25):
-- When realloc() fails to perform a requested change to the size of the KV area, the
error handling sometimes incorrectly sets cfstore_context_t::area_0_head to NULL.
Cfstore returns a suitable error to the client. If memory had previously been held
at area_0_head, realloc(area_0_head, size) returning NULL means the memory
at area_0_head is still retained.
-- On receiving the error code, the client cleans up including a call to Uninitialize().
This should free the retained but as area_0_head == NULL this is not possible. Hence
a memory leak occurred.
-- This was fixed by not setting area_0_head = NULL on the realloc() failure.
-- A create test case was modified to detect the leaking of memory in this way.
- Avoid a call to the protected method `get_stack()` which cause a build fail.
- Remove the constructor definition `TCPServer(NetworkStack *stack)`
because it has no implementation.
* provide missing member functions from control_t in base_control_t
* construction of control_t from reference of base_control_t instead of
value.
* overload operator+ for all permutations between control_t and
base_control_t.
That way it is not a global object anymore and is not attached to the
.init section and init array. If the function which contain the object is
not called then the serial object will not be present in the final binary.
- Corrected handling, before errors would forcibly restart the
accept loop without checks for timeouts
- Rearranged accept logic to match the logic of
recv/send/recvfrom/sendto
To avoid complications with unexpected IP versions, the wanted
IP version was added as an extra argument to DNS query functions
(defaults to NSAPI_IPv4).
Internal API changes:
m nsapi_dns_query
m nsapi_dns_query_multiple
Interestingly, though multiple questions can be encoded in a single
DNS packet, few, if any, nameservers respect any but the first
question. This makes support for coelescing DNS queries useless.
Internal API changes:
+ nsapi_dns_query_multiple
Note, dns_query_multiple takes a buffer of nsapi_addr_t to fill. This is
less dynamic than the linked-list method used in linux's gethostbyname,
but is easier to manage and more constrained.
Internal API changes:
dnsQuery -> nsapi_dns_query
Additionally restructured query code to emit/parse network structures
in stream form to hopefully document the underlying structure more
explicitly.
Additionally, the following changes were don to avoid combinatorial
explosion in function overloads as a result of adding cv-qualifiers:
- Added convenience function for inferred type
- Deprecated callback overloads qhere cv-qualifiers are not scalable
Supported overloads:
callback(void (*f)(A...));
callback(const Callback<R(A...)> &);
callback(T *t, void (*f)(T*, A...));
callback(const T *t, void (*f)(const T*, A...));
callback(volatile T *t, void (*f)(volatile T*, A...));
callback(const volatile T *t, void (*f)(const volatile T*, A...));
callback(T *t, void (T::*f)(A...));
callback(const T *t, void (T::*f)(A...) const);
callback(volatile T *t, void (T::*f)(A...) volatile);
callback(const volatile T *t, void (T::*f)(A...) const volatile);
Sam Grove
Vincent Coubard
Olaf Hagendorf
Simon Hughes
svastm
Christopher Haster
Russ Butler
Yogesh Pande
Milosch Meriac
Marcus Chang
cyliangtw