dbus.c

bluetooth 开发应用bluez-utils-2.23

	/* Create and bind HCI socket */
	sk = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
	if (sk < 0) {
		syslog(LOG_ERR, "Can't open HCI socket: %s (%d)",
							strerror(errno), errno);
		reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET + errno);
		goto failed;
	}

	if (ioctl(sk, HCIDEVUP, dbus_data->dev_id) < 0 && errno != EALREADY) {
		syslog(LOG_ERR, "Can't init device hci%d: %s (%d)",
					dbus_data->dev_id, strerror(errno), errno);
		reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET + errno);
		goto failed;
	}

	if (ioctl(sk, HCIGETDEVINFO, (void *) &di) >= 0 &&
					!hci_test_bit(HCI_RAW, &di.flags)) {
		dr.dev_id  = dbus_data->dev_id;
		dr.dev_opt = SCAN_PAGE | SCAN_INQUIRY; /* piscan */
		if (ioctl(sk, HCISETSCAN, (unsigned long) &dr) < 0) {
			syslog(LOG_ERR, "Can't set scan mode on hci%d: %s (%d)",
					dbus_data->dev_id, strerror(errno), errno);
			reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET + errno);
			goto failed;
		}
	}

	reply = dbus_message_new_method_return(msg);

failed:
	if (sk >= 0)
		close(sk);

	return reply;
}

static DBusMessage* handle_device_down_req(DBusMessage *msg, void *data)
{
	DBusMessage *reply = NULL;
	struct hci_dbus_data *dbus_data = data;
	int sk = -1;

	/* Create and bind HCI socket */
	sk = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
	if (sk < 0) {
		syslog(LOG_ERR, "Can't open HCI socket: %s (%d)",
							strerror(errno), errno);
		reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET + errno);
		goto failed;
	}

	if (ioctl(sk, HCIDEVDOWN, dbus_data->dev_id) < 0) {
		syslog(LOG_ERR, "Can't down device hci%d: %s (%d)",
					dbus_data->dev_id, strerror(errno), errno);
		reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET + errno);
		goto failed;
	}

	reply = dbus_message_new_method_return(msg);

failed:
	if (sk >= 0)
		close(sk);

	return reply;
}

static DBusMessage* handle_device_set_propety_req(DBusMessage *msg, void *data)
{
	const struct service_data *handlers = set_property_services;
	DBusMessageIter iter;
	DBusMessage *reply = NULL;
	const char *signature;
	char *str_name;
	uint32_t error = BLUEZ_EDBUS_WRONG_PARAM;

	signature = dbus_message_get_signature(msg);

	dbus_message_iter_init(msg, &iter);
	dbus_message_iter_get_basic(&iter, &str_name);

	for (; handlers->name != NULL; handlers++) {
		if (strcasecmp(handlers->name, str_name))
			continue;

		if (strcmp(handlers->signature, signature) == 0) {
			reply = handlers->handler_func(msg, data);
			error = 0;
			break;
		} else {
			error = BLUEZ_EDBUS_WRONG_SIGNATURE;
			break;
		}
	}

	if (error)
		reply = bluez_new_failure_msg(msg, error);

	return reply;
}

static DBusMessage* handle_device_get_propety_req(DBusMessage *msg, void *data)
{
	const struct service_data *handlers = get_property_services;
	DBusMessageIter iter;
	DBusMessage *reply = NULL;
	char *str_name;
	uint32_t error = BLUEZ_EDBUS_WRONG_PARAM;


	dbus_message_iter_init(msg, &iter);
	dbus_message_iter_get_basic(&iter, &str_name);

	for (; handlers->name != NULL; handlers++) {
		if (!strcasecmp(handlers->name, str_name)) {
			reply = handlers->handler_func(msg, data);
			error = 0;
			break;
		}
	}

	if (error)
		reply = bluez_new_failure_msg(msg, error);

	return reply;
}

static DBusMessage* handle_device_set_propety_req_name(DBusMessage *msg, void *data)
{
	struct hci_dbus_data *dbus_data = data;
	DBusMessageIter iter;
	DBusMessage *reply = NULL;
	char *str_name;
	int dd = -1;
	uint8_t status;
	change_local_name_cp cp;
	struct hci_request rq;

	dbus_message_iter_init(msg, &iter);
	dbus_message_iter_next(&iter);
	dbus_message_iter_get_basic(&iter, &str_name);

	if(strlen(str_name) == 0) {
		syslog(LOG_ERR, "HCI change name failed - Invalid Name!");
		reply = bluez_new_failure_msg(msg, BLUEZ_EDBUS_WRONG_PARAM);
		goto failed;
	}

	dd = hci_open_dev(dbus_data->dev_id);
	if (dd < 0) {
		syslog(LOG_ERR, "HCI device open failed: hci%d", dbus_data->dev_id);
		reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_ENODEV);
		goto failed;
	}

	memset(&rq, 0, sizeof(rq));
	strncpy((char *) cp.name, str_name, sizeof(cp.name));
	rq.ogf    = OGF_HOST_CTL;
	rq.ocf    = OCF_CHANGE_LOCAL_NAME;
	rq.cparam = &cp;
	rq.clen   = CHANGE_LOCAL_NAME_CP_SIZE;
	rq.rparam = &status;
	rq.rlen   = sizeof(status);

	if (hci_send_req(dd, &rq, 100) < 0) {
		syslog(LOG_ERR, "Sending change name command failed: %s (%d)",
							strerror(errno), errno);
		reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET + errno);
		goto failed;
	}

	if (status) {
		syslog(LOG_ERR, "Setting name failed with status 0x%02x", status);
		reply = bluez_new_failure_msg(msg, BLUEZ_EBT_OFFSET + status);
		goto failed;
	}

	reply = dbus_message_new_method_return(msg);

