btpan.c

affix是一个Open Source的蓝牙协议栈

			ServiceID = SDP_UUID_GN;
		else
			ServiceID = SDP_UUID_PANU;

		printf("Connecting to host %s ...\n", bda2str(&bda));

		/* search for service ServiceID */
		s_list_append_uuid16(&searchList, ServiceID);
		/* set attributes to find */
		s_list_append_uint(&attrList, SDP_ATTR_SERVICE_RECORD_HANDLE);
		s_list_append_uint(&attrList, SDP_ATTR_PROTO_DESC_LIST);
		err = __sdp_search_attr_req(&saddr, searchList, IndividualAttributes, attrList, 0xffff, &svcList, &count);
		s_list_destroy(&searchList);
		s_list_free(&attrList);
		if (err) {
			fprintf(stderr, "%s\n", sdp_error(err));
			return -1;
		}
		if (count == 0) {
			printf("services [%s] not found\n", val2str(sdp_service_map, ServiceID));
			return -1;
		}
		printf("Service found\n");
		svcRec = s_list_dequeue(&svcList);
		sdp_free_svc(svcRec);
		sdp_free_svclist(&svcList);
	}
#endif
	saddr.devnum = hci_devnum(btdev);
	err = affix_pan_connect(&saddr, role);
	if (err) {
		if (errno == EINVAL)
			fprintf(stderr, "Connection not allowed in this role.\n");
		else
			fprintf(stderr, "failed.\n");
	} else 
		fprintf(stderr, "connected.\n");
	return 0;
}

int cmd_pan_disconnect(struct command *cmd)
{
	int		err;
	struct sockaddr_affix	saddr;

	saddr.family = PF_AFFIX;
	saddr.bda = BDADDR_ANY;		// means disconnect
	saddr.devnum = HCIDEV_ANY;

	saddr.devnum = hci_devnum(btdev);
	err = affix_pan_connect(&saddr, 0);
	if (err)
		printf("failed\n");
	else
		printf("done.\n");
	return 0;
}

int cmd_panctl(struct command *cmd)
{
	struct ifreq		ifr;
	protocol_filter		pf;
	multicast_filter 	mf;
	int			fd, result, i;
	int			mode = mode_unknown; /* state when parsing options */
	int			p_set = 0; /* protocol filter set? */
	int			m_set = 0; /* multicast filter set? */

	fd = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
	if (fd < 0) {
		perror("error opening socket");
		return -1;
	}

	if(__argc - optind < 1)
		pan_usage();

	memset(&pf, 0, sizeof(pf));
	memset(&mf, 0, sizeof(mf));

	strncpy(ifr.ifr_name, __argv[optind], IFNAMSIZ);
	ifr.ifr_name[IFNAMSIZ - 1] = '\0';

	/* parse options */
	pf.count = 0;
	mf.count = 0;
	for (i = optind+1; i < __argc; i++) {
		switch(mode) {
			case mode_unknown: /* we dont know what comes next */
				if (__argv[i][0] == 'm') {
					mode = mode_m_next;
					m_set = 1;
				} else if(__argv[i][0] == 'p') {
					mode = mode_p_next;
					p_set = 1;
				} else pan_usage();
				break;
			case mode_m_next: /* we expect either next multicast address start or next command */
				if(__argv[i][0] == 'm') { /* nothing to do */
				} else if(__argv[i][0] == 'p') {
					mode = mode_p_next;
					p_set = 1;
				} else {
					if(mf.count == MULTICAST_FILTER_MAX) {
						printf("too many multicast ranges\n");
						exit(0);
					}
					if(get_addr(__argv[i], &mf.multicast[mf.count][F_START]))
						pan_usage();
					else
						mode = mode_m_stop;
				}
				break;
			case mode_m_stop: /* we expect multicast address stop */
				if(get_addr(__argv[i], &mf.multicast[mf.count][F_STOP]))
					pan_usage();
				else
					mode = mode_m_next;
				mf.count++;
				break;
			case mode_p_next: /* we expect either next protocol range start or next command */
				if(__argv[i][0] == 'm') {
					mode = mode_m_next;
					m_set = 1;
				} else if(__argv[i][0] == 'p') { /* nothing to do */
				} else {
					if(pf.count == PROTOCOL_FILTER_MAX) {
						printf("too many protocol ranges\n");
						exit(0);
					}
					if(get_short(__argv[i], &pf.protocol[pf.count][F_START]))
						pan_usage();
					else
						mode = mode_p_stop;
				}
				break;
			case mode_p_stop: /* we expect protocol range stop */
				if(get_short(__argv[i], &pf.protocol[pf.count][F_STOP]))
					pan_usage();
				else
					mode = mode_p_next;
				pf.count++;
				break;
		}
	}

	if (mode == mode_m_stop || mode == mode_p_stop) /* range stop missing */
		pan_usage();

	/* set protocol filter */
	if(p_set) {
		printf("setting protocol filter...\n");

		ifr.ifr_ifru.ifru_data = (char*) &pf;
		if ((result = ioctl(fd, SIOCSFILTERPROTOCOL, &ifr))) {
			perror("ioctl error");
		}
	}

	/* set multicast filter */
	if(m_set) {
		printf("setting multicast filter...\n");

		ifr.ifr_ifru.ifru_data = (char*) &mf;
		if ((result = ioctl(fd, SIOCSFILTERMULTICAST, &ifr))) {
			perror("ioctl error");
		}
	}

	/* read protocol filter from device and show */
	ifr.ifr_ifru.ifru_data = (char*) &pf;
	if ((result = ioctl(fd, SIOCGFILTERPROTOCOL, &ifr)))
		perror("ioctl error");
	else {
		printf("protocol filter settings: %d entries\n", pf.count);
		for (i = 0; i < pf.count && i < PROTOCOL_FILTER_MAX; i++)
			printf("   0x%04x - 0x%04x\n", ntohs(pf.protocol[i][F_START]), ntohs(pf.protocol[i][F_STOP]));
	}

	/* read multicast filter from device and show */
	ifr.ifr_ifru.ifru_data = (char*) &mf;
	if ((result = ioctl(fd, SIOCGFILTERMULTICAST, &ifr)))
		perror("ioctl error");
	else {
		printf("multicast filter settings: %d entries\n", mf.count);
		for (i = 0; i < mf.count && i < MULTICAST_FILTER_MAX; i++)
			printf("   %02x:%02x:%02x:%02x:%02x:%02x - %02x:%02x:%02x:%02x:%02x:%02x\n",
					mf.multicast[i][F_START][0], mf.multicast[i][F_START][1], mf.multicast[i][F_START][2],
					mf.multicast[i][F_START][3], mf.multicast[i][F_START][4], mf.multicast[i][F_START][5],
					mf.multicast[i][F_STOP][0], mf.multicast[i][F_STOP][1], mf.multicast[i][F_STOP][2],
					mf.multicast[i][F_STOP][3], mf.multicast[i][F_STOP][4], mf.multicast[i][F_STOP][5]);
	}

	return 0;
}

