1 /*-
2  * l2cap.c
3  *
4  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
5  *
6  * Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com>
7  * All rights reserved.
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in the
16  *    documentation and/or other materials provided with the distribution.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28  * SUCH DAMAGE.
29  *
30  * $Id: l2cap.c,v 1.5 2003/05/16 19:52:37 max Exp $
31  * $FreeBSD: stable/12/usr.sbin/bluetooth/l2control/l2cap.c 326276 2017-11-27 15:37:16Z pfg $
32  */
33 
34 #include <sys/ioctl.h>
35 #define L2CAP_SOCKET_CHECKED
36 #include <bluetooth.h>
37 #include <errno.h>
38 #include <stdio.h>
39 #include <stdlib.h>
40 #include <string.h>
41 #include "l2control.h"
42 
43 #define	SIZE(x)	(sizeof((x))/sizeof((x)[0]))
44 
45 /* Print BDADDR */
46 static char *
bdaddrpr(bdaddr_t const * ba)47 bdaddrpr(bdaddr_t const *ba)
48 {
49 	extern int	 numeric_bdaddr;
50 	static char	 str[24];
51 	struct hostent	*he = NULL;
52 
53 	if (memcmp(ba, NG_HCI_BDADDR_ANY, sizeof(*ba)) == 0) {
54 		str[0] = '*';
55 		str[1] = 0;
56 
57 		return (str);
58 	}
59 
60 	if (!numeric_bdaddr &&
61 	    (he = bt_gethostbyaddr((char *)ba, sizeof(*ba), AF_BLUETOOTH)) != NULL) {
62 		strlcpy(str, he->h_name, sizeof(str));
63 
64 		return (str);
65 	}
66 
67 	bt_ntoa(ba, str);
68 
69 	return (str);
70 } /* bdaddrpr */
71 
72 /* Send read_node_flags command to the node */
73 static int
l2cap_read_node_flags(int s,int argc,char ** argv)74 l2cap_read_node_flags(int s, int argc, char **argv)
75 {
76 	struct ng_btsocket_l2cap_raw_node_flags	r;
77 
78 	memset(&r, 0, sizeof(r));
79 	if (ioctl(s, SIOC_L2CAP_NODE_GET_FLAGS, &r, sizeof(r)) < 0)
80 		return (ERROR);
81 
82 	fprintf(stdout, "Connectionless traffic flags:\n");
83 	fprintf(stdout, "\tSDP: %s\n",
84 		(r.flags & NG_L2CAP_CLT_SDP_DISABLED)? "disabled" : "enabled");
85 	fprintf(stdout, "\tRFCOMM: %s\n",
86 		(r.flags & NG_L2CAP_CLT_RFCOMM_DISABLED)? "disabled":"enabled");
87 	fprintf(stdout, "\tTCP: %s\n",
88 		(r.flags & NG_L2CAP_CLT_TCP_DISABLED)? "disabled" : "enabled");
89 
90 	return (OK);
91 } /* l2cap_read_node_flags */
92 
93 /* Send read_debug_level command to the node */
94 static int
l2cap_read_debug_level(int s,int argc,char ** argv)95 l2cap_read_debug_level(int s, int argc, char **argv)
96 {
97 	struct ng_btsocket_l2cap_raw_node_debug	r;
98 
99 	memset(&r, 0, sizeof(r));
100 	if (ioctl(s, SIOC_L2CAP_NODE_GET_DEBUG, &r, sizeof(r)) < 0)
101 		return (ERROR);
102 
103 	fprintf(stdout, "Debug level: %d\n", r.debug);
104 
105 	return (OK);
106 } /* l2cap_read_debug_level */
107 
108 /* Send write_debug_level command to the node */
109 static int
l2cap_write_debug_level(int s,int argc,char ** argv)110 l2cap_write_debug_level(int s, int argc, char **argv)
111 {
112 	struct ng_btsocket_l2cap_raw_node_debug	r;
113 
114 	memset(&r, 0, sizeof(r));
115 	switch (argc) {
116 	case 1:
117 		r.debug = atoi(argv[0]);
118 		break;
119 
120 	default:
121 		return (USAGE);
122 	}
123 
124 	if (ioctl(s, SIOC_L2CAP_NODE_SET_DEBUG, &r, sizeof(r)) < 0)
125 		return (ERROR);
126 
127 	return (OK);
128 } /* l2cap_write_debug_level */
129 
130 /* Send read_connection_list command to the node */
131 static int
l2cap_read_connection_list(int s,int argc,char ** argv)132 l2cap_read_connection_list(int s, int argc, char **argv)
133 {
134 	static char const * const	state[] = {
135 		/* NG_L2CAP_CON_CLOSED */	"CLOSED",
136 		/* NG_L2CAP_W4_LP_CON_CFM */	"W4_LP_CON_CFM",
137 		/* NG_L2CAP_CON_OPEN */		"OPEN"
138 	};
139 #define con_state2str(x)	((x) >= SIZE(state)? "UNKNOWN" : state[(x)])
140 
141 	struct ng_btsocket_l2cap_raw_con_list	r;
142 	int					n, error = OK;
143 
144 	memset(&r, 0, sizeof(r));
145 	r.num_connections = NG_L2CAP_MAX_CON_NUM;
146 	r.connections = calloc(NG_L2CAP_MAX_CON_NUM,
147 				sizeof(ng_l2cap_node_con_ep));
148 	if (r.connections == NULL) {
149 		errno = ENOMEM;
150 		return (ERROR);
151 	}
152 
153 	if (ioctl(s, SIOC_L2CAP_NODE_GET_CON_LIST, &r, sizeof(r)) < 0) {
154 		error = ERROR;
155 		goto out;
156 	}
157 
158 	fprintf(stdout, "L2CAP connections:\n");
159 	fprintf(stdout,
160 "Remote BD_ADDR    Handle Flags Pending State\n");
161 	for (n = 0; n < r.num_connections; n++) {
162 		fprintf(stdout,
163 			"%-17.17s " \
164 			"%6d " \
165 			"%c%c%c%c%c " \
166 			"%7d " \
167 			"%s\n",
168 			bdaddrpr(&r.connections[n].remote),
169 			r.connections[n].con_handle,
170 			((r.connections[n].flags & NG_L2CAP_CON_OUTGOING)? 'O' : 'I'),
171 			((r.connections[n].flags & NG_L2CAP_CON_LP_TIMO)? 'L' : ' '),
172 			((r.connections[n].flags & NG_L2CAP_CON_AUTO_DISCON_TIMO)? 'D' : ' '),
173 			((r.connections[n].flags & NG_L2CAP_CON_TX)? 'T' : ' '),
174 			((r.connections[n].flags & NG_L2CAP_CON_RX)? 'R' : ' '),
175 			r.connections[n].pending,
176 			con_state2str(r.connections[n].state));
177 	}
178 out:
179 	free(r.connections);
180 
181 	return (error);
182 } /* l2cap_read_connection_list */
183 
184 /* Send read_channel_list command to the node */
185 static int
l2cap_read_channel_list(int s,int argc,char ** argv)186 l2cap_read_channel_list(int s, int argc, char **argv)
187 {
188 	static char const * const	state[] = {
189 		/* NG_L2CAP_CLOSED */			"CLOSED",
190 		/* NG_L2CAP_W4_L2CAP_CON_RSP */		"W4_L2CAP_CON_RSP",
191 		/* NG_L2CAP_W4_L2CA_CON_RSP */		"W4_L2CA_CON_RSP",
192 		/* NG_L2CAP_CONFIG */			"CONFIG",
193 		/* NG_L2CAP_OPEN */			"OPEN",
194 		/* NG_L2CAP_W4_L2CAP_DISCON_RSP */	"W4_L2CAP_DISCON_RSP",
195 		/* NG_L2CAP_W4_L2CA_DISCON_RSP */	"W4_L2CA_DISCON_RSP"
196 	};
197 #define ch_state2str(x)	((x) >= SIZE(state)? "UNKNOWN" : state[(x)])
198 
199 	struct ng_btsocket_l2cap_raw_chan_list	r;
200 	int					n, error = OK;
201 
202 	memset(&r, 0, sizeof(r));
203 	r.num_channels = NG_L2CAP_MAX_CHAN_NUM;
204 	r.channels = calloc(NG_L2CAP_MAX_CHAN_NUM,
205 				sizeof(ng_l2cap_node_chan_ep));
206 	if (r.channels == NULL) {
207 		errno = ENOMEM;
208 		return (ERROR);
209 	}
210 
211 	if (ioctl(s, SIOC_L2CAP_NODE_GET_CHAN_LIST, &r, sizeof(r)) < 0) {
212 		error = ERROR;
213 		goto out;
214 	}
215 
216 	fprintf(stdout, "L2CAP channels:\n");
217 	fprintf(stdout,
218 "Remote BD_ADDR     SCID/ DCID   PSM  IMTU/ OMTU State\n");
219 	for (n = 0; n < r.num_channels; n++) {
220 		fprintf(stdout,
221 			"%-17.17s " \
222 			"%5d/%5d %5d " \
223 			"%5d/%5d " \
224 			"%s\n",
225 			bdaddrpr(&r.channels[n].remote),
226 			r.channels[n].scid, r.channels[n].dcid,
227 			r.channels[n].psm, r.channels[n].imtu,
228 			r.channels[n].omtu,
229 			ch_state2str(r.channels[n].state));
230 	}
231 out:
232 	free(r.channels);
233 
234 	return (error);
235 } /* l2cap_read_channel_list */
236 
237 /* Send read_auto_disconnect_timeout command to the node */
238 static int
l2cap_read_auto_disconnect_timeout(int s,int argc,char ** argv)239 l2cap_read_auto_disconnect_timeout(int s, int argc, char **argv)
240 {
241 	struct ng_btsocket_l2cap_raw_auto_discon_timo	r;
242 
243 	memset(&r, 0, sizeof(r));
244 	if (ioctl(s, SIOC_L2CAP_NODE_GET_AUTO_DISCON_TIMO, &r, sizeof(r)) < 0)
245 		return (ERROR);
246 
247 	if (r.timeout != 0)
248 		fprintf(stdout, "Auto disconnect timeout: %d sec\n", r.timeout);
249 	else
250 		fprintf(stdout, "Auto disconnect disabled\n");
251 
252 	return (OK);
253 } /* l2cap_read_auto_disconnect_timeout */
254 
255 /* Send write_auto_disconnect_timeout command to the node */
256 static int
l2cap_write_auto_disconnect_timeout(int s,int argc,char ** argv)257 l2cap_write_auto_disconnect_timeout(int s, int argc, char **argv)
258 {
259 	struct ng_btsocket_l2cap_raw_auto_discon_timo	r;
260 
261 	memset(&r, 0, sizeof(r));
262 	switch (argc) {
263 	case 1:
264 		r.timeout = atoi(argv[0]);
265 		break;
266 
267 	default:
268 		return (USAGE);
269 	}
270 
271 	if (ioctl(s, SIOC_L2CAP_NODE_SET_AUTO_DISCON_TIMO, &r, sizeof(r)) < 0)
272 		return (ERROR);
273 
274 	return (OK);
275 } /* l2cap_write_auto_disconnect_timeout */
276 
277 struct l2cap_command	l2cap_commands[] = {
278 {
279 "read_node_flags",
280 "Get L2CAP node flags",
281 &l2cap_read_node_flags
282 },
283 {
284 "read_debug_level",
285 "Get L2CAP node debug level",
286 &l2cap_read_debug_level
287 },
288 {
289 "write_debug_level <level>",
290 "Set L2CAP node debug level",
291 &l2cap_write_debug_level
292 },
293 {
294 "read_connection_list",
295 "Read list of the L2CAP connections",
296 &l2cap_read_connection_list
297 },
298 {
299 "read_channel_list",
300 "Read list of the L2CAP channels",
301 &l2cap_read_channel_list
302 },
303 {
304 "read_auto_disconnect_timeout",
305 "Get L2CAP node auto disconnect timeout (in sec)",
306 &l2cap_read_auto_disconnect_timeout
307 },
308 {
309 "write_auto_disconnect_timeout <timeout>",
310 "Set L2CAP node auto disconnect timeout (in sec)",
311 &l2cap_write_auto_disconnect_timeout
312 },
313 {
314 NULL,
315 }};
316 
317