2002-03-09 05:12:35 +08:00
|
|
|
/*
|
2004-04-28 20:44:32 +08:00
|
|
|
*
|
|
|
|
* BlueZ - Bluetooth protocol stack for Linux
|
|
|
|
*
|
|
|
|
* Copyright (C) 2000-2001 Qualcomm Incorporated
|
|
|
|
* Copyright (C) 2002-2003 Maxim Krasnyansky <maxk@qualcomm.com>
|
2009-01-02 02:33:20 +08:00
|
|
|
* Copyright (C) 2002-2009 Marcel Holtmann <marcel@holtmann.org>
|
2004-04-28 20:44:32 +08:00
|
|
|
*
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
2005-10-30 06:36:31 +08:00
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
2004-04-28 20:44:32 +08:00
|
|
|
*
|
2005-10-30 06:36:31 +08:00
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
2004-04-28 20:44:32 +08:00
|
|
|
*
|
2005-10-30 06:36:31 +08:00
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
2004-04-28 20:44:32 +08:00
|
|
|
*
|
2002-03-09 05:12:35 +08:00
|
|
|
*/
|
|
|
|
|
2004-04-28 20:44:32 +08:00
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
#include <config.h>
|
|
|
|
#endif
|
|
|
|
|
2002-03-09 05:12:35 +08:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <errno.h>
|
2003-05-30 05:27:00 +08:00
|
|
|
#include <ctype.h>
|
2006-06-14 19:23:24 +08:00
|
|
|
#include <fcntl.h>
|
2005-01-12 05:42:38 +08:00
|
|
|
#include <unistd.h>
|
|
|
|
#include <stdlib.h>
|
2005-01-29 01:24:40 +08:00
|
|
|
#include <getopt.h>
|
2005-01-12 05:42:38 +08:00
|
|
|
#include <syslog.h>
|
2002-03-09 05:12:35 +08:00
|
|
|
#include <signal.h>
|
2003-05-30 05:27:00 +08:00
|
|
|
#include <sys/time.h>
|
2005-02-10 22:07:09 +08:00
|
|
|
#include <sys/poll.h>
|
2008-06-25 15:13:46 +08:00
|
|
|
#include <sys/ioctl.h>
|
2002-03-09 05:12:35 +08:00
|
|
|
#include <sys/socket.h>
|
|
|
|
|
2002-08-20 12:39:54 +08:00
|
|
|
#include <bluetooth/bluetooth.h>
|
2004-11-17 16:28:52 +08:00
|
|
|
#include <bluetooth/hci.h>
|
|
|
|
#include <bluetooth/hci_lib.h>
|
2002-08-20 12:39:54 +08:00
|
|
|
#include <bluetooth/l2cap.h>
|
2002-03-09 05:12:35 +08:00
|
|
|
|
2005-01-12 05:42:38 +08:00
|
|
|
#define NIBBLE_TO_ASCII(c) ((c) < 0x0a ? (c) + 0x30 : (c) + 0x57)
|
2003-05-30 05:27:00 +08:00
|
|
|
|
2002-03-09 05:12:35 +08:00
|
|
|
/* Test modes */
|
|
|
|
enum {
|
|
|
|
SEND,
|
|
|
|
RECV,
|
|
|
|
RECONNECT,
|
|
|
|
MULTY,
|
|
|
|
DUMP,
|
2002-03-27 13:30:35 +08:00
|
|
|
CONNECT,
|
|
|
|
CRECV,
|
2003-05-30 05:27:00 +08:00
|
|
|
LSEND,
|
|
|
|
SENDDUMP,
|
2006-09-24 19:36:24 +08:00
|
|
|
LSENDDUMP,
|
2009-01-13 18:17:17 +08:00
|
|
|
INFOREQ,
|
|
|
|
PAIRING,
|
2002-03-09 05:12:35 +08:00
|
|
|
};
|
|
|
|
|
2005-01-11 18:10:34 +08:00
|
|
|
static unsigned char *buf;
|
2002-03-09 05:12:35 +08:00
|
|
|
|
|
|
|
/* Default mtu */
|
2005-01-11 18:10:34 +08:00
|
|
|
static int imtu = 672;
|
|
|
|
static int omtu = 0;
|
2002-03-09 05:12:35 +08:00
|
|
|
|
|
|
|
/* Default data size */
|
2005-02-10 22:07:09 +08:00
|
|
|
static long data_size = -1;
|
2009-01-15 17:44:52 +08:00
|
|
|
static long buffer_size = 2048;
|
2002-03-09 05:12:35 +08:00
|
|
|
|
|
|
|
/* Default addr and psm */
|
2005-01-11 18:10:34 +08:00
|
|
|
static bdaddr_t bdaddr;
|
|
|
|
static unsigned short psm = 10;
|
2002-03-09 05:12:35 +08:00
|
|
|
|
2005-01-28 02:16:11 +08:00
|
|
|
/* Default number of frames to send (-1 = infinite) */
|
|
|
|
static int num_frames = -1;
|
2003-05-16 15:11:27 +08:00
|
|
|
|
2006-03-24 06:15:09 +08:00
|
|
|
/* Default number of consecutive frames before the delay */
|
|
|
|
static int count = 1;
|
|
|
|
|
|
|
|
/* Default delay after sending count number of frames */
|
|
|
|
static unsigned long delay = 0;
|
|
|
|
|
2006-06-14 19:23:24 +08:00
|
|
|
static char *filename = NULL;
|
|
|
|
|
2008-06-15 22:09:07 +08:00
|
|
|
static int rfcmode = 0;
|
2005-01-11 18:10:34 +08:00
|
|
|
static int master = 0;
|
|
|
|
static int auth = 0;
|
|
|
|
static int encrypt = 0;
|
|
|
|
static int secure = 0;
|
|
|
|
static int socktype = SOCK_SEQPACKET;
|
|
|
|
static int linger = 0;
|
|
|
|
static int reliable = 0;
|
2008-06-24 02:45:52 +08:00
|
|
|
static int timestamp = 0;
|
2009-01-14 21:39:45 +08:00
|
|
|
static int defer_setup = 0;
|
2002-03-09 05:12:35 +08:00
|
|
|
|
2005-01-11 18:10:34 +08:00
|
|
|
static float tv2fl(struct timeval tv)
|
2002-03-09 05:12:35 +08:00
|
|
|
{
|
|
|
|
return (float)tv.tv_sec + (float)(tv.tv_usec/1000000.0);
|
|
|
|
}
|
|
|
|
|
2005-01-11 18:10:34 +08:00
|
|
|
static char *ltoh(unsigned long c, char* s)
|
2003-05-30 05:27:00 +08:00
|
|
|
{
|
|
|
|
int c1;
|
|
|
|
|
|
|
|
c1 = (c >> 28) & 0x0f;
|
|
|
|
*(s++) = NIBBLE_TO_ASCII (c1);
|
|
|
|
c1 = (c >> 24) & 0x0f;
|
|
|
|
*(s++) = NIBBLE_TO_ASCII (c1);
|
|
|
|
c1 = (c >> 20) & 0x0f;
|
|
|
|
*(s++) = NIBBLE_TO_ASCII (c1);
|
|
|
|
c1 = (c >> 16) & 0x0f;
|
|
|
|
*(s++) = NIBBLE_TO_ASCII (c1);
|
|
|
|
c1 = (c >> 12) & 0x0f;
|
|
|
|
*(s++) = NIBBLE_TO_ASCII (c1);
|
|
|
|
c1 = (c >> 8) & 0x0f;
|
|
|
|
*(s++) = NIBBLE_TO_ASCII (c1);
|
|
|
|
c1 = (c >> 4) & 0x0f;
|
|
|
|
*(s++) = NIBBLE_TO_ASCII (c1);
|
|
|
|
c1 = c & 0x0f;
|
|
|
|
*(s++) = NIBBLE_TO_ASCII (c1);
|
|
|
|
*s = 0;
|
2005-01-12 05:42:38 +08:00
|
|
|
return s;
|
2003-05-30 05:27:00 +08:00
|
|
|
}
|
|
|
|
|
2005-01-11 18:10:34 +08:00
|
|
|
static char *ctoh(char c, char* s)
|
2003-05-30 05:27:00 +08:00
|
|
|
{
|
|
|
|
char c1;
|
|
|
|
|
|
|
|
c1 = (c >> 4) & 0x0f;
|
|
|
|
*(s++) = NIBBLE_TO_ASCII (c1);
|
|
|
|
c1 = c & 0x0f;
|
|
|
|
*(s++) = NIBBLE_TO_ASCII (c1);
|
|
|
|
*s = 0;
|
2005-01-12 05:42:38 +08:00
|
|
|
return s;
|
2003-05-30 05:27:00 +08:00
|
|
|
}
|
|
|
|
|
2005-07-06 05:15:41 +08:00
|
|
|
static void hexdump(unsigned char *s, unsigned long l)
|
2003-05-30 05:27:00 +08:00
|
|
|
{
|
|
|
|
char bfr[80];
|
|
|
|
char *pb;
|
|
|
|
unsigned long i, n = 0;
|
2005-01-11 18:10:34 +08:00
|
|
|
|
2003-05-30 05:27:00 +08:00
|
|
|
if (l == 0)
|
|
|
|
return;
|
2005-01-11 18:10:34 +08:00
|
|
|
|
2003-05-30 05:27:00 +08:00
|
|
|
while (n < l) {
|
|
|
|
pb = bfr;
|
|
|
|
pb = ltoh (n, pb);
|
|
|
|
*(pb++) = ':';
|
|
|
|
*(pb++) = ' ';
|
|
|
|
for (i = 0; i < 16; i++) {
|
|
|
|
if (n + i >= l) {
|
|
|
|
*(pb++) = ' ';
|
|
|
|
*(pb++) = ' ';
|
|
|
|
} else
|
|
|
|
pb = ctoh (*(s + i), pb);
|
|
|
|
*(pb++) = ' ';
|
|
|
|
}
|
|
|
|
*(pb++) = ' ';
|
|
|
|
for (i = 0; i < 16; i++) {
|
|
|
|
if (n + i >= l)
|
|
|
|
break;
|
|
|
|
else
|
|
|
|
*(pb++) = (isprint (*(s + i)) ? *(s + i) : '.');
|
|
|
|
}
|
2005-01-11 18:10:34 +08:00
|
|
|
*pb = 0;
|
2003-05-30 05:27:00 +08:00
|
|
|
n += 16;
|
|
|
|
s += 16;
|
|
|
|
puts(bfr);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-01-11 18:10:34 +08:00
|
|
|
static int do_connect(char *svr)
|
2002-03-09 05:12:35 +08:00
|
|
|
{
|
2005-01-28 02:16:11 +08:00
|
|
|
struct sockaddr_l2 addr;
|
2002-03-09 05:12:35 +08:00
|
|
|
struct l2cap_options opts;
|
2004-12-26 22:10:24 +08:00
|
|
|
struct l2cap_conninfo conn;
|
2005-01-28 02:16:11 +08:00
|
|
|
socklen_t optlen;
|
|
|
|
int sk, opt;
|
2002-03-09 05:12:35 +08:00
|
|
|
|
2005-01-28 02:16:11 +08:00
|
|
|
/* Create socket */
|
|
|
|
sk = socket(PF_BLUETOOTH, socktype, BTPROTO_L2CAP);
|
|
|
|
if (sk < 0) {
|
|
|
|
syslog(LOG_ERR, "Can't create socket: %s (%d)",
|
|
|
|
strerror(errno), errno);
|
2002-03-09 05:12:35 +08:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2005-01-28 02:16:11 +08:00
|
|
|
/* Bind to local address */
|
|
|
|
memset(&addr, 0, sizeof(addr));
|
|
|
|
addr.l2_family = AF_BLUETOOTH;
|
|
|
|
bacpy(&addr.l2_bdaddr, &bdaddr);
|
|
|
|
|
|
|
|
if (bind(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
|
|
|
|
syslog(LOG_ERR, "Can't bind socket: %s (%d)",
|
|
|
|
strerror(errno), errno);
|
|
|
|
goto error;
|
2002-03-09 05:12:35 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Get default options */
|
2004-12-26 01:43:16 +08:00
|
|
|
memset(&opts, 0, sizeof(opts));
|
2005-01-28 02:16:11 +08:00
|
|
|
optlen = sizeof(opts);
|
|
|
|
|
|
|
|
if (getsockopt(sk, SOL_L2CAP, L2CAP_OPTIONS, &opts, &optlen) < 0) {
|
|
|
|
syslog(LOG_ERR, "Can't get default L2CAP options: %s (%d)",
|
|
|
|
strerror(errno), errno);
|
|
|
|
goto error;
|
2002-03-09 05:12:35 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Set new options */
|
|
|
|
opts.omtu = omtu;
|
|
|
|
opts.imtu = imtu;
|
2008-06-15 22:09:07 +08:00
|
|
|
if (rfcmode > 0)
|
|
|
|
opts.mode = rfcmode;
|
2005-01-28 02:16:11 +08:00
|
|
|
|
|
|
|
if (setsockopt(sk, SOL_L2CAP, L2CAP_OPTIONS, &opts, sizeof(opts)) < 0) {
|
|
|
|
syslog(LOG_ERR, "Can't set L2CAP options: %s (%d)",
|
|
|
|
strerror(errno), errno);
|
|
|
|
goto error;
|
2002-03-09 05:12:35 +08:00
|
|
|
}
|
|
|
|
|
2008-06-25 15:13:46 +08:00
|
|
|
#if 0
|
2008-06-24 02:45:52 +08:00
|
|
|
/* Enable SO_TIMESTAMP */
|
|
|
|
if (timestamp) {
|
|
|
|
int t = 1;
|
|
|
|
|
|
|
|
if (setsockopt(sk, SOL_SOCKET, SO_TIMESTAMP, &t, sizeof(t)) < 0) {
|
|
|
|
syslog(LOG_ERR, "Can't enable SO_TIMESTAMP: %s (%d)",
|
|
|
|
strerror(errno), errno);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
}
|
2008-06-25 15:13:46 +08:00
|
|
|
#endif
|
2008-06-24 02:45:52 +08:00
|
|
|
|
2003-05-17 08:45:58 +08:00
|
|
|
/* Enable SO_LINGER */
|
|
|
|
if (linger) {
|
|
|
|
struct linger l = { .l_onoff = 1, .l_linger = linger };
|
2005-01-28 02:16:11 +08:00
|
|
|
|
|
|
|
if (setsockopt(sk, SOL_SOCKET, SO_LINGER, &l, sizeof(l)) < 0) {
|
2005-01-12 05:42:38 +08:00
|
|
|
syslog(LOG_ERR, "Can't enable SO_LINGER: %s (%d)",
|
2005-01-28 02:16:11 +08:00
|
|
|
strerror(errno), errno);
|
2008-06-24 02:45:52 +08:00
|
|
|
goto error;
|
2003-05-17 08:45:58 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-05-29 20:05:10 +08:00
|
|
|
/* Set link mode */
|
|
|
|
opt = 0;
|
|
|
|
if (reliable)
|
2005-01-12 05:42:38 +08:00
|
|
|
opt |= L2CAP_LM_RELIABLE;
|
2008-07-10 17:38:39 +08:00
|
|
|
if (master)
|
|
|
|
opt |= L2CAP_LM_MASTER;
|
|
|
|
if (auth)
|
|
|
|
opt |= L2CAP_LM_AUTH;
|
|
|
|
if (encrypt)
|
|
|
|
opt |= L2CAP_LM_ENCRYPT;
|
|
|
|
if (secure)
|
|
|
|
opt |= L2CAP_LM_SECURE;
|
2003-05-29 20:05:10 +08:00
|
|
|
|
2005-01-28 02:16:11 +08:00
|
|
|
if (setsockopt(sk, SOL_L2CAP, L2CAP_LM, &opt, sizeof(opt)) < 0) {
|
|
|
|
syslog(LOG_ERR, "Can't set L2CAP link mode: %s (%d)",
|
|
|
|
strerror(errno), errno);
|
|
|
|
goto error;
|
2003-05-29 20:05:10 +08:00
|
|
|
}
|
|
|
|
|
2005-01-28 02:16:11 +08:00
|
|
|
/* Connect to remote device */
|
|
|
|
memset(&addr, 0, sizeof(addr));
|
|
|
|
addr.l2_family = AF_BLUETOOTH;
|
|
|
|
str2ba(svr, &addr.l2_bdaddr);
|
|
|
|
addr.l2_psm = htobs(psm);
|
|
|
|
|
|
|
|
if (connect(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0 ) {
|
|
|
|
syslog(LOG_ERR, "Can't connect: %s (%d)",
|
|
|
|
strerror(errno), errno);
|
|
|
|
goto error;
|
2002-03-09 05:12:35 +08:00
|
|
|
}
|
|
|
|
|
2005-01-28 02:16:11 +08:00
|
|
|
/* Get current options */
|
2004-12-26 01:43:16 +08:00
|
|
|
memset(&opts, 0, sizeof(opts));
|
2005-01-28 02:16:11 +08:00
|
|
|
optlen = sizeof(opts);
|
|
|
|
|
|
|
|
if (getsockopt(sk, SOL_L2CAP, L2CAP_OPTIONS, &opts, &optlen) < 0) {
|
|
|
|
syslog(LOG_ERR, "Can't get L2CAP options: %s (%d)",
|
|
|
|
strerror(errno), errno);
|
|
|
|
goto error;
|
2002-03-09 05:12:35 +08:00
|
|
|
}
|
|
|
|
|
2005-01-28 02:16:11 +08:00
|
|
|
/* Get connection information */
|
2004-12-26 22:10:24 +08:00
|
|
|
memset(&conn, 0, sizeof(conn));
|
2005-01-28 02:16:11 +08:00
|
|
|
optlen = sizeof(conn);
|
|
|
|
|
|
|
|
if (getsockopt(sk, SOL_L2CAP, L2CAP_CONNINFO, &conn, &optlen) < 0) {
|
|
|
|
syslog(LOG_ERR, "Can't get L2CAP connection information: %s (%d)",
|
|
|
|
strerror(errno), errno);
|
|
|
|
goto error;
|
2004-12-26 22:10:24 +08:00
|
|
|
}
|
|
|
|
|
2005-01-28 02:16:11 +08:00
|
|
|
syslog(LOG_INFO, "Connected [imtu %d, omtu %d, flush_to %d, "
|
|
|
|
"mode %d, handle %d, class 0x%02x%02x%02x]",
|
2004-12-26 22:10:24 +08:00
|
|
|
opts.imtu, opts.omtu, opts.flush_to, opts.mode, conn.hci_handle,
|
|
|
|
conn.dev_class[2], conn.dev_class[1], conn.dev_class[0]);
|
2002-03-09 05:12:35 +08:00
|
|
|
|
2009-01-15 17:44:52 +08:00
|
|
|
omtu = (opts.omtu > buffer_size) ? buffer_size : opts.omtu;
|
|
|
|
imtu = (opts.imtu > buffer_size) ? buffer_size : opts.imtu;
|
2005-05-20 01:06:50 +08:00
|
|
|
|
2005-01-28 02:16:11 +08:00
|
|
|
return sk;
|
|
|
|
|
|
|
|
error:
|
|
|
|
close(sk);
|
|
|
|
return -1;
|
2002-03-09 05:12:35 +08:00
|
|
|
}
|
|
|
|
|
2005-01-11 18:10:34 +08:00
|
|
|
static void do_listen(void (*handler)(int sk))
|
2002-03-09 05:12:35 +08:00
|
|
|
{
|
2005-01-28 02:16:11 +08:00
|
|
|
struct sockaddr_l2 addr;
|
2002-03-09 05:12:35 +08:00
|
|
|
struct l2cap_options opts;
|
2005-01-25 02:33:49 +08:00
|
|
|
struct l2cap_conninfo conn;
|
2005-01-28 02:16:11 +08:00
|
|
|
socklen_t optlen;
|
|
|
|
int sk, nsk, opt;
|
2005-01-11 18:10:34 +08:00
|
|
|
char ba[18];
|
2002-03-09 05:12:35 +08:00
|
|
|
|
2005-01-28 02:16:11 +08:00
|
|
|
/* Create socket */
|
|
|
|
sk = socket(PF_BLUETOOTH, socktype, BTPROTO_L2CAP);
|
|
|
|
if (sk < 0) {
|
|
|
|
syslog(LOG_ERR, "Can't create socket: %s (%d)",
|
|
|
|
strerror(errno), errno);
|
2002-03-09 05:12:35 +08:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
2005-01-28 02:16:11 +08:00
|
|
|
/* Bind to local address */
|
2009-03-31 06:39:36 +08:00
|
|
|
memset(&addr, 0, sizeof(addr));
|
2005-01-28 02:16:11 +08:00
|
|
|
addr.l2_family = AF_BLUETOOTH;
|
|
|
|
bacpy(&addr.l2_bdaddr, &bdaddr);
|
|
|
|
addr.l2_psm = htobs(psm);
|
|
|
|
|
|
|
|
if (bind(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
|
|
|
|
syslog(LOG_ERR, "Can't bind socket: %s (%d)",
|
|
|
|
strerror(errno), errno);
|
|
|
|
goto error;
|
2002-03-09 05:12:35 +08:00
|
|
|
}
|
|
|
|
|
2002-07-21 02:53:27 +08:00
|
|
|
/* Set link mode */
|
|
|
|
opt = 0;
|
2003-05-29 20:05:10 +08:00
|
|
|
if (reliable)
|
|
|
|
opt |= L2CAP_LM_RELIABLE;
|
2002-07-21 02:53:27 +08:00
|
|
|
if (master)
|
2004-11-17 16:28:52 +08:00
|
|
|
opt |= L2CAP_LM_MASTER;
|
2002-07-21 02:53:27 +08:00
|
|
|
if (auth)
|
2004-11-17 16:28:52 +08:00
|
|
|
opt |= L2CAP_LM_AUTH;
|
2002-07-21 02:53:27 +08:00
|
|
|
if (encrypt)
|
2004-11-17 16:28:52 +08:00
|
|
|
opt |= L2CAP_LM_ENCRYPT;
|
|
|
|
if (secure)
|
|
|
|
opt |= L2CAP_LM_SECURE;
|
2002-07-21 02:53:27 +08:00
|
|
|
|
2005-01-28 02:16:11 +08:00
|
|
|
if (opt && setsockopt(sk, SOL_L2CAP, L2CAP_LM, &opt, sizeof(opt)) < 0) {
|
|
|
|
syslog(LOG_ERR, "Can't set L2CAP link mode: %s (%d)",
|
|
|
|
strerror(errno), errno);
|
|
|
|
goto error;
|
2002-03-09 05:12:35 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Get default options */
|
2005-01-28 02:16:11 +08:00
|
|
|
memset(&opts, 0, sizeof(opts));
|
|
|
|
optlen = sizeof(opts);
|
|
|
|
|
|
|
|
if (getsockopt(sk, SOL_L2CAP, L2CAP_OPTIONS, &opts, &optlen) < 0) {
|
|
|
|
syslog(LOG_ERR, "Can't get default L2CAP options: %s (%d)",
|
|
|
|
strerror(errno), errno);
|
|
|
|
goto error;
|
2002-03-09 05:12:35 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Set new options */
|
2007-05-23 19:50:49 +08:00
|
|
|
opts.omtu = omtu;
|
2002-03-09 05:12:35 +08:00
|
|
|
opts.imtu = imtu;
|
2008-06-15 22:09:07 +08:00
|
|
|
if (rfcmode > 0)
|
|
|
|
opts.mode = rfcmode;
|
2005-01-28 02:16:11 +08:00
|
|
|
|
|
|
|
if (setsockopt(sk, SOL_L2CAP, L2CAP_OPTIONS, &opts, sizeof(opts)) < 0) {
|
|
|
|
syslog(LOG_ERR, "Can't set L2CAP options: %s (%d)",
|
|
|
|
strerror(errno), errno);
|
|
|
|
goto error;
|
2002-03-09 05:12:35 +08:00
|
|
|
}
|
|
|
|
|
2002-07-21 02:53:27 +08:00
|
|
|
if (socktype == SOCK_DGRAM) {
|
2005-01-28 02:16:11 +08:00
|
|
|
handler(sk);
|
2002-07-21 02:53:27 +08:00
|
|
|
return;
|
|
|
|
}
|
2002-03-09 05:12:35 +08:00
|
|
|
|
2009-01-14 21:39:45 +08:00
|
|
|
/* Enable deferred setup */
|
|
|
|
opt = defer_setup;
|
|
|
|
|
|
|
|
if (opt && setsockopt(sk, SOL_BLUETOOTH, BT_DEFER_SETUP,
|
|
|
|
&opt, sizeof(opt)) < 0) {
|
|
|
|
syslog(LOG_ERR, "Can't enable deferred setup : %s (%d)",
|
|
|
|
strerror(errno), errno);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2005-01-28 02:16:11 +08:00
|
|
|
/* Listen for connections */
|
|
|
|
if (listen(sk, 10)) {
|
|
|
|
syslog(LOG_ERR, "Can not listen on the socket: %s (%d)",
|
|
|
|
strerror(errno), errno);
|
|
|
|
goto error;
|
2002-03-09 05:12:35 +08:00
|
|
|
}
|
|
|
|
|
2007-01-22 07:56:48 +08:00
|
|
|
/* Check for socket address */
|
|
|
|
memset(&addr, 0, sizeof(addr));
|
|
|
|
optlen = sizeof(addr);
|
|
|
|
|
|
|
|
if (getsockname(sk, (struct sockaddr *) &addr, &optlen) < 0) {
|
|
|
|
syslog(LOG_ERR, "Can't get socket name: %s (%d)",
|
|
|
|
strerror(errno), errno);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
psm = btohs(addr.l2_psm);
|
|
|
|
|
2005-01-28 02:16:11 +08:00
|
|
|
syslog(LOG_INFO, "Waiting for connection on psm %d ...", psm);
|
2002-03-09 05:12:35 +08:00
|
|
|
|
2009-01-14 21:39:45 +08:00
|
|
|
while (1) {
|
2005-01-28 02:16:11 +08:00
|
|
|
memset(&addr, 0, sizeof(addr));
|
|
|
|
optlen = sizeof(addr);
|
|
|
|
|
|
|
|
nsk = accept(sk, (struct sockaddr *) &addr, &optlen);
|
|
|
|
if (nsk < 0) {
|
|
|
|
syslog(LOG_ERR, "Accept failed: %s (%d)",
|
|
|
|
strerror(errno), errno);
|
|
|
|
goto error;
|
2002-03-09 05:12:35 +08:00
|
|
|
}
|
2005-01-12 05:42:38 +08:00
|
|
|
if (fork()) {
|
2002-03-09 05:12:35 +08:00
|
|
|
/* Parent */
|
2005-01-28 02:16:11 +08:00
|
|
|
close(nsk);
|
2002-03-09 05:12:35 +08:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
/* Child */
|
2005-01-28 02:16:11 +08:00
|
|
|
close(sk);
|
2002-03-09 05:12:35 +08:00
|
|
|
|
2005-01-28 02:16:11 +08:00
|
|
|
/* Get current options */
|
2005-01-25 02:33:49 +08:00
|
|
|
memset(&opts, 0, sizeof(opts));
|
2005-01-28 02:16:11 +08:00
|
|
|
optlen = sizeof(opts);
|
|
|
|
|
|
|
|
if (getsockopt(nsk, SOL_L2CAP, L2CAP_OPTIONS, &opts, &optlen) < 0) {
|
|
|
|
syslog(LOG_ERR, "Can't get L2CAP options: %s (%d)",
|
|
|
|
strerror(errno), errno);
|
2009-01-14 21:39:45 +08:00
|
|
|
if (!defer_setup) {
|
|
|
|
close(nsk);
|
|
|
|
goto error;
|
|
|
|
}
|
2005-01-25 02:33:49 +08:00
|
|
|
}
|
|
|
|
|
2005-01-28 02:16:11 +08:00
|
|
|
/* Get connection information */
|
2005-01-25 02:33:49 +08:00
|
|
|
memset(&conn, 0, sizeof(conn));
|
2005-01-28 02:16:11 +08:00
|
|
|
optlen = sizeof(conn);
|
|
|
|
|
|
|
|
if (getsockopt(nsk, SOL_L2CAP, L2CAP_CONNINFO, &conn, &optlen) < 0) {
|
|
|
|
syslog(LOG_ERR, "Can't get L2CAP connection information: %s (%d)",
|
|
|
|
strerror(errno), errno);
|
2009-01-14 21:39:45 +08:00
|
|
|
if (!defer_setup) {
|
|
|
|
close(nsk);
|
|
|
|
goto error;
|
|
|
|
}
|
2002-03-09 05:12:35 +08:00
|
|
|
}
|
|
|
|
|
2005-01-28 02:16:11 +08:00
|
|
|
ba2str(&addr.l2_bdaddr, ba);
|
|
|
|
syslog(LOG_INFO, "Connect from %s [imtu %d, omtu %d, flush_to %d, "
|
2005-01-28 04:08:11 +08:00
|
|
|
"mode %d, handle %d, class 0x%02x%02x%02x]",
|
2005-01-25 02:33:49 +08:00
|
|
|
ba, opts.imtu, opts.omtu, opts.flush_to, opts.mode, conn.hci_handle,
|
|
|
|
conn.dev_class[2], conn.dev_class[1], conn.dev_class[0]);
|
2002-03-09 05:12:35 +08:00
|
|
|
|
2009-01-15 17:44:52 +08:00
|
|
|
omtu = (opts.omtu > buffer_size) ? buffer_size : opts.omtu;
|
|
|
|
imtu = (opts.imtu > buffer_size) ? buffer_size : opts.imtu;
|
|
|
|
|
2008-06-25 15:13:46 +08:00
|
|
|
#if 0
|
2008-06-24 02:45:52 +08:00
|
|
|
/* Enable SO_TIMESTAMP */
|
|
|
|
if (timestamp) {
|
|
|
|
int t = 1;
|
|
|
|
|
2008-06-24 02:54:15 +08:00
|
|
|
if (setsockopt(nsk, SOL_SOCKET, SO_TIMESTAMP, &t, sizeof(t)) < 0) {
|
2008-06-24 02:45:52 +08:00
|
|
|
syslog(LOG_ERR, "Can't enable SO_TIMESTAMP: %s (%d)",
|
|
|
|
strerror(errno), errno);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
}
|
2008-06-25 15:13:46 +08:00
|
|
|
#endif
|
2008-06-24 02:45:52 +08:00
|
|
|
|
2003-05-17 08:45:58 +08:00
|
|
|
/* Enable SO_LINGER */
|
|
|
|
if (linger) {
|
|
|
|
struct linger l = { .l_onoff = 1, .l_linger = linger };
|
2005-01-28 02:16:11 +08:00
|
|
|
|
|
|
|
if (setsockopt(nsk, SOL_SOCKET, SO_LINGER, &l, sizeof(l)) < 0) {
|
2005-01-12 05:42:38 +08:00
|
|
|
syslog(LOG_ERR, "Can't enable SO_LINGER: %s (%d)",
|
2005-01-28 02:16:11 +08:00
|
|
|
strerror(errno), errno);
|
|
|
|
close(nsk);
|
|
|
|
goto error;
|
2003-05-17 08:45:58 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-01-14 21:39:45 +08:00
|
|
|
/* Handle deferred setup */
|
|
|
|
if (defer_setup) {
|
|
|
|
syslog(LOG_INFO, "Waiting for %d seconds",
|
|
|
|
abs(defer_setup) - 1);
|
|
|
|
sleep(abs(defer_setup) - 1);
|
|
|
|
|
|
|
|
if (defer_setup < 0) {
|
|
|
|
close(nsk);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-01-28 02:16:11 +08:00
|
|
|
handler(nsk);
|
2002-03-09 05:12:35 +08:00
|
|
|
|
2005-01-12 05:42:38 +08:00
|
|
|
syslog(LOG_INFO, "Disconnect: %m");
|
2002-03-09 05:12:35 +08:00
|
|
|
exit(0);
|
|
|
|
}
|
2005-01-28 02:16:11 +08:00
|
|
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
error:
|
|
|
|
close(sk);
|
|
|
|
exit(1);
|
2002-03-09 05:12:35 +08:00
|
|
|
}
|
|
|
|
|
2005-01-28 02:16:11 +08:00
|
|
|
static void dump_mode(int sk)
|
2002-03-09 05:12:35 +08:00
|
|
|
{
|
2005-01-28 02:16:11 +08:00
|
|
|
socklen_t optlen;
|
|
|
|
int opt, len;
|
2002-03-09 05:12:35 +08:00
|
|
|
|
2009-01-15 17:44:52 +08:00
|
|
|
if (data_size < 0)
|
|
|
|
data_size = imtu;
|
|
|
|
|
2009-01-14 21:39:45 +08:00
|
|
|
if (defer_setup) {
|
|
|
|
len = read(sk, buf, sizeof(buf));
|
|
|
|
if (len < 0)
|
|
|
|
syslog(LOG_ERR, "Initial read error: %s (%d)",
|
|
|
|
strerror(errno), errno);
|
|
|
|
else
|
|
|
|
syslog(LOG_INFO, "Initial bytes %d", len);
|
|
|
|
}
|
|
|
|
|
2002-07-21 02:53:27 +08:00
|
|
|
syslog(LOG_INFO, "Receiving ...");
|
2002-10-16 01:44:49 +08:00
|
|
|
while (1) {
|
|
|
|
fd_set rset;
|
2005-01-11 18:10:34 +08:00
|
|
|
|
2002-10-16 01:44:49 +08:00
|
|
|
FD_ZERO(&rset);
|
2005-01-28 02:16:11 +08:00
|
|
|
FD_SET(sk, &rset);
|
2005-01-12 05:42:38 +08:00
|
|
|
|
2005-01-28 02:16:11 +08:00
|
|
|
if (select(sk + 1, &rset, NULL, NULL, NULL) < 0)
|
2002-10-16 01:44:49 +08:00
|
|
|
return;
|
|
|
|
|
2005-01-28 02:16:11 +08:00
|
|
|
if (!FD_ISSET(sk, &rset))
|
2002-10-16 01:44:49 +08:00
|
|
|
continue;
|
|
|
|
|
2005-01-28 02:16:11 +08:00
|
|
|
len = read(sk, buf, data_size);
|
2003-05-29 20:05:10 +08:00
|
|
|
if (len <= 0) {
|
|
|
|
if (len < 0) {
|
|
|
|
if (reliable && (errno == ECOMM)) {
|
2005-01-28 02:16:11 +08:00
|
|
|
syslog(LOG_INFO, "L2CAP Error ECOMM - clearing error and continuing.");
|
|
|
|
optlen = sizeof(opt);
|
|
|
|
if (getsockopt(sk, SOL_SOCKET, SO_ERROR, &opt, &optlen) < 0) {
|
|
|
|
syslog(LOG_ERR, "Couldn't getsockopt(SO_ERROR): %s (%d)",
|
2005-01-11 18:10:34 +08:00
|
|
|
strerror(errno), errno);
|
2003-05-29 20:05:10 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
} else {
|
2005-01-28 02:16:11 +08:00
|
|
|
syslog(LOG_ERR, "Read error: %s(%d)",
|
|
|
|
strerror(errno), errno);
|
2003-05-29 20:05:10 +08:00
|
|
|
}
|
|
|
|
}
|
2002-10-16 01:44:49 +08:00
|
|
|
return;
|
2003-05-29 20:05:10 +08:00
|
|
|
}
|
2002-10-16 01:44:49 +08:00
|
|
|
|
2005-01-28 02:16:11 +08:00
|
|
|
syslog(LOG_INFO, "Recevied %d bytes", len);
|
2005-07-06 05:15:41 +08:00
|
|
|
hexdump(buf, len);
|
2002-10-16 01:44:49 +08:00
|
|
|
}
|
2002-03-09 05:12:35 +08:00
|
|
|
}
|
|
|
|
|
2005-01-28 02:16:11 +08:00
|
|
|
static void recv_mode(int sk)
|
2002-03-09 05:12:35 +08:00
|
|
|
{
|
2005-02-10 22:07:09 +08:00
|
|
|
struct timeval tv_beg, tv_end, tv_diff;
|
|
|
|
struct pollfd p;
|
2008-06-25 15:13:46 +08:00
|
|
|
char ts[30];
|
2002-03-09 05:12:35 +08:00
|
|
|
long total;
|
|
|
|
uint32_t seq;
|
2005-01-28 02:16:11 +08:00
|
|
|
socklen_t optlen;
|
2009-01-14 21:39:45 +08:00
|
|
|
int opt, len;
|
|
|
|
|
2009-01-15 17:44:52 +08:00
|
|
|
if (data_size < 0)
|
|
|
|
data_size = imtu;
|
|
|
|
|
2009-01-14 21:39:45 +08:00
|
|
|
if (defer_setup) {
|
|
|
|
len = read(sk, buf, sizeof(buf));
|
|
|
|
if (len < 0)
|
|
|
|
syslog(LOG_ERR, "Initial read error: %s (%d)",
|
|
|
|
strerror(errno), errno);
|
|
|
|
else
|
|
|
|
syslog(LOG_INFO, "Initial bytes %d", len);
|
|
|
|
}
|
2002-03-09 05:12:35 +08:00
|
|
|
|
2008-06-25 15:13:46 +08:00
|
|
|
syslog(LOG_INFO, "Receiving ...");
|
|
|
|
|
|
|
|
memset(ts, 0, sizeof(ts));
|
2002-03-09 05:12:35 +08:00
|
|
|
|
2005-02-10 22:07:09 +08:00
|
|
|
p.fd = sk;
|
|
|
|
p.events = POLLIN | POLLERR | POLLHUP;
|
|
|
|
|
2002-03-09 05:12:35 +08:00
|
|
|
seq = 0;
|
|
|
|
while (1) {
|
2005-01-12 05:42:38 +08:00
|
|
|
gettimeofday(&tv_beg, NULL);
|
2002-03-09 05:12:35 +08:00
|
|
|
total = 0;
|
|
|
|
while (total < data_size) {
|
|
|
|
uint32_t sq;
|
|
|
|
uint16_t l;
|
2009-01-14 21:39:45 +08:00
|
|
|
int i;
|
2005-02-10 22:07:09 +08:00
|
|
|
|
|
|
|
p.revents = 0;
|
|
|
|
if (poll(&p, 1, -1) <= 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (p.revents & (POLLERR | POLLHUP))
|
|
|
|
return;
|
|
|
|
|
|
|
|
len = recv(sk, buf, data_size, 0);
|
|
|
|
if (len < 0) {
|
|
|
|
if (reliable && (errno == ECOMM)) {
|
|
|
|
syslog(LOG_INFO, "L2CAP Error ECOMM - clearing error and continuing.\n");
|
|
|
|
optlen = sizeof(opt);
|
|
|
|
if (getsockopt(sk, SOL_SOCKET, SO_ERROR, &opt, &optlen) < 0) {
|
|
|
|
syslog(LOG_ERR, "Couldn't getsockopt(SO_ERROR): %s (%d)",
|
2005-01-11 18:10:34 +08:00
|
|
|
strerror(errno), errno);
|
2005-02-10 22:07:09 +08:00
|
|
|
return;
|
2003-05-29 20:05:10 +08:00
|
|
|
}
|
2005-02-10 22:07:09 +08:00
|
|
|
continue;
|
|
|
|
} else {
|
|
|
|
syslog(LOG_ERR, "Read failed: %s (%d)",
|
|
|
|
strerror(errno), errno);
|
2003-05-29 20:05:10 +08:00
|
|
|
}
|
2002-03-09 05:12:35 +08:00
|
|
|
}
|
|
|
|
|
2005-02-10 22:07:09 +08:00
|
|
|
if (len < 6)
|
|
|
|
break;
|
|
|
|
|
2008-06-25 15:13:46 +08:00
|
|
|
if (timestamp) {
|
|
|
|
struct timeval tv;
|
|
|
|
|
|
|
|
if (ioctl(sk, SIOCGSTAMP, &tv) < 0) {
|
|
|
|
timestamp = 0;
|
|
|
|
memset(ts, 0, sizeof(ts));
|
|
|
|
} else {
|
|
|
|
sprintf(ts, "[%ld.%ld] ",
|
|
|
|
tv.tv_sec, tv.tv_usec);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-03-09 05:12:35 +08:00
|
|
|
/* Check sequence */
|
2005-01-12 05:42:38 +08:00
|
|
|
sq = btohl(*(uint32_t *) buf);
|
2002-03-09 05:12:35 +08:00
|
|
|
if (seq != sq) {
|
|
|
|
syslog(LOG_INFO, "seq missmatch: %d -> %d", seq, sq);
|
|
|
|
seq = sq;
|
|
|
|
}
|
|
|
|
seq++;
|
2005-01-11 18:10:34 +08:00
|
|
|
|
2002-03-09 05:12:35 +08:00
|
|
|
/* Check length */
|
2005-01-12 05:42:38 +08:00
|
|
|
l = btohs(*(uint16_t *) (buf + 4));
|
2005-02-10 22:07:09 +08:00
|
|
|
if (len != l) {
|
|
|
|
syslog(LOG_INFO, "size missmatch: %d -> %d", len, l);
|
2002-03-09 05:12:35 +08:00
|
|
|
continue;
|
|
|
|
}
|
2005-01-11 18:10:34 +08:00
|
|
|
|
|
|
|
/* Verify data */
|
2005-02-10 22:07:09 +08:00
|
|
|
for (i = 6; i < len; i++) {
|
2002-03-09 05:12:35 +08:00
|
|
|
if (buf[i] != 0x7f)
|
|
|
|
syslog(LOG_INFO, "data missmatch: byte %d 0x%2.2x", i, buf[i]);
|
|
|
|
}
|
|
|
|
|
2005-02-10 22:07:09 +08:00
|
|
|
total += len;
|
2002-03-09 05:12:35 +08:00
|
|
|
}
|
2005-01-12 05:42:38 +08:00
|
|
|
gettimeofday(&tv_end, NULL);
|
2002-03-09 05:12:35 +08:00
|
|
|
|
2005-01-12 05:42:38 +08:00
|
|
|
timersub(&tv_end, &tv_beg, &tv_diff);
|
2002-03-09 05:12:35 +08:00
|
|
|
|
2008-06-25 15:13:46 +08:00
|
|
|
syslog(LOG_INFO,"%s%ld bytes in %.2f sec, %.2f kB/s", ts, total,
|
2005-01-11 18:10:34 +08:00
|
|
|
tv2fl(tv_diff), (float)(total / tv2fl(tv_diff) ) / 1024.0);
|
2002-03-09 05:12:35 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-06-14 19:23:24 +08:00
|
|
|
static void do_send(int sk)
|
2002-03-09 05:12:35 +08:00
|
|
|
{
|
|
|
|
uint32_t seq;
|
2009-01-15 15:06:34 +08:00
|
|
|
int i, fd, len, buflen, size, sent;
|
2002-03-09 05:12:35 +08:00
|
|
|
|
2003-05-20 05:04:25 +08:00
|
|
|
syslog(LOG_INFO, "Sending ...");
|
2002-03-09 05:12:35 +08:00
|
|
|
|
2009-01-15 17:44:52 +08:00
|
|
|
if (data_size < 0)
|
|
|
|
data_size = omtu;
|
|
|
|
|
2006-06-14 19:23:24 +08:00
|
|
|
if (filename) {
|
|
|
|
fd = open(filename, O_RDONLY);
|
|
|
|
if (fd < 0) {
|
|
|
|
syslog(LOG_ERR, "Open failed: %s (%d)",
|
|
|
|
strerror(errno), errno);
|
|
|
|
exit(1);
|
|
|
|
}
|
2009-01-15 15:06:34 +08:00
|
|
|
|
|
|
|
sent = 0;
|
|
|
|
size = read(fd, buf, data_size);
|
|
|
|
while (size > 0) {
|
|
|
|
buflen = (size > omtu) ? omtu : size;
|
|
|
|
|
|
|
|
len = send(sk, buf + sent, buflen, 0);
|
|
|
|
|
|
|
|
sent += len;
|
|
|
|
size -= len;
|
|
|
|
}
|
2006-06-14 19:23:24 +08:00
|
|
|
return;
|
|
|
|
} else {
|
|
|
|
for (i = 6; i < data_size; i++)
|
|
|
|
buf[i] = 0x7f;
|
|
|
|
}
|
2002-03-09 05:12:35 +08:00
|
|
|
|
|
|
|
seq = 0;
|
2003-05-20 05:04:25 +08:00
|
|
|
while ((num_frames == -1) || (num_frames-- > 0)) {
|
2004-02-18 02:29:02 +08:00
|
|
|
*(uint32_t *) buf = htobl(seq);
|
2005-01-12 05:42:38 +08:00
|
|
|
*(uint16_t *) (buf + 4) = htobs(data_size);
|
2004-02-18 02:29:02 +08:00
|
|
|
seq++;
|
2005-01-11 18:10:34 +08:00
|
|
|
|
2009-01-15 15:06:34 +08:00
|
|
|
sent = 0;
|
|
|
|
size = data_size;
|
|
|
|
while (size > 0) {
|
|
|
|
buflen = (size > omtu) ? omtu : size;
|
|
|
|
|
|
|
|
len = send(sk, buf, buflen, 0);
|
|
|
|
if (len < 0 || len != buflen) {
|
|
|
|
syslog(LOG_ERR, "Send failed: %s (%d)",
|
2006-06-14 19:23:24 +08:00
|
|
|
strerror(errno), errno);
|
2009-01-15 15:06:34 +08:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
sent += len;
|
|
|
|
size -= len;
|
2002-03-09 05:12:35 +08:00
|
|
|
}
|
2006-03-24 06:15:09 +08:00
|
|
|
|
2006-03-25 02:05:22 +08:00
|
|
|
if (num_frames && delay && count && !(seq % count))
|
2006-03-24 06:15:09 +08:00
|
|
|
usleep(delay);
|
2002-03-09 05:12:35 +08:00
|
|
|
}
|
2006-06-14 19:23:24 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void send_mode(int sk)
|
|
|
|
{
|
|
|
|
do_send(sk);
|
2003-05-20 05:04:25 +08:00
|
|
|
|
|
|
|
syslog(LOG_INFO, "Closing channel ...");
|
2005-01-28 02:16:11 +08:00
|
|
|
if (shutdown(sk, SHUT_RDWR) < 0)
|
2005-01-12 05:42:38 +08:00
|
|
|
syslog(LOG_INFO, "Close failed: %m");
|
2003-05-20 05:04:25 +08:00
|
|
|
else
|
|
|
|
syslog(LOG_INFO, "Done");
|
2002-03-09 05:12:35 +08:00
|
|
|
}
|
|
|
|
|
2005-01-28 02:16:11 +08:00
|
|
|
static void senddump_mode(int sk)
|
2003-05-30 05:27:00 +08:00
|
|
|
{
|
2006-06-14 19:23:24 +08:00
|
|
|
do_send(sk);
|
2003-05-30 05:27:00 +08:00
|
|
|
|
2005-01-28 02:16:11 +08:00
|
|
|
dump_mode(sk);
|
2003-05-30 05:27:00 +08:00
|
|
|
}
|
|
|
|
|
2005-01-11 18:10:34 +08:00
|
|
|
static void reconnect_mode(char *svr)
|
2002-03-09 05:12:35 +08:00
|
|
|
{
|
2005-01-28 03:59:22 +08:00
|
|
|
while (1) {
|
|
|
|
int sk = do_connect(svr);
|
|
|
|
close(sk);
|
2002-03-09 05:12:35 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-01-11 18:10:34 +08:00
|
|
|
static void connect_mode(char *svr)
|
2002-03-09 05:12:35 +08:00
|
|
|
{
|
2005-05-20 01:06:50 +08:00
|
|
|
struct pollfd p;
|
2005-01-28 03:59:22 +08:00
|
|
|
int sk;
|
|
|
|
|
|
|
|
if ((sk = do_connect(svr)) < 0)
|
2002-03-09 05:12:35 +08:00
|
|
|
exit(1);
|
2005-01-28 03:59:22 +08:00
|
|
|
|
2005-05-20 01:06:50 +08:00
|
|
|
p.fd = sk;
|
|
|
|
p.events = POLLERR | POLLHUP;
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
p.revents = 0;
|
2006-08-10 18:20:59 +08:00
|
|
|
if (poll(&p, 1, 500))
|
2005-05-20 01:06:50 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
syslog(LOG_INFO, "Disconnected");
|
|
|
|
|
|
|
|
close(sk);
|
2002-03-09 05:12:35 +08:00
|
|
|
}
|
|
|
|
|
2006-07-06 02:53:18 +08:00
|
|
|
static void multi_connect_mode(int argc, char *argv[])
|
2002-03-09 05:12:35 +08:00
|
|
|
{
|
2006-07-06 02:53:18 +08:00
|
|
|
int i, n, sk;
|
|
|
|
|
2002-07-24 03:51:11 +08:00
|
|
|
while (1) {
|
2006-07-06 02:53:18 +08:00
|
|
|
for (n = 0; n < argc; n++) {
|
|
|
|
for (i = 0; i < count; i++) {
|
|
|
|
if (fork())
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* Child */
|
|
|
|
sk = do_connect(argv[n]);
|
|
|
|
usleep(500);
|
|
|
|
close(sk);
|
|
|
|
exit(0);
|
|
|
|
}
|
2002-03-09 05:12:35 +08:00
|
|
|
}
|
2006-07-06 02:53:18 +08:00
|
|
|
sleep(4);
|
2002-03-09 05:12:35 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-09-24 19:36:24 +08:00
|
|
|
static void info_request(char *svr)
|
|
|
|
{
|
|
|
|
unsigned char buf[48];
|
|
|
|
l2cap_cmd_hdr *cmd = (l2cap_cmd_hdr *) buf;
|
|
|
|
l2cap_info_req *req = (l2cap_info_req *) (buf + L2CAP_CMD_HDR_SIZE);
|
|
|
|
l2cap_info_rsp *rsp = (l2cap_info_rsp *) (buf + L2CAP_CMD_HDR_SIZE);
|
|
|
|
uint16_t mtu;
|
2009-05-04 17:42:55 +08:00
|
|
|
uint32_t channels, mask = 0x0000;
|
2006-09-24 19:36:24 +08:00
|
|
|
struct sockaddr_l2 addr;
|
|
|
|
int sk, err;
|
|
|
|
|
|
|
|
sk = socket(PF_BLUETOOTH, SOCK_RAW, BTPROTO_L2CAP);
|
|
|
|
if (sk < 0) {
|
|
|
|
perror("Can't create socket");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
memset(&addr, 0, sizeof(addr));
|
|
|
|
addr.l2_family = AF_BLUETOOTH;
|
|
|
|
bacpy(&addr.l2_bdaddr, &bdaddr);
|
|
|
|
|
|
|
|
if (bind(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
|
|
|
|
perror("Can't bind socket");
|
|
|
|
goto failed;
|
|
|
|
}
|
|
|
|
|
|
|
|
memset(&addr, 0, sizeof(addr));
|
|
|
|
addr.l2_family = AF_BLUETOOTH;
|
|
|
|
str2ba(svr, &addr.l2_bdaddr);
|
|
|
|
|
|
|
|
if (connect(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0 ) {
|
|
|
|
perror("Can't connect socket");
|
|
|
|
goto failed;
|
|
|
|
}
|
|
|
|
|
|
|
|
memset(buf, 0, sizeof(buf));
|
|
|
|
cmd->code = L2CAP_INFO_REQ;
|
2009-04-20 04:38:36 +08:00
|
|
|
cmd->ident = 141;
|
2006-09-24 19:36:24 +08:00
|
|
|
cmd->len = htobs(2);
|
|
|
|
req->type = htobs(0x0001);
|
|
|
|
|
|
|
|
if (send(sk, buf, L2CAP_CMD_HDR_SIZE + L2CAP_INFO_REQ_SIZE, 0) < 0) {
|
|
|
|
perror("Can't send info request");
|
|
|
|
goto failed;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = recv(sk, buf, L2CAP_CMD_HDR_SIZE + L2CAP_INFO_RSP_SIZE + 2, 0);
|
|
|
|
if (err < 0) {
|
|
|
|
perror("Can't receive info response");
|
|
|
|
goto failed;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (btohs(rsp->result)) {
|
|
|
|
case 0x0000:
|
2009-07-16 13:23:38 +08:00
|
|
|
memcpy(&mtu, rsp->data, sizeof(mtu));
|
|
|
|
printf("Connectionless MTU size is %d\n", btohs(mtu));
|
2006-09-24 19:36:24 +08:00
|
|
|
break;
|
|
|
|
case 0x0001:
|
|
|
|
printf("Connectionless MTU is not supported\n");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
memset(buf, 0, sizeof(buf));
|
|
|
|
cmd->code = L2CAP_INFO_REQ;
|
2009-04-20 04:38:36 +08:00
|
|
|
cmd->ident = 142;
|
2006-09-24 19:36:24 +08:00
|
|
|
cmd->len = htobs(2);
|
|
|
|
req->type = htobs(0x0002);
|
|
|
|
|
|
|
|
if (send(sk, buf, L2CAP_CMD_HDR_SIZE + L2CAP_INFO_REQ_SIZE, 0) < 0) {
|
|
|
|
perror("Can't send info request");
|
|
|
|
goto failed;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = recv(sk, buf, L2CAP_CMD_HDR_SIZE + L2CAP_INFO_RSP_SIZE + 4, 0);
|
|
|
|
if (err < 0) {
|
|
|
|
perror("Can't receive info response");
|
|
|
|
goto failed;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (btohs(rsp->result)) {
|
|
|
|
case 0x0000:
|
2009-07-16 13:23:38 +08:00
|
|
|
memcpy(&mask, rsp->data, sizeof(mask));
|
|
|
|
printf("Extended feature mask is 0x%04x\n", btohl(mask));
|
2006-09-24 19:36:24 +08:00
|
|
|
if (mask & 0x01)
|
|
|
|
printf(" Flow control mode\n");
|
|
|
|
if (mask & 0x02)
|
|
|
|
printf(" Retransmission mode\n");
|
|
|
|
if (mask & 0x04)
|
|
|
|
printf(" Bi-directional QoS\n");
|
2009-04-20 04:10:01 +08:00
|
|
|
if (mask & 0x08)
|
|
|
|
printf(" Enhanced Retransmission mode\n");
|
|
|
|
if (mask & 0x10)
|
|
|
|
printf(" Streaming mode\n");
|
|
|
|
if (mask & 0x20)
|
|
|
|
printf(" FCS Option\n");
|
2009-04-20 04:28:53 +08:00
|
|
|
if (mask & 0x40)
|
|
|
|
printf(" Extended Flow Specification\n");
|
|
|
|
if (mask & 0x80)
|
|
|
|
printf(" Fixed Channels\n");
|
|
|
|
if (mask & 0x0100)
|
|
|
|
printf(" Extended Window Size\n");
|
|
|
|
if (mask & 0x0200)
|
|
|
|
printf(" Unicast Connectionless Data Reception\n");
|
2006-09-24 19:36:24 +08:00
|
|
|
break;
|
|
|
|
case 0x0001:
|
|
|
|
printf("Extended feature mask is not supported\n");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2009-04-20 04:38:36 +08:00
|
|
|
if (!(mask & 0x80))
|
|
|
|
goto failed;
|
|
|
|
|
|
|
|
memset(buf, 0, sizeof(buf));
|
|
|
|
cmd->code = L2CAP_INFO_REQ;
|
|
|
|
cmd->ident = 143;
|
|
|
|
cmd->len = htobs(2);
|
|
|
|
req->type = htobs(0x0003);
|
|
|
|
|
|
|
|
if (send(sk, buf, L2CAP_CMD_HDR_SIZE + L2CAP_INFO_REQ_SIZE, 0) < 0) {
|
|
|
|
perror("Can't send info request");
|
|
|
|
goto failed;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = recv(sk, buf, L2CAP_CMD_HDR_SIZE + L2CAP_INFO_RSP_SIZE + 8, 0);
|
|
|
|
if (err < 0) {
|
|
|
|
perror("Can't receive info response");
|
|
|
|
goto failed;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (btohs(rsp->result)) {
|
|
|
|
case 0x0000:
|
2009-07-16 13:23:38 +08:00
|
|
|
memcpy(&channels, rsp->data, sizeof(channels));
|
|
|
|
printf("Fixed channels list is 0x%04x\n", btohl(channels));
|
2009-04-20 04:38:36 +08:00
|
|
|
case 0x0001:
|
|
|
|
printf("Fixed channels list is not supported\n");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2006-09-24 19:36:24 +08:00
|
|
|
failed:
|
|
|
|
close(sk);
|
|
|
|
}
|
|
|
|
|
2009-01-13 18:17:17 +08:00
|
|
|
static void do_pairing(char *svr)
|
|
|
|
{
|
|
|
|
struct sockaddr_l2 addr;
|
|
|
|
int sk, opt;
|
|
|
|
|
|
|
|
sk = socket(PF_BLUETOOTH, SOCK_RAW, BTPROTO_L2CAP);
|
|
|
|
if (sk < 0) {
|
|
|
|
perror("Can't create socket");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
memset(&addr, 0, sizeof(addr));
|
|
|
|
addr.l2_family = AF_BLUETOOTH;
|
|
|
|
bacpy(&addr.l2_bdaddr, &bdaddr);
|
|
|
|
|
|
|
|
if (bind(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
|
|
|
|
perror("Can't bind socket");
|
|
|
|
goto failed;
|
|
|
|
}
|
|
|
|
|
2009-01-14 00:55:54 +08:00
|
|
|
if (secure)
|
|
|
|
opt = L2CAP_LM_SECURE;
|
|
|
|
else
|
|
|
|
opt = L2CAP_LM_ENCRYPT;
|
2009-01-13 18:17:17 +08:00
|
|
|
|
|
|
|
if (setsockopt(sk, SOL_L2CAP, L2CAP_LM, &opt, sizeof(opt)) < 0) {
|
|
|
|
perror("Can't set link mode");
|
|
|
|
goto failed;
|
|
|
|
}
|
|
|
|
|
|
|
|
memset(&addr, 0, sizeof(addr));
|
|
|
|
addr.l2_family = AF_BLUETOOTH;
|
|
|
|
str2ba(svr, &addr.l2_bdaddr);
|
|
|
|
|
|
|
|
if (connect(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0 ) {
|
|
|
|
perror("Can't connect socket");
|
|
|
|
goto failed;
|
|
|
|
}
|
|
|
|
|
|
|
|
printf("Pairing successful\n");
|
|
|
|
|
|
|
|
failed:
|
|
|
|
close(sk);
|
|
|
|
}
|
|
|
|
|
2005-01-11 18:10:34 +08:00
|
|
|
static void usage(void)
|
2002-03-09 05:12:35 +08:00
|
|
|
{
|
|
|
|
printf("l2test - L2CAP testing\n"
|
|
|
|
"Usage:\n");
|
2002-03-19 03:39:45 +08:00
|
|
|
printf("\tl2test <mode> [options] [bdaddr]\n");
|
2002-03-09 05:12:35 +08:00
|
|
|
printf("Modes:\n"
|
2002-03-27 13:30:35 +08:00
|
|
|
"\t-r listen and receive\n"
|
|
|
|
"\t-w listen and send\n"
|
2003-02-04 23:32:21 +08:00
|
|
|
"\t-d listen and dump incoming data\n"
|
2003-05-30 05:27:00 +08:00
|
|
|
"\t-x listen, then send, then dump incoming data\n"
|
2002-03-27 13:30:35 +08:00
|
|
|
"\t-s connect and send\n"
|
|
|
|
"\t-u connect and receive\n"
|
|
|
|
"\t-n connect and be silent\n"
|
2003-05-30 05:27:00 +08:00
|
|
|
"\t-y connect, then send, then dump incoming data\n"
|
2002-03-27 13:30:35 +08:00
|
|
|
"\t-c connect, disconnect, connect, ...\n"
|
2006-09-24 19:36:24 +08:00
|
|
|
"\t-m multiple connects\n"
|
2009-01-13 18:17:17 +08:00
|
|
|
"\t-p trigger dedicated bonding\n"
|
2006-09-24 19:36:24 +08:00
|
|
|
"\t-z information request\n");
|
2002-03-27 13:30:35 +08:00
|
|
|
|
2002-03-19 03:39:45 +08:00
|
|
|
printf("Options:\n"
|
2004-11-17 16:28:52 +08:00
|
|
|
"\t[-b bytes] [-i device] [-P psm]\n"
|
2005-01-11 18:10:34 +08:00
|
|
|
"\t[-I imtu] [-O omtu]\n"
|
2003-05-17 08:45:58 +08:00
|
|
|
"\t[-L seconds] enable SO_LINGER\n"
|
2009-01-14 21:39:45 +08:00
|
|
|
"\t[-F seconds] enable deferred setup\n"
|
2006-06-14 19:23:24 +08:00
|
|
|
"\t[-B filename] use data packets from file\n"
|
|
|
|
"\t[-N num] send num frames (default = infinite)\n"
|
2006-03-24 06:15:09 +08:00
|
|
|
"\t[-C num] send num frames before delay (default = 1)\n"
|
2006-03-25 02:05:22 +08:00
|
|
|
"\t[-D milliseconds] delay after sending num frames (default = 0)\n"
|
2008-06-15 22:09:07 +08:00
|
|
|
"\t[-X mode] select retransmission/flow-control mode\n"
|
2003-05-29 20:05:10 +08:00
|
|
|
"\t[-R] reliable mode\n"
|
2006-03-24 06:06:13 +08:00
|
|
|
"\t[-G] use connectionless channel (datagram)\n"
|
2003-03-26 22:39:19 +08:00
|
|
|
"\t[-A] request authentication\n"
|
2002-03-19 03:39:45 +08:00
|
|
|
"\t[-E] request encryption\n"
|
2004-11-17 16:28:52 +08:00
|
|
|
"\t[-S] secure connection\n"
|
2008-06-24 02:45:52 +08:00
|
|
|
"\t[-M] become master\n"
|
|
|
|
"\t[-T] enable timestamps\n");
|
2002-03-09 05:12:35 +08:00
|
|
|
}
|
|
|
|
|
2006-06-14 19:23:24 +08:00
|
|
|
int main(int argc, char *argv[])
|
2002-03-09 05:12:35 +08:00
|
|
|
{
|
|
|
|
struct sigaction sa;
|
2005-01-28 04:13:19 +08:00
|
|
|
int opt, sk, mode = RECV, need_addr = 0;
|
2004-11-17 16:28:52 +08:00
|
|
|
|
|
|
|
bacpy(&bdaddr, BDADDR_ANY);
|
|
|
|
|
2009-01-14 21:39:45 +08:00
|
|
|
while ((opt=getopt(argc,argv,"rdscuwmnxyzpb:i:P:I:O:B:N:L:F:C:D:X:RGAESMT")) != EOF) {
|
2002-03-09 05:12:35 +08:00
|
|
|
switch(opt) {
|
|
|
|
case 'r':
|
|
|
|
mode = RECV;
|
|
|
|
break;
|
2005-01-11 18:10:34 +08:00
|
|
|
|
2002-03-09 05:12:35 +08:00
|
|
|
case 's':
|
|
|
|
mode = SEND;
|
2002-03-27 13:30:35 +08:00
|
|
|
need_addr = 1;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 'w':
|
|
|
|
mode = LSEND;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 'u':
|
|
|
|
mode = CRECV;
|
|
|
|
need_addr = 1;
|
2002-03-09 05:12:35 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 'd':
|
|
|
|
mode = DUMP;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 'c':
|
|
|
|
mode = RECONNECT;
|
2002-03-27 13:30:35 +08:00
|
|
|
need_addr = 1;
|
2002-03-09 05:12:35 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 'n':
|
|
|
|
mode = CONNECT;
|
2002-03-27 13:30:35 +08:00
|
|
|
need_addr = 1;
|
2002-03-09 05:12:35 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 'm':
|
|
|
|
mode = MULTY;
|
2002-03-27 13:30:35 +08:00
|
|
|
need_addr = 1;
|
2002-03-09 05:12:35 +08:00
|
|
|
break;
|
|
|
|
|
2003-05-30 05:27:00 +08:00
|
|
|
case 'x':
|
|
|
|
mode = LSENDDUMP;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 'y':
|
|
|
|
mode = SENDDUMP;
|
|
|
|
break;
|
|
|
|
|
2006-09-24 19:36:24 +08:00
|
|
|
case 'z':
|
|
|
|
mode = INFOREQ;
|
|
|
|
need_addr = 1;
|
|
|
|
break;
|
|
|
|
|
2009-01-13 18:17:17 +08:00
|
|
|
case 'p':
|
|
|
|
mode = PAIRING;
|
|
|
|
need_addr = 1;
|
|
|
|
break;
|
|
|
|
|
2006-09-24 19:36:24 +08:00
|
|
|
case 'b':
|
|
|
|
data_size = atoi(optarg);
|
|
|
|
break;
|
|
|
|
|
2004-11-17 16:28:52 +08:00
|
|
|
case 'i':
|
|
|
|
if (!strncasecmp(optarg, "hci", 3))
|
|
|
|
hci_devba(atoi(optarg + 3), &bdaddr);
|
|
|
|
else
|
|
|
|
str2ba(optarg, &bdaddr);
|
2002-03-09 05:12:35 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 'P':
|
|
|
|
psm = atoi(optarg);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 'I':
|
|
|
|
imtu = atoi(optarg);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 'O':
|
|
|
|
omtu = atoi(optarg);
|
|
|
|
break;
|
|
|
|
|
2003-05-17 08:45:58 +08:00
|
|
|
case 'L':
|
|
|
|
linger = atoi(optarg);
|
|
|
|
break;
|
|
|
|
|
2009-01-14 21:39:45 +08:00
|
|
|
case 'F':
|
|
|
|
defer_setup = atoi(optarg);
|
|
|
|
break;
|
|
|
|
|
2006-06-14 19:23:24 +08:00
|
|
|
case 'B':
|
|
|
|
filename = strdup(optarg);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 'N':
|
|
|
|
num_frames = atoi(optarg);
|
|
|
|
break;
|
|
|
|
|
2006-03-24 06:15:09 +08:00
|
|
|
case 'C':
|
|
|
|
count = atoi(optarg);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 'D':
|
2006-03-25 02:05:22 +08:00
|
|
|
delay = atoi(optarg) * 1000;
|
2006-03-24 06:15:09 +08:00
|
|
|
break;
|
|
|
|
|
2008-06-15 22:09:07 +08:00
|
|
|
case 'X':
|
2009-05-03 14:03:57 +08:00
|
|
|
if (strcasecmp(optarg, "ertm") == 0)
|
|
|
|
rfcmode = L2CAP_MODE_ERTM;
|
|
|
|
else
|
|
|
|
rfcmode = atoi(optarg);
|
2008-06-15 22:09:07 +08:00
|
|
|
break;
|
|
|
|
|
2003-05-29 20:05:10 +08:00
|
|
|
case 'R':
|
|
|
|
reliable = 1;
|
|
|
|
break;
|
|
|
|
|
2002-03-09 05:12:35 +08:00
|
|
|
case 'M':
|
|
|
|
master = 1;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 'A':
|
|
|
|
auth = 1;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 'E':
|
|
|
|
encrypt = 1;
|
|
|
|
break;
|
|
|
|
|
2004-11-17 16:28:52 +08:00
|
|
|
case 'S':
|
|
|
|
secure = 1;
|
|
|
|
break;
|
|
|
|
|
2006-03-24 06:06:13 +08:00
|
|
|
case 'G':
|
2002-07-21 02:53:27 +08:00
|
|
|
socktype = SOCK_DGRAM;
|
|
|
|
break;
|
|
|
|
|
2008-06-24 02:45:52 +08:00
|
|
|
case 'T':
|
|
|
|
timestamp = 1;
|
|
|
|
break;
|
|
|
|
|
2002-03-09 05:12:35 +08:00
|
|
|
default:
|
|
|
|
usage();
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-03-27 13:30:35 +08:00
|
|
|
if (need_addr && !(argc - optind)) {
|
2002-03-09 05:12:35 +08:00
|
|
|
usage();
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
2009-01-15 15:06:34 +08:00
|
|
|
if (data_size < 0)
|
2009-01-15 17:44:52 +08:00
|
|
|
buffer_size = (omtu > imtu) ? omtu : imtu;
|
|
|
|
else
|
|
|
|
buffer_size = data_size;
|
2005-01-25 02:26:54 +08:00
|
|
|
|
2009-01-15 17:44:52 +08:00
|
|
|
if (!(buf = malloc(buffer_size))) {
|
2002-03-09 05:12:35 +08:00
|
|
|
perror("Can't allocate data buffer");
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
memset(&sa, 0, sizeof(sa));
|
|
|
|
sa.sa_handler = SIG_IGN;
|
|
|
|
sa.sa_flags = SA_NOCLDSTOP;
|
|
|
|
sigaction(SIGCHLD, &sa, NULL);
|
|
|
|
|
|
|
|
openlog("l2test", LOG_PERROR | LOG_PID, LOG_LOCAL0);
|
|
|
|
|
2005-01-11 18:10:34 +08:00
|
|
|
switch (mode) {
|
2002-03-09 05:12:35 +08:00
|
|
|
case RECV:
|
|
|
|
do_listen(recv_mode);
|
|
|
|
break;
|
|
|
|
|
2002-03-27 13:30:35 +08:00
|
|
|
case CRECV:
|
2005-01-28 04:13:19 +08:00
|
|
|
sk = do_connect(argv[optind]);
|
|
|
|
if (sk < 0)
|
2002-03-27 13:30:35 +08:00
|
|
|
exit(1);
|
2005-01-28 04:13:19 +08:00
|
|
|
recv_mode(sk);
|
2002-03-27 13:30:35 +08:00
|
|
|
break;
|
|
|
|
|
2002-03-09 05:12:35 +08:00
|
|
|
case DUMP:
|
|
|
|
do_listen(dump_mode);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SEND:
|
2005-01-28 04:13:19 +08:00
|
|
|
sk = do_connect(argv[optind]);
|
|
|
|
if (sk < 0)
|
2002-03-27 13:30:35 +08:00
|
|
|
exit(1);
|
2005-01-28 04:13:19 +08:00
|
|
|
send_mode(sk);
|
2002-03-27 13:30:35 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
case LSEND:
|
|
|
|
do_listen(send_mode);
|
2002-03-09 05:12:35 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
case RECONNECT:
|
|
|
|
reconnect_mode(argv[optind]);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MULTY:
|
2006-07-06 02:53:18 +08:00
|
|
|
multi_connect_mode(argc - optind, argv + optind);
|
2002-03-09 05:12:35 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
case CONNECT:
|
|
|
|
connect_mode(argv[optind]);
|
|
|
|
break;
|
2003-05-30 05:27:00 +08:00
|
|
|
|
|
|
|
case SENDDUMP:
|
2005-01-28 04:13:19 +08:00
|
|
|
sk = do_connect(argv[optind]);
|
|
|
|
if (sk < 0)
|
2003-05-30 05:27:00 +08:00
|
|
|
exit(1);
|
2005-01-28 04:13:19 +08:00
|
|
|
senddump_mode(sk);
|
2003-05-30 05:27:00 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
case LSENDDUMP:
|
|
|
|
do_listen(senddump_mode);
|
|
|
|
break;
|
2006-09-24 19:36:24 +08:00
|
|
|
|
|
|
|
case INFOREQ:
|
|
|
|
info_request(argv[optind]);
|
|
|
|
exit(0);
|
2009-01-13 18:17:17 +08:00
|
|
|
|
|
|
|
case PAIRING:
|
|
|
|
do_pairing(argv[optind]);
|
|
|
|
exit(0);
|
2002-03-09 05:12:35 +08:00
|
|
|
}
|
2005-01-11 18:10:34 +08:00
|
|
|
|
2002-03-09 05:12:35 +08:00
|
|
|
syslog(LOG_INFO, "Exit");
|
|
|
|
|
|
|
|
closelog();
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|