tree b7edc139d3d97d3803943d0a7fe270562297afac
parent 35364c99d20edc7329843e2a6dad6851d77eafd7
author Johan Hedberg <johan.hedberg@intel.com> 1390951011 -0800
committer Johan Hedberg <johan.hedberg@intel.com> 1392277899 +0200

Bluetooth: Always use l2cap_chan->psm for returning PSM to user space

The l2cap_chan->psm value is always set to a valid value for a
connection oriented channel. The l2cap_chan->sport is used for tracking
local PSM allocations but will not always have a proper value, such as
with connected sockets derived from a listening socket. This patch fixes
the sock_getname callback to always use chan->psm when returning address
information.

Signed-off-by: Johan Hedberg <johan.hedberg@intel.com>
Signed-off-by: Marcel Holtmann <marcel@holtmann.org>