failed:
	if (dd >= 0)
		close(dd);

	return reply;
}

void hcid_dbus_setname_complete(bdaddr_t *local)
{
	DBusMessage *message = NULL;
	char path[MAX_PATH_LENGTH];
	char *local_addr;
	bdaddr_t tmp;
	int id;
	int dd = -1;
	read_local_name_rp rp;
	struct hci_request rq;
	const char *pname = (char*) rp.name;
	char name[249];

	baswap(&tmp, local); local_addr = batostr(&tmp);

	id = hci_devid(local_addr);
	if (id < 0) {
		syslog(LOG_ERR, "No matching device id for %s", local_addr);
		goto failed;
	}

	snprintf(path, sizeof(path), "%s/hci%d", DEVICE_PATH, id);

	message = dbus_message_new_signal(path, DEVICE_INTERFACE,
						BLUEZ_HCI_SET_NAME);
	if (message == NULL) {
		syslog(LOG_ERR, "Can't allocate D-BUS inquiry complete message");
		goto failed;
	}

	dd = hci_open_dev(id);
	memset(&rq, 0, sizeof(rq));
	if (dd < 0) {
		syslog(LOG_ERR, "HCI device open failed: hci%d", id);
	} else {
		rq.ogf    = OGF_HOST_CTL;
		rq.ocf    = OCF_READ_LOCAL_NAME;
		rq.rparam = &rp;
		rq.rlen   = READ_LOCAL_NAME_RP_SIZE;
		if (hci_send_req(dd, &rq, 100) < 0) {
			syslog(LOG_ERR,
				"Sending getting name command failed: %s (%d)",
				strerror(errno), errno);
			rp.name[0] = '\0';
		}
		if (rp.status) {
			syslog(LOG_ERR,
				"Getting name failed with status 0x%02x",
				rp.status);
			rp.name[0] = '\0';
		}
	}

	strncpy(name,pname,sizeof(name)-1);
	name[248]='\0';
	pname = name;

	dbus_message_append_args(message,
				DBUS_TYPE_STRING, &pname,
				DBUS_TYPE_INVALID);

	if (dbus_connection_send(connection, message, NULL) == FALSE) {
		syslog(LOG_ERR, "Can't send D-BUS NameChanged signal");
		goto failed;
	}
	dbus_connection_flush(connection);

failed:
	if (dd >= 0)
		close(dd);
	dbus_message_unref(message);
	bt_free(local_addr);
}

static DBusMessage* handle_device_get_propety_req_name(DBusMessage *msg, void *data)
{
	struct hci_dbus_data *dbus_data = data;
	DBusMessage *reply = NULL;
	int dd = -1;
	read_local_name_rp rp;
	struct hci_request rq;
	const char *pname = (char*) rp.name;
	char name[249];

	dd = hci_open_dev(dbus_data->dev_id);
	if (dd < 0) {
		syslog(LOG_ERR, "HCI device open failed: hci%d", dbus_data->dev_id);
		reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_ENODEV);
		goto failed;
	}
	memset(&rq, 0, sizeof(rq));
	rq.ogf    = OGF_HOST_CTL;
	rq.ocf    = OCF_READ_LOCAL_NAME;
	rq.rparam = &rp;
	rq.rlen   = READ_LOCAL_NAME_RP_SIZE;

	if (hci_send_req(dd, &rq, 100) < 0) {
		syslog(LOG_ERR, "Sending getting name command failed: %s (%d)",
							strerror(errno), errno);
		reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET + errno);
		goto failed;
	}

	if (rp.status) {
		syslog(LOG_ERR, "Getting name failed with status 0x%02x", rp.status);
		reply = bluez_new_failure_msg(msg, BLUEZ_EBT_OFFSET + rp.status);
		goto failed;
	}

	reply = dbus_message_new_method_return(msg);
	if (reply == NULL) {
		syslog(LOG_ERR, "Out of memory while calling dbus_message_new_method_return");
		goto failed;
	}

	strncpy(name,pname,sizeof(name)-1);
	name[248]='\0';
	pname = name;

	dbus_message_append_args(reply,
				DBUS_TYPE_STRING, &pname,
				DBUS_TYPE_INVALID);

failed:
	if (dd >= 0)
		close(dd);

	return reply;
}

