BT_OCTET16_LEN - syntax, references, description

References

Code

Location

#define BT_OCTET16_LEN 16

bt_types.h:319

typedef UINT8 BT_OCTET16[BT_OCTET16_LEN]; /* octet array: size 16 */

bt_types.h:320

memcpy(sec_event.local_oob_data.local_oob_c, p_data->local_oob_data.commitment, BT_OCTET16_LEN);

bta_dm_act.c:4940

memcpy(sec_event.local_oob_data.local_oob_r, p_data->local_oob_data.randomizer, BT_OCTET16_LEN);

bta_dm_act.c:4941

if(p_value == NULL || len > BT_OCTET16_LEN) {

bta_dm_api.c:827

memcpy(p_msg->c, p_c, BT_OCTET16_LEN);

bta_dm_api.c:862

memcpy(p_msg->r, p_r, BT_OCTET16_LEN);

bta_dm_api.c:863

memcpy(p_msg->c, c, BT_OCTET16_LEN);

bta_dm_ci.c:80

memcpy(p_msg->r, r, BT_OCTET16_LEN);

bta_dm_ci.c:81

UINT8 value[BT_OCTET16_LEN];

bta_dm_int.h:482

UINT8 c[BT_OCTET16_LEN];

bta_dm_int.h:483

UINT8 r[BT_OCTET16_LEN];

bta_dm_int.h:484

UINT8 c[BT_OCTET16_LEN];

bta_dm_int.h:491

UINT8 r[BT_OCTET16_LEN];

bta_dm_int.h:492

btc_storage_set_gatt_db_hash(&bd_addr, db_hash, BT_OCTET16_LEN);

bta_gatts_co.c:205

btc_storage_get_gatt_db_hash(&bd_addr, db_hash, BT_OCTET16_LEN);

bta_gatts_co.c:247

BT_OCTET16_LEN)== BT_STATUS_SUCCESS) {

btc_dm.c:136

BT_OCTET16_LEN)== BT_STATUS_SUCCESS )&&

btc_dm.c:142

BT_OCTET16_LEN)== BT_STATUS_SUCCESS)&&

btc_dm.c:144

BT_OCTET16_LEN)== BT_STATUS_SUCCESS)) {

btc_dm.c:146

memcpy(param.ble_security.oob_data.oob_c, p_data->local_oob_data.local_oob_c, BT_OCTET16_LEN);

btc_dm.c:1015

memcpy(param.ble_security.oob_data.oob_r, p_data->local_oob_data.local_oob_r, BT_OCTET16_LEN);

BT_OCTET16_LEN);

BT_OCTET16_LEN);

BT_OCTET16_LEN);

BT_OCTET16_LEN);

uint8_t ir[BT_OCTET16_LEN];

btc_dm.h:48

uint8_t irk[BT_OCTET16_LEN];

btc_dm.h:49

uint8_t dhk[BT_OCTET16_LEN];

btc_dm.h:50

uint8_t er[BT_OCTET16_LEN];

btc_dm.h:56

dst->sc_oob_req_reply.p_c = osi_malloc(BT_OCTET16_LEN);

btc_gap_ble.c:1669

memcpy(dst->sc_oob_req_reply.p_c, src->sc_oob_req_reply.p_c, BT_OCTET16_LEN);

btc_gap_ble.c:1671

dst->sc_oob_req_reply.p_r = osi_malloc(BT_OCTET16_LEN);

btc_gap_ble.c:1677

memcpy(dst->sc_oob_req_reply.p_r, src->sc_oob_req_reply.p_r, BT_OCTET16_LEN);

btc_gap_ble.c:1679

memcpy (ble_encr_key_value, btm_cb.devcb.ble_encryption_key_value, BT_OCTET16_LEN);

btm_ble.c:240

memcpy (irk, btm_cb.devcb.id_keys.irk, BT_OCTET16_LEN);

btm_ble.c:258

