static bool io_read_callback(struct io *io, void *user_data)
{
struct bt_hci *hci = user_data;
uint8_t buf[512];
ssize_t len;
int fd;
fd = io_get_fd(hci->io);
if (fd < 0)
return false;
if (hci->is_stream)
return false;
len = read(fd, buf, sizeof(buf));
if (len < 0)
return false;
if (len < 1)
return true;
switch (buf[0]) {
case BT_H4_EVT_PKT:
process_event(hci, buf + 1, len - 1);
break;
}
return true;
}
static void send_command(struct bt_hci *hci, uint16_t opcode,
void *data, uint8_t size)
{
uint8_t type = BT_H4_CMD_PKT;
struct bt_hci_cmd_hdr hdr;
struct iovec iov[3];
int fd, iovcnt;
if (hci->num_cmds < 1)
return;
hdr.opcode = cpu_to_le16(opcode);
hdr.plen = size;
iov[0].iov_base = &type;
iov[0].iov_len = 1;
iov[1].iov_base = &hdr;
iov[1].iov_len = sizeof(hdr);
if (size > 0) {
iov[2].iov_base = data;
iov[2].iov_len = size;
iovcnt = 3;
} else
iovcnt = 2;
fd = io_get_fd(hci->io);
if (fd < 0)
return;
if (writev(fd, iov, iovcnt) < 0)
return;
hci->num_cmds--;
}
ssize_t io_send(struct io *io, const struct iovec *iov, int iovcnt)
{
int fd;
ssize_t ret;
if (!io || !io->channel)
return -ENOTCONN;
fd = io_get_fd(io);
do {
ret = writev(fd, iov, iovcnt);
} while (ret < 0 && errno == EINTR);
if (ret < 0)
return -errno;
return ret;
}
void
http_accept(IO *io, int events, void *arg)
{
int cfd, fd = io_get_fd(io);
struct sockaddr_in addr = { 0 };
size_t addr_len = sizeof(addr);
IO *client;
struct service *service = arg;
if (events & IO_IN) {
if ((cfd = accept(fd, (struct sockaddr *)&addr, &addr_len)) > -1) {
socket_set_nonblock(cfd);
client = io_new_fd(cfd);
/* TODO: create conn */
struct conn *conn = conn_new(service, client);
printf("--> accepted\n");
io_watch(client, IO_IN | IO_HUP, http_incoming, conn);
}
}
}
static bool uhid_read_handler(struct io *io, void *user_data)
{
struct bt_uhid *uhid = user_data;
int fd;
ssize_t len;
struct uhid_event ev;
fd = io_get_fd(io);
if (fd < 0)
return false;
memset(&ev, 0, sizeof(ev));
len = read(fd, &ev, sizeof(ev));
if (len < 0)
return false;
if ((size_t) len < sizeof(ev.type))
return false;
queue_foreach(uhid->notify_list, notify_handler, &ev);
return true;
}
/*
* This routine loads bitmap blocks from an o2image image file into memory.
* This process happens during file open. bitmap blocks reside towards
* the end of the imagefile.
*/
errcode_t ocfs2_image_load_bitmap(ocfs2_filesys *ofs)
{
struct ocfs2_image_state *ost;
struct ocfs2_image_hdr *hdr;
uint64_t blk_off, bits_set;
int i, j, fd;
ssize_t count;
errcode_t ret;
char *blk;
ret = ocfs2_malloc0(sizeof(struct ocfs2_image_state), &ofs->ost);
if (ret)
return ret;
ost = ofs->ost;
ret = ocfs2_malloc_block(ofs->fs_io, &blk);
if (ret)
return ret;
/* read ocfs2 image header */
ret = io_read_block(ofs->fs_io, 0, 1, blk);
if (ret)
goto out;
hdr = (struct ocfs2_image_hdr *)blk;
ocfs2_image_swap_header(hdr);
ret = OCFS2_ET_BAD_MAGIC;
if (hdr->hdr_magic != OCFS2_IMAGE_MAGIC)
goto out;
if (memcmp(hdr->hdr_magic_desc, OCFS2_IMAGE_DESC,
sizeof(OCFS2_IMAGE_DESC)))
goto out;
ret = OCFS2_ET_OCFS_REV;
if (hdr->hdr_version > OCFS2_IMAGE_VERSION)
goto out;
ost->ost_fsblkcnt = hdr->hdr_fsblkcnt;
ost->ost_fsblksz = hdr->hdr_fsblksz;
ost->ost_imgblkcnt = hdr->hdr_imgblkcnt;
ost->ost_bmpblksz = hdr->hdr_bmpblksz;
ret = ocfs2_image_alloc_bitmap(ofs);
if (ret)
return ret;
/* load bitmap blocks ocfs2 image state */
bits_set = 0;
fd = io_get_fd(ofs->fs_io);
blk_off = (ost->ost_imgblkcnt + 1) * ost->ost_fsblksz;
for (i = 0; i < ost->ost_bmpblks; i++) {
ost->ost_bmparr[i].arr_set_bit_cnt = bits_set;
/*
* we don't use io_read_block as ocfs2 image bitmap block size
* could be different from filesystem block size
*/
count = pread64(fd, ost->ost_bmparr[i].arr_map,
ost->ost_bmpblksz, blk_off);
if (count < 0) {
ret = OCFS2_ET_IO;
goto out;
}
/* add bits set in this bitmap */
for (j = 0; j < (ost->ost_bmpblksz * 8); j++)
if (ocfs2_test_bit(j, ost->ost_bmparr[i].arr_map))
bits_set++;
blk_off += ost->ost_bmpblksz;
}
out:
if (blk)
ocfs2_free(&blk);
return ret;
}