static DBusMessage* handle_device_list_req(DBusMessage *msg, void *data)
{
	DBusMessageIter iter;
	DBusMessageIter array_iter;
	DBusMessage *reply = NULL;
	struct hci_dev_list_req *dl = NULL;
	struct hci_dev_req *dr      = NULL;
	int sk = -1;
	int i;
	const char array_sig[] = MGR_GET_DEV_REPLY_STRUCT_SIGNATURE;

	/* Create and bind HCI socket */
	sk = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
	if (sk < 0) {
		syslog(LOG_ERR, "Can't open HCI socket: %s (%d)", strerror(errno), errno);
		reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET + errno);
		goto failed;
	}

	dl = malloc(HCI_MAX_DEV * sizeof(*dr) + sizeof(*dl));
	if (!dl) {
		syslog(LOG_ERR, "Can't allocate memory");
		reply = bluez_new_failure_msg(msg, BLUEZ_EDBUS_NO_MEM);
		goto failed;
	}

	dl->dev_num = HCI_MAX_DEV;
	dr = dl->dev_req;

	if (ioctl(sk, HCIGETDEVLIST, dl) < 0) {
		reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_OFFSET + errno);
		goto failed;
	}

	/* active bluetooth adapter found */
	reply = dbus_message_new_method_return(msg);
	if (reply == NULL) {
		syslog(LOG_ERR, "Out of memory while calling dbus_message_new_method_return");
		goto failed;
	}

	dbus_message_iter_init_append(reply, &iter);
	dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, array_sig, &array_iter);
	dr = dl->dev_req;

	for (i = 0; i < dl->dev_num; i++, dr++) {
		char apath[MAX_PATH_LENGTH];
		char aaddr[18];
		char *paddr = aaddr;
		char *ppath = apath;
		char *ptype;
		const char *flag;
		DBusMessageIter flag_array_iter, struct_iter;
		struct hci_dev_info di;
		hci_map *mp;

		mp = dev_flags_map;
		memset(&di, 0 , sizeof(struct hci_dev_info));
		di.dev_id = dr->dev_id;

		if (ioctl(sk, HCIGETDEVINFO, &di) < 0)
			continue;

		snprintf(apath, sizeof(apath), "%s/%s", DEVICE_PATH, di.name);

		ba2str(&di.bdaddr, aaddr);
		ptype = hci_dtypetostr(di.type);

		dbus_message_iter_open_container(&array_iter,
				DBUS_TYPE_STRUCT, NULL, &struct_iter);

		dbus_message_iter_append_basic(&struct_iter, DBUS_TYPE_STRING, &ppath);
		dbus_message_iter_append_basic(&struct_iter, DBUS_TYPE_STRING, &paddr);
		dbus_message_iter_append_basic(&struct_iter, DBUS_TYPE_STRING, &ptype);

		if (hci_test_bit(HCI_UP, &dr->dev_opt))
			flag = "UP";
		else
			flag = "DOWN";

		dbus_message_iter_append_basic(&struct_iter, DBUS_TYPE_STRING, &flag);

		dbus_message_iter_open_container(&struct_iter,
					DBUS_TYPE_ARRAY, DBUS_TYPE_STRING_AS_STRING, &flag_array_iter);

		while (mp->str) {
			if (hci_test_bit(mp->val, &dr->dev_opt))
				dbus_message_iter_append_basic(&flag_array_iter, DBUS_TYPE_STRING, &mp->str);
			mp++;
		}
		dbus_message_iter_close_container(&struct_iter, &flag_array_iter);
		dbus_message_iter_close_container(&array_iter, &struct_iter);
	}

	dbus_message_iter_close_container(&iter, &array_iter);

failed:
	if (sk >= 0)
		close(sk);

	if (dl)
		free(dl);

	return reply;
}

/*****************************************************************
 *  
 *  Section reserved to Manager D-Bus services
 *  
 *****************************************************************/
static DBusMessage* handle_default_device_req(DBusMessage *msg, void *data) {
	char path[MAX_PATH_LENGTH];
	char *pptr = path;
	DBusMessage *reply = NULL;

	if (default_dev < 0) {
		reply = bluez_new_failure_msg(msg, BLUEZ_ESYSTEM_ENODEV);
		goto failed;
	}

	reply = dbus_message_new_method_return(msg);
	if (reply == NULL) {
		syslog(LOG_ERR, "Out of memory while calling dbus_message_new_method_return");
		goto failed;
	}

	snprintf(path, sizeof(path), "%s/hci%d", DEVICE_PATH, default_dev);
	dbus_message_append_args(reply,
					DBUS_TYPE_STRING, &pptr,
					DBUS_TYPE_INVALID);

failed:
	return reply;
}

static DBusMessage* handle_not_implemented_req(DBusMessage *msg, void *data) 
{
	const char *path = dbus_message_get_path(msg);
	const char *iface = dbus_message_get_interface(msg);
	const char *method = dbus_message_get_member(msg);

	syslog(LOG_INFO, "Not Implemented - path %s iface %s method %s",
							path, iface, method);

	return NULL;
}