memcpy (dhk, btm_cb.devcb.id_keys.dhk, BT_OCTET16_LEN);

btm_ble.c:274

memcpy(&oob.peer_oob_data.commitment, p_c, BT_OCTET16_LEN);

btm_ble.c:530

memcpy(&oob.peer_oob_data.randomizer, p_r, BT_OCTET16_LEN);

btm_ble.c:531

params.param_len = BT_OCTET16_LEN;

btm_ble.c:1163

memcpy(p_rec->ble.keys.pltk, p_keys->penc_key.ltk, BT_OCTET16_LEN);

btm_ble.c:1295

for (i = 0; i < BT_OCTET16_LEN; i++) {

btm_ble.c:1314

memcpy(p_rec->ble.keys.pcsrk, p_keys->pcsrk_key.csrk, BT_OCTET16_LEN);

btm_ble.c:1330

memcpy(p_rec->ble.keys.lltk, p_keys->lenc_key.ltk, BT_OCTET16_LEN);

btm_ble.c:1349

memcpy (p_rec->ble.keys.lcsrk, p_keys->lcsrk_key.csrk, BT_OCTET16_LEN);

btm_ble.c:1371

memcpy(btm_cb.devcb.id_keys.irk, p->param_buf, BT_OCTET16_LEN);

btm_ble.c:2652

memcpy(btm_cb.devcb.id_keys.dhk, p->param_buf, BT_OCTET16_LEN);

btm_ble.c:2695

if (!SMP_Encrypt(btm_cb.devcb.id_keys.ir, BT_OCTET16_LEN, &btm_ble_irk_pt,

btm_ble.c:2699

SMP_Encrypt(btm_cb.devcb.id_keys.ir, BT_OCTET16_LEN, &btm_ble_dhk_pt,

btm_ble.c:2736

if (!SMP_Encrypt(btm_cb.devcb.id_keys.irk, BT_OCTET16_LEN, p->param_buf, 3, &output)) {

btm_ble_addr.c:114

SMP_Encrypt(p_dev_rec->ble.keys.irk, BT_OCTET16_LEN,

btm_ble_addr.c:314

SMP_Encrypt(p_dev_rec->ble.keys.irk, BT_OCTET16_LEN,

btm_ble_addr.c:363

UINT8 param_buf[BT_OCTET16_LEN];

btm_ble_api.h:283

if (!SMP_Encrypt(btm_cb.devcb.id_keys.irk, BT_OCTET16_LEN, p->param_buf, 3, &output)) {

btm_ble_multi_adv.c:409

ARRAY_TO_STREAM(p, p_dev_rec->ble.keys.irk, BT_OCTET16_LEN);

btm_ble_privacy.c:916

memcpy(le_key.ltk, p_cb->ltk, BT_OCTET16_LEN);

smp_act.c:375

memcpy (key.csrk, p_cb->csrk, BT_OCTET16_LEN);

smp_act.c:430

STREAM_TO_ARRAY(p_cb->rconfirm, p, BT_OCTET16_LEN);

smp_act.c:694

STREAM_TO_ARRAY(p_cb->rrand, p, BT_OCTET16_LEN);

smp_act.c:739

STREAM_TO_ARRAY(p_cb->remote_commitment, p, BT_OCTET16_LEN);

smp_act.c:806

STREAM_TO_ARRAY(p_cb->remote_dhkey_check, p, BT_OCTET16_LEN);

smp_act.c:827

STREAM_TO_ARRAY(p_cb->ltk, p, BT_OCTET16_LEN);

smp_act.c:1016

memcpy(le_key.ltk, p_cb->ltk, BT_OCTET16_LEN);

smp_act.c:1039

STREAM_TO_ARRAY (p_cb->tk, p, BT_OCTET16_LEN); /* reuse TK for IRK */

smp_act.c:1063

memcpy(pid_key.irk, p_cb->tk, BT_OCTET16_LEN);

smp_act.c:1081

memcpy (le_key.csrk, p_data, BT_OCTET16_LEN); /* get peer CSRK */

smp_act.c:1113

if (!memcmp(p_cb->rconfirm, p_data->key.p_data, BT_OCTET16_LEN)) {

smp_act.c:1135

memset(p_cb->tk, 0, BT_OCTET16_LEN);

smp_act.c:1364

memset(p_cb->local_random, 0, BT_OCTET16_LEN);

smp_act.c:1610

if (memcmp(p_data->key.p_data, p_cb->remote_dhkey_check, BT_OCTET16_LEN)) {

smp_act.c:1778

BT_OCTET16_LEN);

smp_act.c:1944

if (len > BT_OCTET16_LEN) {

smp_api.c:439

len = BT_OCTET16_LEN;

smp_api.c:440

UINT8 param_buf[BT_OCTET16_LEN];

smp_api.h:277

for ( i = length ; i < BT_OCTET16_LEN; i++ ) {

smp_cmac.c:82

p[BT_OCTET16_LEN - i - 1] = ( i == length ) ? 0x80 : 0;

smp_cmac.c:83

for ( i = 0; i < BT_OCTET16_LEN ; i ++ ) {

smp_cmac.c:100

smp_xor_128(&cmac_cb.text[(cmac_cb.round - i)*BT_OCTET16_LEN], x); /* Mi' := Mi (+) X */

smp_cmac.c:143

if (!SMP_Encrypt(key, BT_OCTET16_LEN, &cmac_cb.text[(cmac_cb.round - i)*BT_OCTET16_LEN], BT_OCTET16_LEN, &output)) {

smp_cmac.c:145

memcpy(x, output.param_buf, BT_OCTET16_LEN);

smp_cmac.c:150

p_mac = output.param_buf + (BT_OCTET16_LEN - tlen);

smp_cmac.c:155

flag = ((cmac_cb.len % BT_OCTET16_LEN) == 0 && cmac_cb.len != 0) ? TRUE : FALSE;

smp_cmac.c:187

UINT8 k1[BT_OCTET16_LEN], k2[BT_OCTET16_LEN];

smp_cmac.c:211

if ( (pp[BT_OCTET16_LEN - 1] & 0x80) != 0 ) {

smp_cmac.c:217

if ( (k1[BT_OCTET16_LEN - 1] & 0x80) != 0 ) {

smp_cmac.c:225

if (SMP_Encrypt(key, BT_OCTET16_LEN, z, BT_OCTET16_LEN, &output)) {

smp_cmac.c:257

UINT16 n = (length + BT_OCTET16_LEN - 1) / BT_OCTET16_LEN; /* n is number of rounds */

smp_cmac.c:284

len = n * BT_OCTET16_LEN;

smp_cmac.c:292

memset(p_cb->tk, 0, BT_OCTET16_LEN);

smp_keys.c:222

memset(p_cb->tk, 0, BT_OCTET16_LEN);

smp_keys.c:291

if (!SMP_Encrypt(er, BT_OCTET16_LEN, buffer, 4, &output)) {

smp_keys.c:461

memcpy((void *)p_cb->csrk, output.param_buf, BT_OCTET16_LEN);

smp_keys.c:471

if (!SMP_Encrypt(p_cb->tk, BT_OCTET16_LEN, p1, BT_OCTET16_LEN, &output)) {

smp_keys.c:666

if (!SMP_Encrypt(p_cb->tk, BT_OCTET16_LEN, p2, BT_OCTET16_LEN, &output)) {

smp_keys.c:703

memcpy(p_cb->confirm, p->param_buf, BT_OCTET16_LEN);

smp_keys.c:776

if (!SMP_Encrypt(er, BT_OCTET16_LEN, (UINT8 *)&p_cb->div,

smp_keys.c:862

memcpy((void *)p_cb->ltk, output.param_buf, BT_OCTET16_LEN);

smp_keys.c:869

if (!SMP_Encrypt(dhk, BT_OCTET16_LEN, p_cb->enc_rand,

smp_keys.c:895

memset(p, 0, BT_OCTET16_LEN);

smp_keys.c:970

encrypted = SMP_Encrypt( p_cb->tk, BT_OCTET16_LEN, ptext, BT_OCTET16_LEN, output);

smp_keys.c:981

memcpy(p_cb->local_random, p_loc_oob->randomizer, BT_OCTET16_LEN);

smp_keys.c:1132

UINT8 key[BT_OCTET16_LEN];

smp_keys.c:1304

UINT8 cmac[BT_OCTET16_LEN];

smp_keys.c:1305

ARRAY_TO_STREAM(p, x, BT_OCTET16_LEN);

smp_keys.c:1334

aes_cipher_msg_auth_code(key, msg, msg_len, BT_OCTET16_LEN, cmac);

smp_keys.c:1340

ARRAY_TO_STREAM(p, cmac, BT_OCTET16_LEN);

smp_keys.c:1347

+ BT_OCTET16_LEN /* Y size */;

smp_keys.c:1414

UINT8 msg[BT_OCTET32_LEN + BT_OCTET32_LEN + BT_OCTET16_LEN];

smp_keys.c:1415

UINT8 key[BT_OCTET16_LEN];

smp_keys.c:1416

UINT8 cmac[BT_OCTET16_LEN];

smp_keys.c:1417

ARRAY_TO_STREAM(p, y, BT_OCTET16_LEN);

smp_keys.c:1427

ARRAY_TO_STREAM(p, x, BT_OCTET16_LEN);

smp_keys.c:1442

if (!aes_cipher_msg_auth_code(key, msg, msg_len, BT_OCTET16_LEN, cmac)) {

smp_keys.c:1448

UINT8 cmac[BT_OCTET16_LEN];

smp_keys.c:1641

UINT8 key[BT_OCTET16_LEN];

smp_keys.c:1642

BT_OCTET16_LEN /* N1 size */ + BT_OCTET16_LEN /* N2 size */ +

smp_keys.c:1644

UINT8 msg[1 + 4 + BT_OCTET16_LEN + BT_OCTET16_LEN + 7 + 7 + 2];

smp_keys.c:1646

ARRAY_TO_STREAM(p, t, BT_OCTET16_LEN);

smp_keys.c:1673

ARRAY_TO_STREAM(p, n2, BT_OCTET16_LEN);

smp_keys.c:1682

ARRAY_TO_STREAM(p, n1, BT_OCTET16_LEN);

smp_keys.c:1683

if (!aes_cipher_msg_auth_code(key, msg, msg_len, BT_OCTET16_LEN, cmac)) {

smp_keys.c:1691

ARRAY_TO_STREAM(p, cmac, BT_OCTET16_LEN);

smp_keys.c:1702

ARRAY_TO_STREAM(p, salt, BT_OCTET16_LEN);

smp_keys.c:1752

if (!aes_cipher_msg_auth_code(key, msg, BT_OCTET32_LEN, BT_OCTET16_LEN, cmac)) {

smp_keys.c:1764

ARRAY_TO_STREAM(p, cmac, BT_OCTET16_LEN);

smp_keys.c:1775

UINT8 msg_len = BT_OCTET16_LEN /* N1 size */ + BT_OCTET16_LEN /* N2 size */ +

smp_keys.c:1878

BT_OCTET16_LEN /* R size */ + 3 /* IOcap size */ + 7 /* A1 size*/

smp_keys.c:1879

UINT8 msg[BT_OCTET16_LEN + BT_OCTET16_LEN + BT_OCTET16_LEN + 3 + 7 + 7];

smp_keys.c:1881

UINT8 cmac[BT_OCTET16_LEN];

smp_keys.c:1904

UINT8 key[BT_OCTET16_LEN];

smp_keys.c:1905

ARRAY_TO_STREAM(p, w, BT_OCTET16_LEN);

smp_keys.c:1908

ARRAY_TO_STREAM(p, r, BT_OCTET16_LEN);

smp_keys.c:1918

ARRAY_TO_STREAM(p, n2, BT_OCTET16_LEN);

smp_keys.c:1919

ARRAY_TO_STREAM(p, n1, BT_OCTET16_LEN);

smp_keys.c:1920

if (!aes_cipher_msg_auth_code(key, msg, msg_len, BT_OCTET16_LEN, cmac)) {

smp_keys.c:1927

ARRAY_TO_STREAM(p, cmac, BT_OCTET16_LEN);

smp_keys.c:1938

UINT8 key[BT_OCTET16_LEN];

smp_keys.c:2130

ARRAY_TO_STREAM(p, w, BT_OCTET16_LEN);

smp_keys.c:2133

UINT8 cmac[BT_OCTET16_LEN];

smp_keys.c:2152

if (!aes_cipher_msg_auth_code(key, msg, msg_len, BT_OCTET16_LEN, cmac)) {

smp_keys.c:2153

ARRAY_TO_STREAM(p, cmac, BT_OCTET16_LEN);

smp_keys.c:2164

#define SMP_CONFIRM_CMD_SIZE (BT_OCTET16_LEN + 1)

smp_utils.c:42

#define SMP_RAND_CMD_SIZE (BT_OCTET16_LEN + 1)

smp_utils.c:43

#define SMP_ENC_INFO_SIZE (BT_OCTET16_LEN + 1)

smp_utils.c:45

#define SMP_ID_INFO_SIZE (BT_OCTET16_LEN + 1)

smp_utils.c:47

#define SMP_SIGN_INFO_SIZE (BT_OCTET16_LEN + 1)

smp_utils.c:49

#define SMP_PAIR_COMMITM_SIZE (1 /* opcode */ + BT_OCTET16_LEN /*Commitment*/)

smp_utils.c:53

#define SMP_PAIR_DHKEY_CHECK_SIZE (1 /* opcode */ + BT_OCTET16_LEN /*DHKey Check*/)

smp_utils.c:54

ARRAY_TO_STREAM (p, p_cb->confirm, BT_OCTET16_LEN);

smp_utils.c:456

ARRAY_TO_STREAM (p, p_cb->rand, BT_OCTET16_LEN);

smp_utils.c:483

ARRAY_TO_STREAM (p, p_cb->ltk, BT_OCTET16_LEN);

smp_utils.c:509

ARRAY_TO_STREAM (p, irk, BT_OCTET16_LEN);

smp_utils.c:570

ARRAY_TO_STREAM (p, p_cb->csrk, BT_OCTET16_LEN);

smp_utils.c:638

ARRAY_TO_STREAM (p, p_cb->commitment, BT_OCTET16_LEN);

smp_utils.c:757

ARRAY_TO_STREAM (p, p_cb->dhkey_check, BT_OCTET16_LEN);

smp_utils.c:785

if (loc_enc_size < BT_OCTET16_LEN) {

smp_utils.c:860

for (; loc_enc_size < BT_OCTET16_LEN; loc_enc_size ++) {

smp_utils.c:861

for (i = 0; i < BT_OCTET16_LEN; i++) {

smp_utils.c:884

if (memcmp(p_cb->remote_commitment, expected, BT_OCTET16_LEN)) {

smp_utils.c:1522

memcpy(lle_key.ltk, p_cb->ltk, BT_OCTET16_LEN);

smp_utils.c:1547

memcpy(ple_key.ltk, p_cb->ltk, BT_OCTET16_LEN);

smp_utils.c:1556

BT_OCTET16_LEN macro

Syntax

Examples

References

Call Tree

Data Use

Class Tree

Override Tree

Implementations

Instances

Lifecycle