Logging cleanup

Remove unused definitions from bt_target.h

Eliminate memory leaks and unsafe callbacks in BTA and BTE.

Alarms were being added to a hash map but were not freed during
teardown. This results in both memory leaks and potential access
of torn-down data (in case the still-armed alarm fires after
teardown completes).

Add string hashing function using djb2

Disassociate hash algorithm with hash function name

This will make it easier to select the correct one for the job, and also
make it possible to substitute a better one in the future if need be without
having to change the function name.

kunth is duplicated, once for integer hashing and once for shallow pointer hashing, to
make usage more readable.

Rewerite btif_sendmsg in terms of thread_post

Fix alarm setting for newer deadlines

If an alarm is being set and is the newest deadline
among a set of existing alarms, it would be appended
after the first existing alarm rather than prepended
in front.

This in turn meant the root alarm wasn't getting
rescheduled correctly, especially if the old
deadline was rather distant in the future.

(This was causing the bluetooth disable sequence to
fail intermittently.)

Post adapter_state_changed events to the JNI workqueue

Otherwise, JNI rejects the callbacks. Fix for b/17655336

Don't send adapter change until stack manager updates state

Since the callback occurred before the stack manager updated its
state to say the stack was fully loaded, there was a chance that
the adapter name change would be attempted before the state was
updated.

This would cause the adapter property change function to return
a "not ready" status.

Eliminate memory leak in stack initialization.

A heap allocated semaphore was not freed after use.

Fix bug where some BTU timer callbacks weren't propagated in a timely manner.

This change sends an event to the BTU task after enqueuing a timer
callback into its timer queue so that the BTU task thread wakes up
and dispatches the callback ASAP. Otherwise, the callback will be
dispatched at a random time or sometimes not at all.

All bdtest cases pass after this change.

Fix timeout values for BTA system timers.

bta_sys_start_timer assumes a timeout value in GKI ticks but the
callers are passing in a timeout value in milliseconds. This change
updates the implementation to use units of milliseconds.

Add back timer list entry in_use field

I thought this field was used for internal
bookkeeping, but it turns the higher layer
protocols use it to condition if a timer
should be started or stopped.

Enable assertions.

Remove btif enable state management

It's no longer necessary with the stack manager.

With these changes I don't think we'll be able to handle clean_up
as a result of an enable timeout coming down from Java.
But I think I'm ok with that.

At that point we're already hosed because of something else
which should be fixed. And if we wanted to handle clean_up during
start_up we'd violate the mutually exclusive guarantees the stack
management thread makes about init/start_up/shut_down/clean_up.

Make stack manager functions not finish until action complete

It's a bit hacky at the moment, but this incremental update means the
stack manager booleans should be correct now and we can start removing
code that relies on the btif states.

s/async_result/future/g and also improve the future API

Freeing now happens implicitly upon await, and immediate
futures will allow a uniform usage pattern for calls
that are async and calls that are not.

Make semaphore_free idempotent

Passing NULL before would lead to a segfault.

Move all stack init/start_up/shut_down/clean_up on a single known thread

Execution happens on the same thread, but the next step will be to
ensure each of the functions do not complete until start_up/shut_down/clean_up
complete. That will ensure each is mutually exclusive.

async_result abstraction for signaling async return values

This will be useful when signaling success/fail during individual
asynchronous steps of stack start up and shut down.

Fix packet fragmenter so it doesn't request acl sizes unless it's actually an ACL packet

During the startup process, commands are sent before the ACL sizes are fetched.
With the change that we now assert the acl sizes are fetched when you request
them from the controller, the assertion was being triggered during that phase.

When I was rebasing the waiting changes and also making the assertion change,
I should have been more careful to test this. mea culpa

Also simplifies that code path just a bit.

Shuffle HCI layer internal functions into a more logical ordering

No actual code additions/deletions, other than additional forward declarations

Refactor bte_main into more of a shell.

Moves all HCI initialization into hci_layer. Removes superfluous exposed
functionality on the HCI layer (like turning the chip on/off and logging)

Also reorganizes some of hci_layer to group related functions together.

Add non-repeating timer wrapper for alarm

Refactor the hci layer to use it.

The timer wrapper allows you to specify the duration, etc at construction time
rather than at start time, making some usage patterns of alarm more convenient.

HCI layer cleanup