int cmd_help(struct command *cmd)
{
	if (!__argv[optind]) {
		print_usage(cmd);
		exit(0);
	}

	return print_command_usage(cmds, __argv[optind]);
}

void usage(void)
{
	printf("Usage: btpan [-i <name>] [-a] [--nosdp | -s] <command> [parameters..]>\n");

	print_all_usage(cmds);
#if 0
	printf("\n"
		"Notes:\n"
		"\t1. *address* argument can be replaced by cache entry number (btctl list)\n"
		"\n"
		);
#endif
}

struct command cmds[] = {
	{0, 0, 0, 0, "---->>>> General commands <<<<----\n"},
	{"help", cmd_help, 0, "<command name>"},
	/* PAN */
#if defined(CONFIG_AFFIX_PAN) || defined(CONFIG_AFFIX_PAN_MOD)
	{0, 0, 0, 0, "---->>>> PAN commands <<<<----\n"},
	{"init", cmd_pan_init, 0, "[role] [flags]",
		"\tinitialize PAN\n"
		"\trole: panu, nap, gn\n"
	},
	{"stop", cmd_pan_init, 1, "",
		"\tstop PAN\n"
	},
	{"discovery", cmd_pan_discovery, 0, "[service]",
		"discover PAN device.\n"
		"service: panu, nap, gn\n"
	},
	{"connect", cmd_pan_connect, 0, "<address> [service]",
		"connects to the NAP service.\n"
		"service: nap, gn\n"
	},
	{"disconnect", cmd_pan_disconnect, 0, "",
		"close connection to connected service.\n"
	},
	{"ctl", cmd_panctl, 2, "<interface> [m (start_addr stop_addr)* ] [p (range_start range_stop)* ]",
		"Examples:\n"
		"\t1. lists all filters of PAN device pan0:\n"
		"\t   panctl pan0\n"
		"\t2. set multicast filter to 03:00:00:20:00:00 only:\n"
		"\t   panctl pan0 m 03:00:00:20:00:00 03:00:00:20:00:00\n"
		"\t3. set protocol filter to range 0x800 - 0x801 and 0x806\n"
		"\t   panctl pan0 p 0x800 0x801 0x806 0x806\n"
		"\t4. reset protocol filter\n"
		"\t   panctl pan0 p\n"
	},
#endif
	{0, 0, 0, NULL}
};

void do_exit(void)
{
}

int main(int argc, char **argv)
{
	int	c, lind, i, err = 0;

	struct option	opts[] = {
		{"help", 0, 0, 'h'},
		{"tcp", 0, 0, 't'},
		{"nosdp", 0, 0, 's'},
		{"version", 0, 0, 'V'},
		{0, 0, 0, 0}
	};
	
	if (affix_init(argc, argv, LOG_USER)) {
		fprintf(stderr, "Affix initialization failed\n");
		return 1;
	}

	atexit(do_exit);

	for (;;) {
		c = getopt_long(argc, __argv, "+htvsVi:", opts, &lind);
		if (c == -1)
			break;
		switch (c) {
			case 'h':
				usage();
				return 0;
				break;
			case 'v':
				verboseflag = 1;
				break;
			case 'i':
				strncpy(btdev, optarg, IFNAMSIZ);
				break;
			case 's':
				sdpmode = 0;
				break;
			case 'V':
				printf("Affix version: %s\n", affix_version);
				return 0;
				break;
			case ':':
				printf("Missing parameters for option: %c\n", optopt);
				return 1;
				break;
			case '?':
				printf("Unknown option: %c\n", optopt);
				return 1;
				break;
		}
	}
	if (__argv[optind] && sscanf(__argv[optind], "bt%d", &i) > 0) {
		/* interface name */
		sprintf(btdev, "bt%d", i);
		optind++;
	}
	if (__argv[optind] == NULL) {
		usage();
		//err = cmd_prompt(NULL);
		goto exit;
	}
	err = call_command(cmds, __argv[optind++]);
exit:
	return err;
}