sys/netgraph/bluetooth/l2cap/ng_l2cap_cmds.h

   1 /*
   2  * ng_l2cap_cmds.h
   3  */
   4
   5 /*-
   6  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   7  *
   8  * Copyright (c) Maksim Yevmenkin <m_evmenkin@yahoo.com>
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  *
  32  * $Id: ng_l2cap_cmds.h,v 1.4 2003/04/01 18:15:26 max Exp $
  33  * $FreeBSD$
  34  */
  35
  36 #ifndef _NETGRAPH_L2CAP_CMDS_H_
  37 #define _NETGRAPH_L2CAP_CMDS_H_
  38
  39 /******************************************************************************
  40  ******************************************************************************
  41  **                L2CAP to L2CAP signaling command macros
  42  ******************************************************************************
  43  ******************************************************************************/
  44
  45 /*
  46  * Note: All L2CAP implementations are required to support minimal signaling
  47  *       MTU of 48 bytes. In order to simplify things we will send one command
  48  *       per one L2CAP packet. Given evrything above we can assume that one
  49  *       signaling packet will fit into single mbuf.
  50  */
  51
  52 /* L2CAP_CommandRej */
  53 #define _ng_l2cap_cmd_rej(_m, _ident, _reason, _mtu, _scid, _dcid)      \
  54 do {                                                                    \
  55         struct _cmd_rej {                                               \
  56                 ng_l2cap_cmd_hdr_t       hdr;                           \
  57                 ng_l2cap_cmd_rej_cp      param;                         \
  58                 ng_l2cap_cmd_rej_data_t  data;                          \
  59         } __attribute__ ((packed))      *c = NULL;                      \
  60                                                                         \
  61         MGETHDR((_m), M_NOWAIT, MT_DATA);                               \
  62         if ((_m) == NULL)                                               \
  63                 break;                                                  \
  64                                                                         \
  65         c = mtod((_m), struct _cmd_rej *);                              \
  66         c->hdr.code = NG_L2CAP_CMD_REJ;                                 \
  67         c->hdr.ident = (_ident);                                        \
  68         c->hdr.length = sizeof(c->param);                               \
  69                                                                         \
  70         c->param.reason = htole16((_reason));                           \
  71                                                                         \
  72         if ((_reason) == NG_L2CAP_REJ_MTU_EXCEEDED) {                   \
  73                 c->data.mtu.mtu = htole16((_mtu));                      \
  74                 c->hdr.length += sizeof(c->data.mtu);                   \
  75         } else if ((_reason) == NG_L2CAP_REJ_INVALID_CID) {             \
  76                 c->data.cid.scid = htole16((_scid));                    \
  77                 c->data.cid.dcid = htole16((_dcid));                    \
  78                 c->hdr.length += sizeof(c->data.cid);                   \
  79         }                                                               \
  80                                                                         \
  81         (_m)->m_pkthdr.len = (_m)->m_len = sizeof(c->hdr) +             \
  82                                         c->hdr.length;                  \
  83                                                                         \
  84         c->hdr.length = htole16(c->hdr.length);                         \
  85 } while (0)
  86
  87 /* L2CAP_ConnectReq */
  88 #define _ng_l2cap_con_req(_m, _ident, _psm, _scid)                      \
  89 do {                                                                    \
  90         struct _con_req {                                               \
  91                 ng_l2cap_cmd_hdr_t       hdr;                           \
  92                 ng_l2cap_con_req_cp      param;                         \
  93         } __attribute__ ((packed))      *c = NULL;                      \
  94                                                                         \
  95         MGETHDR((_m), M_NOWAIT, MT_DATA);                               \
  96         if ((_m) == NULL)                                               \
  97                 break;                                                  \
  98                                                                         \
  99         (_m)->m_pkthdr.len = (_m)->m_len = sizeof(*c);                  \
 100                                                                         \
 101         c = mtod((_m), struct _con_req *);                              \
 102         c->hdr.code = NG_L2CAP_CON_REQ;                                 \
 103         c->hdr.ident = (_ident);                                        \
 104         c->hdr.length = htole16(sizeof(c->param));                      \
 105                                                                         \
 106         c->param.psm = htole16((_psm));                                 \
 107         c->param.scid = htole16((_scid));                               \
 108 } while (0)
 109
 110 /* L2CAP_ConnectRsp */
 111 #define _ng_l2cap_con_rsp(_m, _ident, _dcid, _scid, _result, _status)   \
 112 do {                                                                    \
 113         struct _con_rsp {                                               \
 114                 ng_l2cap_cmd_hdr_t       hdr;                           \
 115                 ng_l2cap_con_rsp_cp      param;                         \
 116         } __attribute__ ((packed))      *c = NULL;                      \
 117                                                                         \
 118         MGETHDR((_m), M_NOWAIT, MT_DATA);                               \
 119         if ((_m) == NULL)                                               \
 120                 break;                                                  \
 121                                                                         \
 122         (_m)->m_pkthdr.len = (_m)->m_len = sizeof(*c);                  \
 123                                                                         \
 124         c = mtod((_m), struct _con_rsp *);                              \
 125         c->hdr.code = NG_L2CAP_CON_RSP;                                 \
 126         c->hdr.ident = (_ident);                                        \
 127         c->hdr.length = htole16(sizeof(c->param));                      \
 128                                                                         \
 129         c->param.dcid = htole16((_dcid));                               \
 130         c->param.scid = htole16((_scid));                               \
 131         c->param.result = htole16((_result));                           \
 132         c->param.status = htole16((_status));                           \
 133 } while (0)
 134
 135 /* L2CAP_ConfigReq */
 136 #define _ng_l2cap_cfg_req(_m, _ident, _dcid, _flags, _data)             \
 137 do {                                                                    \
 138         struct _cfg_req {                                               \
 139                 ng_l2cap_cmd_hdr_t       hdr;                           \
 140                 ng_l2cap_cfg_req_cp      param;                         \
 141         } __attribute__ ((packed))      *c = NULL;                      \
 142                                                                         \
 143         MGETHDR((_m), M_NOWAIT, MT_DATA);                               \
 144         if ((_m) == NULL) {                                             \
 145                 NG_FREE_M((_data));                                     \
 146                 break;                                                  \
 147         }                                                               \
 148                                                                         \
 149         (_m)->m_pkthdr.len = (_m)->m_len = sizeof(*c);                  \
 150                                                                         \
 151         c = mtod((_m), struct _cfg_req *);                              \
 152         c->hdr.code = NG_L2CAP_CFG_REQ;                                 \
 153         c->hdr.ident = (_ident);                                        \
 154         c->hdr.length = sizeof(c->param);                               \
 155                                                                         \
 156         c->param.dcid = htole16((_dcid));                               \
 157         c->param.flags = htole16((_flags));                             \
 158         if ((_data) != NULL) {                                          \
 159                 int     l = (_data)->m_pkthdr.len;                      \
 160                                                                         \
 161                 m_cat((_m), (_data));                                   \
 162                 c->hdr.length += l;                                     \
 163                 (_m)->m_pkthdr.len += l;                                \
 164         }                                                               \
 165                                                                         \
 166         c->hdr.length = htole16(c->hdr.length);                         \
 167 } while (0)
 168
 169 /* L2CAP_ConfigRsp */
 170 #define _ng_l2cap_cfg_rsp(_m, _ident, _scid, _flags, _result, _data)    \
 171 do {                                                                    \
 172         struct _cfg_rsp {                                               \
 173                 ng_l2cap_cmd_hdr_t       hdr;                           \
 174                 ng_l2cap_cfg_rsp_cp      param;                         \
 175         } __attribute__ ((packed))      *c = NULL;                      \
 176                                                                         \
 177         MGETHDR((_m), M_NOWAIT, MT_DATA);                               \
 178         if ((_m) == NULL) {                                             \
 179                 NG_FREE_M((_data));                                     \
 180                 break;                                                  \
 181         }                                                               \
 182                                                                         \
 183         (_m)->m_pkthdr.len = (_m)->m_len = sizeof(*c);                  \
 184                                                                         \
 185         c = mtod((_m), struct _cfg_rsp *);                              \
 186         c->hdr.code = NG_L2CAP_CFG_RSP;                                 \
 187         c->hdr.ident = (_ident);                                        \
 188         c->hdr.length = sizeof(c->param);                               \
 189                                                                         \
 190         c->param.scid = htole16((_scid));                               \
 191         c->param.flags = htole16((_flags));                             \
 192         c->param.result = htole16((_result));                           \
 193         if ((_data) != NULL) {                                          \
 194                 int     l = (_data)->m_pkthdr.len;                      \
 195                                                                         \
 196                 m_cat((_m), (_data));                                   \
 197                 c->hdr.length += l;                                     \
 198                 (_m)->m_pkthdr.len += l;                                \
 199         }                                                               \
 200                                                                         \
 201         c->hdr.length = htole16(c->hdr.length);                         \
 202 } while (0)
 203
 204 #define _ng_l2cap_cmd_urs(_m, _ident, _result)  \
 205 do {                                                                    \
 206         struct  _cmd_urs{                                               \
 207                 ng_l2cap_cmd_hdr_t       hdr;                           \
 208                 uint16_t         result;                                \
 209         } __attribute__ ((packed))      *c = NULL;                      \
 210                                                                         \
 211         MGETHDR((_m), M_NOWAIT, MT_DATA);                               \
 212                                                                         \
 213         (_m)->m_pkthdr.len = (_m)->m_len = sizeof(*c);                  \
 214                                                                         \
 215         c = mtod((_m), struct _cmd_urs *);                              \
 216         c->hdr.code = NG_L2CAP_CMD_PARAM_UPDATE_RESPONSE;               \
 217         c->hdr.ident = (_ident);                                        \
 218         c->hdr.length = sizeof(c->result);                              \
 219                                                                         \
 220         c->result = htole16((_result));                         \
 221 } while (0)
 222
 223 /* Build configuration options */
 224 #define _ng_l2cap_build_cfg_options(_m, _mtu, _flush_timo, _flow)       \
 225 do {                                                                    \
 226         u_int8_t        *p = NULL;                                      \
 227                                                                         \
 228         MGETHDR((_m), M_NOWAIT, MT_DATA);                               \
 229         if ((_m) == NULL)                                               \
 230                 break;                                                  \
 231                                                                         \
 232         (_m)->m_pkthdr.len = (_m)->m_len = 0;                           \
 233         p = mtod((_m), u_int8_t *);                                     \
 234                                                                         \
 235         if ((_mtu) != NULL) {                                           \
 236                 struct _cfg_opt_mtu {                                   \
 237                         ng_l2cap_cfg_opt_t       hdr;                   \
 238                         u_int16_t                val;                   \
 239                 } __attribute__ ((packed))      *o = NULL;              \
 240                                                                         \
 241                 o = (struct _cfg_opt_mtu *) p;                          \
 242                 o->hdr.type = NG_L2CAP_OPT_MTU;                         \
 243                 o->hdr.length = sizeof(o->val);                         \
 244                 o->val = htole16(*(u_int16_t *)(_mtu));                 \
 245                                                                         \
 246                 (_m)->m_pkthdr.len += sizeof(*o);                       \
 247                 p += sizeof(*o);                                        \
 248         }                                                               \
 249                                                                         \
 250         if ((_flush_timo) != NULL) {                                    \
 251                 struct _cfg_opt_flush {                                 \
 252                         ng_l2cap_cfg_opt_t       hdr;                   \
 253                         u_int16_t                val;                   \
 254                 } __attribute__ ((packed))      *o = NULL;              \
 255                                                                         \
 256                 o = (struct _cfg_opt_flush *) p;                        \
 257                 o->hdr.type = NG_L2CAP_OPT_FLUSH_TIMO;                  \
 258                 o->hdr.length = sizeof(o->val);                         \
 259                 o->val = htole16(*(u_int16_t *)(_flush_timo));          \
 260                                                                         \
 261                 (_m)->m_pkthdr.len += sizeof(*o);                       \
 262                 p += sizeof(*o);                                        \
 263         }                                                               \
 264                                                                         \
 265         if ((_flow) != NULL) {                                          \
 266                 struct _cfg_opt_flow {                                  \
 267                         ng_l2cap_cfg_opt_t       hdr;                   \
 268                         ng_l2cap_flow_t          val;                   \
 269                 } __attribute__ ((packed))      *o = NULL;              \
 270                                                                         \
 271                 o = (struct _cfg_opt_flow *) p;                         \
 272                 o->hdr.type = NG_L2CAP_OPT_QOS;                         \
 273                 o->hdr.length = sizeof(o->val);                         \
 274                 o->val.flags = ((ng_l2cap_flow_p)(_flow))->flags;       \
 275                 o->val.service_type = ((ng_l2cap_flow_p)                \
 276                                 (_flow))->service_type;                 \
 277                 o->val.token_rate =                                     \
 278                         htole32(((ng_l2cap_flow_p)(_flow))->token_rate);\
 279                 o->val.token_bucket_size =                              \
 280                         htole32(((ng_l2cap_flow_p)                      \
 281                                 (_flow))->token_bucket_size);           \
 282                 o->val.peak_bandwidth =                                 \
 283                         htole32(((ng_l2cap_flow_p)                      \
 284                                 (_flow))->peak_bandwidth);              \
 285                 o->val.latency = htole32(((ng_l2cap_flow_p)             \
 286                                 (_flow))->latency);                     \
 287                 o->val.delay_variation =                                \
 288                         htole32(((ng_l2cap_flow_p)                      \
 289                                 (_flow))->delay_variation);             \
 290                                                                         \
 291                 (_m)->m_pkthdr.len += sizeof(*o);                       \
 292         }                                                               \
 293                                                                         \
 294         (_m)->m_len = (_m)->m_pkthdr.len;                               \
 295 } while (0)
 296
 297 /* L2CAP_DisconnectReq */
 298 #define _ng_l2cap_discon_req(_m, _ident, _dcid, _scid)                  \
 299 do {                                                                    \
 300         struct _discon_req {                                            \
 301                 ng_l2cap_cmd_hdr_t       hdr;                           \
 302                 ng_l2cap_discon_req_cp   param;                         \
 303         } __attribute__ ((packed))      *c = NULL;                      \
 304                                                                         \
 305         MGETHDR((_m), M_NOWAIT, MT_DATA);                               \
 306         if ((_m) == NULL)                                               \
 307                 break;                                                  \
 308                                                                         \
 309         (_m)->m_pkthdr.len = (_m)->m_len = sizeof(*c);                  \
 310                                                                         \
 311         c = mtod((_m), struct _discon_req *);                           \
 312         c->hdr.code = NG_L2CAP_DISCON_REQ;                              \
 313         c->hdr.ident = (_ident);                                        \
 314         c->hdr.length = htole16(sizeof(c->param));                      \
 315                                                                         \
 316         c->param.dcid = htole16((_dcid));                               \
 317         c->param.scid = htole16((_scid));                               \
 318 } while (0)
 319
 320 /* L2CA_DisconnectRsp */
 321 #define _ng_l2cap_discon_rsp(_m, _ident, _dcid, _scid)                  \
 322 do {                                                                    \
 323         struct _discon_rsp {                                            \
 324                 ng_l2cap_cmd_hdr_t       hdr;                           \
 325                 ng_l2cap_discon_rsp_cp   param;                         \
 326         } __attribute__ ((packed))      *c = NULL;                      \
 327                                                                         \
 328         MGETHDR((_m), M_NOWAIT, MT_DATA);                               \
 329         if ((_m) == NULL)                                               \
 330                 break;                                                  \
 331                                                                         \
 332         (_m)->m_pkthdr.len = (_m)->m_len = sizeof(*c);                  \
 333                                                                         \
 334         c = mtod((_m), struct _discon_rsp *);                           \
 335         c->hdr.code = NG_L2CAP_DISCON_RSP;                              \
 336         c->hdr.ident = (_ident);                                        \
 337         c->hdr.length = htole16(sizeof(c->param));                      \
 338                                                                         \
 339         c->param.dcid = htole16((_dcid));                               \
 340         c->param.scid = htole16((_scid));                               \
 341 } while (0)
 342
 343 /* L2CAP_EchoReq */
 344 #define _ng_l2cap_echo_req(_m, _ident, _data, _size)                    \
 345 do {                                                                    \
 346         ng_l2cap_cmd_hdr_t      *c = NULL;                              \
 347                                                                         \
 348         MGETHDR((_m), M_NOWAIT, MT_DATA);                               \
 349         if ((_m) == NULL)                                               \
 350                 break;                                                  \
 351                                                                         \
 352         (_m)->m_pkthdr.len = (_m)->m_len = sizeof(*c);                  \
 353                                                                         \
 354         c = mtod((_m), ng_l2cap_cmd_hdr_t *);                           \
 355         c->code = NG_L2CAP_ECHO_REQ;                                    \
 356         c->ident = (_ident);                                            \
 357         c->length = 0;                                                  \
 358                                                                         \
 359         if ((_data) != NULL) {                                          \
 360                 m_copyback((_m), sizeof(*c), (_size), (_data));         \
 361                 c->length += (_size);                                   \
 362         }                                                               \
 363                                                                         \
 364         c->length = htole16(c->length);                                 \
 365 } while (0)
 366
 367 /* L2CAP_InfoReq */
 368 #define _ng_l2cap_info_req(_m, _ident, _type)                           \
 369 do {                                                                    \
 370         struct _info_req {                                              \
 371                 ng_l2cap_cmd_hdr_t       hdr;                           \
 372                 ng_l2cap_info_req_cp     param;                         \
 373         } __attribute__ ((packed))      *c = NULL;                      \
 374                                                                         \
 375         MGETHDR((_m), M_NOWAIT, MT_DATA);                               \
 376         if ((_m) == NULL)                                               \
 377                 break;                                                  \
 378                                                                         \
 379         (_m)->m_pkthdr.len = (_m)->m_len = sizeof(*c);                  \
 380                                                                         \
 381         c = mtod((_m), struct _info_req *);                             \
 382         c->hdr.code = NG_L2CAP_INFO_REQ;                                \
 383         c->hdr.ident = (_ident);                                        \
 384         c->hdr.length = htole16(sizeof(c->param));                      \
 385                                                                         \
 386         c->param.type = htole16((_type));                               \
 387 } while (0)
 388
 389 /* L2CAP_InfoRsp */
 390 #define _ng_l2cap_info_rsp(_m, _ident, _type, _result, _mtu)            \
 391 do {                                                                    \
 392         struct _info_rsp {                                              \
 393                 ng_l2cap_cmd_hdr_t       hdr;                           \
 394                 ng_l2cap_info_rsp_cp     param;                         \
 395                 ng_l2cap_info_rsp_data_t data;                          \
 396         } __attribute__ ((packed))      *c = NULL;                      \
 397                                                                         \
 398         MGETHDR((_m), M_NOWAIT, MT_DATA);                               \
 399         if ((_m) == NULL)                                               \
 400                 break;                                                  \
 401                                                                         \
 402         c = mtod((_m), struct _info_rsp *);                             \
 403         c->hdr.code = NG_L2CAP_INFO_RSP;                                \
 404         c->hdr.ident = (_ident);                                        \
 405         c->hdr.length = sizeof(c->param);                               \
 406                                                                         \
 407         c->param.type = htole16((_type));                               \
 408         c->param.result = htole16((_result));                           \
 409                                                                         \
 410         if ((_result) == NG_L2CAP_SUCCESS) {                            \
 411                 switch ((_type)) {                                      \
 412                 case NG_L2CAP_CONNLESS_MTU:                             \
 413                         c->data.mtu.mtu = htole16((_mtu));              \
 414                         c->hdr.length += sizeof((c->data.mtu.mtu));     \
 415                         break;                                          \
 416                 }                                                       \
 417         }                                                               \
 418                                                                         \
 419         (_m)->m_pkthdr.len = (_m)->m_len = sizeof(c->hdr) +             \
 420                                         c->hdr.length;                  \
 421                                                                         \
 422         c->hdr.length = htole16(c->hdr.length);                         \
 423 } while (0)
 424
 425 void ng_l2cap_con_wakeup              (ng_l2cap_con_p);
 426 void ng_l2cap_con_fail                (ng_l2cap_con_p, u_int16_t);
 427 void ng_l2cap_process_command_timeout (node_p, hook_p, void *, int);
 428
 429 #endif /* ndef _NETGRAPH_L2CAP_CMDS_H_ */