- x_interface_t started to get annoyingly verbose, changed to x_t
- buffer_allocator is standalone now, no longer part of bte_main
- new controller_t to handle controller start up and hold controller state
- new hci_packet_factory to make packets, and hci_packet_parser
  to read information out of packets.

Remove must-always-be-true BTU_BTA_INCLUDED

Change-Id: I7ddfb9d611b7f4a2787e0f4bec4a090cd9efc202

Add a check for a NULL root element from tinyxml2's XMLDocument.

This shouldn't really be necessary since a parsed document
should have at least a root element. In practice, however, tinyxml2
sometimes returns success on LoadFile() and NULL on RootElement().

Bug: 17504829

Fix silly freeing of buffer.data instead of buffer

Also remove an unnecessary log message.

Sink all HCI transmission management into the HCI layer

Begins the refactoring of the HCI related code in BTA, corrects some
hacks in the HCI layer (no more concept of internal commands, yay!),
and corrects the handling of multiple commands pending response in the
HCI layer.

This introduce a horrible hack external to the HCI layer to keep BTU HCI
handling of command complete/status events on the BTU task. That hack
will be removed when BTU moves to a reactor model and we have osi
threads to work with.

Demote timer hashmap entry failure log message

The procedures that use timers immediately cancel them upon startup
assuming they existed previously. The first time though the codepath
these traversalls cause the hashmap lookup failure.

btif task removal and reactor insertion

GKI task entry points should have a consistent signature.

Previously, GKI task entry points had inconsistent signatures. For
example, we had:

int btif_media_task(void *p)
void btif_task(UINT32 params)
void btu_task (UINT32 param)

The single argument was universally ignored and the caller always
set it to 0. This change consolidates all of that and defines the
entry point as having 0 arity and no return value.

Code cleanup in GKI layer.

  * move buffer macros into .c from .h
  * delete dead code (e.g. GKI_igetpoolbuf, pool_list variable)
  * define task states as an enum and not a bitfield
  * start renaming fields in GKI control block for future consolidation

Eliminate unnecessary macros GKI_API, EXPORT_API, and UDRV_API.

Delete GKI debug code.

GKI is slowly disappearing so much of that debug code isn't useful.

Eliminate GKI_os_malloc and GKI_os_free.

Eliminate unused variables bufpool{0..15} in GKI control block.

GKI_USE_DEFERED_ALLOC_BUF_POOLS is always defined. Flatten code paths.

Remove unused fields from GKI internal header.

Cleanup and remove unused variables in GKI's common OS control block.

Use arrays instead of variable names like Tmr0, Tmr1, ... in GKI.

Eliminate all attempts to set scheduling policy (all no-ops).

Eliminate GKI_run and GKI_stop. Neither had any effect.

GKI_run was called but didn't do anything: it would call
sched_setscheduler to increase the priority of the current process
but Android OS policy doesn't allow for that. And GKI_stop was never
called.

Eliminate always-on macro GKI_PTHREAD_JOINABLE.

Eliminate unused 'stack' concept for GKI tasks.

This change also fixes the type for task names: should be a const
string, not a mutable INT8*.

Move BTU task creation into stack/btu/btu_init.c.

Also fixed function naming where the BTE prefix was used
instead of BTU.

Replace timers and btu_task

Replace GKI timers with alarms.

Replace mailboxes with fixed queues.

Also refactored btu_task a bit.

Remove #define BTA_SYS_TIMER_PERIOD

Remove unused BTU timer/event APIs

btu_register_timer
btu_deregister_timer
btu_register_event_range
btu_deregister_event_range

Fix memory leak in L2CAP utils

A list was not freed (just its contents was).

Replace BUFFER_Q with list_t

Replace A2DP BUFFER_Q with a list

The functions acting upon this list are all executed from action
or event context; which would be the same thread.

Remove unused function BTM_SecSetConnectFilterCallback

Make SCO sockets request eSCO instead of SCO

This fixes some audio routing problems.

Fix memory leak in RFCOMM sockets where some lists were not being freed.

Remove unused #define BTU_CMD_CMPL_TOUT_DOUBLE_CHECK

Remove unused definitions using GKI events

Re-layout Android.mk for single shared library

Remove unncessary socket write to SCO socket.

I've verified that the BluetoothSocket is terminated in a timely manner
even without the write(2).

Update SCO sockets to use OSI.

This change brings us one step closer to eliminating btsock_thread.

Rewrite the btif_sock module.

The initialization flow now handles errors. The btif_sock module is
now solely responsible for managing the lifetime of the btsock_thread
it creates.

This change lays the foundation for switching all btif sockets to use
the OSI primitives.

Implement GKI timers in terms of alarm.c. This also fixes some alarm/wake lock bugs.

The OS callout implementation expects only a single outstanding alarm
and a single wake lock being taken. Since alarm.c uses both and GKI
timers use both, they were occasionally clobbering each other resulting
in unpredictable behaviour. By writing GKI timers in terms of alarm.c,
this change addresses those bugs.

Remove unused "file system" concept & friends

Not actually ever used in the code, beyond importing some
header files and not calling any of their functions.

Remove Windows related macros

Eliminate call out/in indirection in bta_sys

Remove FM/GPS/NFC related definitions

Make the DURING test stub macro support checking multiple modes at a time

This allows test modes which have almost identical code paths to share
some test stub code instead of having to duplicate it for each of them.

Remove _WIDCOMM defines and AMP VSE events from hcidefs.h

Remove some more unused Broadcom specific macros

Remove BTM_ReadBrcmFeatures because it shouldn't exist and isn't used

Also eliminates some related macros.

Remove the company id defines (except broadcom for now)

Remove printf when attempting SDP requests.

Implement BTM_InqDbRead in terms of btm_inq_db_find

duplicated_code--;

Remove never used function BTM_GetNumLeLinks

verified unused, even in the latest android code

Modify allocation tracking to include and verify the allocation source

This will help detect and prevent allocator alloc/free mismatch.

Add memory canaries and turn them on for unit tests

This will allow us to verify with resonable certainty
that the code is not writing past the end or beginning
of the memory allocation that it was given.

With canaries on, the canaried pointers returned by the
osi alloc functions are no longer passable directly to
free, since they must be offset to get the real allocation
pointers. This means all legacy code must be converted
over to the osi alloc functions before turning canaries
on in the wider codebase.

Remove unused function BTM_SetInquiryFilterCallback

Remove unused function BTM_InquiryRegisterForChanges and associated code

Add a VALGRIND #define to heap-allocate all GKI buffers.

This change allows us to run Valgrind on bluedroid to find memory
leaks. It has already been used to track down multiple memory leaks
which weren't trackable with the existing GKI buffer implementation.

Fix memory leak in BTU where enequeued buffers were never freed on shutdown.

This resulted in the stack running out of GKI buffers on repeated
enable/disable cycles.

Rename init/cleanup to start_up/shut_down in the HCI layer

Don't pass in uninitialized memory to epoll_ctl. Make valgrind happy.

Remove incomplete FTP #defines and implementation

Remove unreferenced BTRC_DISP macro

Remove unreferenced BTE macros

Fix heap memory leak by placing the BT device struct in static storage

Removed always false macro BTM_INQ_GET_REMOTE_NAME

Remove some never used BTM macros

Remove always false macro L2CAP_HOST_FLOW_CTRL

Remove unused #define's BTM_IS_CONNECTABLE and BTM_IS_DISCOVERABLE

Eliminate unused #define BTM_INTERNAL_BB

Use osi_free with osi_calloc in HCI layer to avoid corruption

There was a mismatch where the free function was GKI_free for a
pointer allocated with osi_calloc. This resulted in GKI exceptions
being thrown if the adapter goes through enable -> disable -> enable
-> disable without terminating the process.

Remove unused auto-reset code path, with associated macros.

Remove unused #define BTM_AFTER_RESET_TIMEOUT

Remove indirection in the controller reset sequence

Fix issue where last character of device name is missing

The device name stored on disk is correct but has a missing character
at the end when read off of disk. This happened because the returned
|length| parameter to |btif_config_get_str| is in number of *bytes*,
not in number of characters (i.e. must add one for NULL character).

Add a UUID module to btcore for operating on UUIDs.

This change only adds a single function, uuid_is_empty, but I expect
other UUID-related functions to find themselves here.

Introduce btcore, a low-level library to manipulate Bluetooth data types.

This change adds a single module to btcore: bdaddr. The bdaddr module
is reponsible for manipulating and working with Bluetooth addresses.

Fix digital transposition in saving binary config data

Was causing link keys to be saved/read incorrectly, causing reconnect on reboot to fail.