int main(int argc, char *argv[])
{
int ret;
const char *shell_command = "sh";
ret = setuid(0);
if (ret < 0)
{
pr_error_info("Set user to super failed");
return ret;
}
ret = setgid(0);
if (ret < 0)
{
pr_error_info("Set group to super failed");
return ret;
}
cavan_permission_set(0xFFFFFFFF);
if (argc > 1)
{
char command[1024];
text_join_by_char(argv + 1, argc - 1, ' ', command, sizeof(command));
ret = execlp(shell_command, shell_command, "-c", command, NULL);
}
else
{
ret = execlp(shell_command, shell_command, "-", NULL);
}
return ret;
}
bool cavan_touch_device_matcher(struct cavan_event_matcher *matcher, void *data)
{
int ret;
uint8_t abs_bitmask[ABS_BITMASK_SIZE];
uint8_t key_bitmask[KEY_BITMASK_SIZE];
ret = cavan_event_get_abs_bitmask(matcher->fd, abs_bitmask);
if (ret < 0)
{
pr_error_info("cavan_event_get_abs_bitmask");
return false;
}
if (cavan_multi_touch_device_match(abs_bitmask))
{
pr_green_info("Deivce %s mutil touch screen", matcher->devname);
return true;
}
ret = cavan_event_get_key_bitmask(matcher->fd, key_bitmask);
if (ret < 0)
{
pr_error_info("cavan_event_get_key_bitmask");
return false;
}
return cavan_single_touch_device_match(abs_bitmask, key_bitmask);
}
int cavan_fifo_init(struct cavan_fifo *fifo, size_t size, void *data)
{
int ret;
ret = pthread_mutex_init(&fifo->lock, NULL);
if (ret < 0)
{
pr_error_info("pthread_mutex_init");
return ret;
}
fifo->mem = malloc(size);
if (fifo->mem == NULL)
{
pr_error_info("malloc");
ret = -ENOMEM;
goto out_pthread_mutex_destroy;
}
fifo->size = size;
fifo->private_data = data;
fifo->mem_end = fifo->mem + size;
fifo->data = fifo->data_end = fifo->mem;
fifo->read = cavan_fifo_read_dummy;
fifo->write = cavan_fifo_write_dummy;
return 0;
out_pthread_mutex_destroy:
pthread_mutex_destroy(&fifo->lock);
return ret;
}
static struct ext2_group_desc *ext2_read_gdt(struct ext2_desc *desc)
{
ssize_t rdlen;
struct ext2_group_desc *gdt;
size_t gdt_size = desc->group_count * sizeof(*gdt);
gdt = malloc(gdt_size);
if (gdt == NULL)
{
pr_error_info("malloc");
return NULL;
}
rdlen = ffile_readfrom(desc->fd, gdt, gdt_size, BOOT_BLOCK_SIZE + desc->block_size);
if ((size_t) rdlen != gdt_size)
{
pr_error_info("ffile_readfrom");
goto out_free_gdt;
}
return gdt;
out_free_gdt:
free(gdt);
return NULL;
}
bool huamobile_touch_device_matcher(int fd, const char *name, void *data)
{
int ret;
uint8_t abs_bitmask[ABS_BITMASK_SIZE];
uint8_t key_bitmask[KEY_BITMASK_SIZE];
pr_pos_info();
ret = huamobile_event_get_abs_bitmask(fd, abs_bitmask);
if (ret < 0)
{
pr_error_info("huamobile_event_get_abs_bitmask");
return false;
}
if (huamobile_multi_touch_device_match(abs_bitmask))
{
pr_green_info("Deivce %s mutil touch screen", name);
return true;
}
ret = huamobile_event_get_key_bitmask(fd, key_bitmask);
if (ret < 0)
{
pr_error_info("huamobile_event_get_key_bitmask");
return false;
}
return huamobile_single_touch_device_match(abs_bitmask, key_bitmask);
}
static int cavan_input_device_probe(struct cavan_event_device *event_dev, void *data)
{
int ret;
int fd = event_dev->fd;
uint8_t key_bitmask[KEY_BITMASK_SIZE];
uint8_t abs_bitmask[ABS_BITMASK_SIZE];
uint8_t rel_bitmask[REL_BITMASK_SIZE];
struct cavan_input_device *dev, *head, *tail;
ret = cavan_event_get_abs_bitmask(fd, abs_bitmask);
if (ret < 0) {
pr_error_info("cavan_event_get_abs_bitmask");
return ret;
}
ret = cavan_event_get_key_bitmask(fd, key_bitmask);
if (ret < 0) {
pr_error_info("cavan_event_get_key_bitmask");
return ret;
}
ret = cavan_event_get_rel_bitmask(fd, rel_bitmask);
if (ret < 0) {
pr_error_info("cavan_event_get_rel_bitmask");
return ret;
}
head = tail = NULL;
while (1) {
dev = cavan_input_device_create(key_bitmask, abs_bitmask, rel_bitmask);
if (dev == NULL) {
break;
}
dev->event_dev = event_dev;
if (dev->probe && dev->probe(dev, data) < 0) {
free(dev);
continue;
}
if (head) {
tail->next = dev;
tail = dev;
} else {
head = tail = dev;
}
}
if (head == NULL) {
pr_red_info("can't recognize device");
return -EINVAL;
}
tail->next = NULL;
event_dev->private_data = head;
return 0;
}
void *huamobule_file_read_all(const char *pathname, size_t *size)
{
int ret;
int fd;
struct stat st;
void *mem;
ssize_t rdlen;
pr_bold_info("pathname = %s", pathname);
fd = open(pathname, O_RDONLY);
if (fd < 0)
{
pr_error_info("open file %s", pathname);
return NULL;
}
ret = fstat(fd, &st);
if (ret < 0)
{
pr_error_info("get file `%s' stat", pathname);
close(fd);
return NULL;
}
mem = malloc(st.st_size);
if (mem == NULL)
{
pr_error_info("malloc");
close(fd);
return NULL;
}
rdlen = read(fd, mem, st.st_size);
if (rdlen < 0)
{
pr_error_info("read");
free(mem);
mem = NULL;
}
else
{
*size = rdlen;
}
close(fd);
return mem;
}
static int bootimg_write_image(int fd, const char *pathname, unsigned *size, unsigned page_size, struct cavan_sha_context *context)
{
int ret;
int img_fd;
ssize_t wrlen;
ret = cavan_file_seek_next_page(fd, page_size);
if (ret < 0)
{
pr_red_info("cavan_file_seek_next_page");
return ret;
}
img_fd = open(pathname, O_RDONLY);
if (img_fd < 0)
{
pr_error_info("open file `%s'", pathname);
return img_fd;
}
wrlen = ffile_copy(img_fd, fd);
if (wrlen < 0)
{
ret = wrlen;
pr_red_info("ffile_copy");
goto out_close_img_fd;
}
if (lseek(img_fd, 0, SEEK_SET) != 0)
{
pr_error_info("lseek");
ret = -EFAULT;
goto out_close_img_fd;
}
ret = cavan_sha_update2(context, img_fd);
if (ret < 0)
{
pr_red_info("cavan_sha_update2");
goto out_close_img_fd;
}
*size = wrlen;
out_close_img_fd:
close(img_fd);
return ret;
}
int cavan_font_init(struct cavan_font *font)
{
byte *body;
if (font->body)
{
return 0;
}
body = malloc(font->width * font->height);
if (body == NULL)
{
pr_error_info("malloc");
return -ENOMEM;
}
font->body = body;
font->stride = font->width * font->cheight;
if (font->rundata && font->rundata_size > 0)
{
const byte *rundata, *rundata_end;
for (rundata = font->rundata, rundata_end = rundata + font->rundata_size; rundata < rundata_end; rundata++)
{
int count = (*rundata) & 0x7F;
mem_set(body, ((*rundata) & (1 << 7)) ? 0xFF : 0, count);
body += count;
}
}
return 0;
}
struct cavan_input_device *cavan_single_touch_device_create(void)
{
struct cavan_single_touch_device *ts;
struct cavan_touch_device *touch_dev;
struct cavan_input_device *dev;
ts = malloc(sizeof(*ts));
if (ts == NULL)
{
pr_error_info("malloc");
return NULL;
}
ts->pressed = 0;
ts->point.pressed = false;
touch_dev = &ts->touch_dev;
touch_dev->xaxis = ABS_X;
touch_dev->yaxis = ABS_Y;
dev = &touch_dev->input_dev;
dev->probe = cavan_single_touch_device_probe;
dev->remove = NULL;
dev->event_handler = cavan_single_touch_event_handler;
return dev;
}
struct huamobile_input_device *huamobile_multi_touch_device_create(void)
{
struct huamobile_multi_touch_device *ts;
struct huamobile_touch_device *touch_dev;
struct huamobile_input_device *dev;
struct huamobile_touch_point *p, *p_end;
pr_pos_info();
ts = malloc(sizeof(*ts));
if (ts == NULL) {
pr_error_info("malloc");
return NULL;
}
ts->point_count = 0;
ts->point_count_old = 0;
for (p = ts->points, p_end = p + NELEM(ts->points); p < p_end; p++) {
p->id = p - ts->points;
p->pressure = -1;
p->released = 1;
}
touch_dev = &ts->touch_dev;
touch_dev->xaxis = ABS_MT_POSITION_X;
touch_dev->yaxis = ABS_MT_POSITION_Y;
dev = &touch_dev->input_dev;
dev->probe = huamobile_multi_touch_device_probe;
dev->remove = NULL;
dev->event_handler = huamobile_multi_touch_event_handler;
return dev;
}
struct cavan_input_device *cavan_touchpad_device_create(void)
{
struct cavan_touchpad_device *touchpad;
struct cavan_input_device *dev;
touchpad = malloc(sizeof(*touchpad));
if (touchpad == NULL)
{
pr_error_info("malloc");
return NULL;
}
touchpad->x = touchpad->xold = 0;
touchpad->y = touchpad->yold = 0;
touchpad->state = CAVAN_TOUCHPAD_STATE_IDLE;
touchpad->mode = CAVAN_TOUCHPAD_MODE_NONE;
cavan_timer_init(&touchpad->timer, NULL);
dev = &touchpad->input_dev;
dev->probe = cavan_touchpad_probe;
dev->remove = NULL;
dev->event_handler = cavan_touchpad_event_handler;
return dev;
}
int bootimg_write_config_file(const struct bootimg_header *hdr, const char *pathname)
{
int fd;
int ret;
println("write config file `%s'", pathname);
fd = open(pathname, O_WRONLY | O_TRUNC | O_CREAT, 0777);
if (fd < 0)
{
pr_error_info("open file %s", pathname);
return fd;
}
ret = ffile_printf(fd, "kernel_addr: 0x%08x\n", hdr->kernel_addr);
ret |= ffile_printf(fd, "ramdisk_addr: 0x%08x\n", hdr->ramdisk_addr);
ret |= ffile_printf(fd, "second_addr: 0x%08x\n", hdr->second_addr);
ret |= ffile_printf(fd, "tags_addr: 0x%08x\n", hdr->tags_addr);
ret |= ffile_printf(fd, "page_size: %d\n", hdr->page_size);
ret |= ffile_printf(fd, "unused: 0x%08x,0x%08x\n", hdr->unused[0], hdr->unused[1]);
if (hdr->name[0])
{
ret |= ffile_printf(fd, "board: %s\n", hdr->name);
}
if (hdr->cmdline[0])
{
ret |= ffile_printf(fd, "cmdline: %s%s\n", hdr->cmdline, hdr->extra_cmdline);
}
close(fd);
return ret;
}
struct huamobile_input_device *huamobile_mouse_create(void)
{
struct huamobile_mouse_device *mouse;
struct huamobile_input_device *dev;
struct huamobile_touch_point *point;
pr_pos_info();
mouse = malloc(sizeof(*mouse));
if (mouse == NULL)
{
pr_error_info("malloc");
return NULL;
}
mouse->xold = 0;
mouse->yold = 0;
point = &mouse->point;
point->id = 0;
point->x = 0;
point->y = 0;
point->pressure = 0;
point->released = 1;
dev = &mouse->input_dev;
dev->probe = huamobile_mouse_probe;
dev->remove = NULL;
dev->event_handler = huamobile_mouse_event_handler;
return dev;
}
struct huamobile_input_device *huamobile_single_touch_device_create(void)
{
struct huamobile_single_touch_device *ts;
struct huamobile_touch_device *touch_dev;
struct huamobile_input_device *dev;
pr_pos_info();
ts = malloc(sizeof(*ts));
if (ts == NULL)
{
pr_error_info("malloc");
return NULL;
}
ts->pressed = 0;
ts->point.released = 1;
touch_dev = &ts->touch_dev;
touch_dev->xaxis = ABS_X;
touch_dev->yaxis = ABS_Y;
dev = &touch_dev->input_dev;
dev->probe = huamobile_single_touch_device_probe;
dev->remove = NULL;
dev->event_handler = huamobile_single_touch_event_handler;
return dev;
}
static int ext2_read_directory_entry(struct ext2_desc *desc, off_t offset, struct ext2_directory_entry *entry)
{
ssize_t rdlen;
rdlen = ffile_readfrom(desc->fd, entry, EXT2_DIR_ENTRY_HEADER_SIZE, offset);
if (rdlen < 0)
{
pr_error_info("read");
return rdlen;
}
if (entry->inode == 0)
{
pr_red_info("inode is zero");
return -EINVAL;
}
if (entry->name_len == 0)
{
pr_red_info("name length is zero");
return -EINVAL;
}
if (entry->rec_len < EXT2_DIR_ENTRY_HEADER_SIZE + entry->name_len)
{
pr_red_info("rec_len = %d", entry->rec_len);
return -EINVAL;
}
rdlen = ffile_read(desc->fd, entry->name, entry->name_len);
if (rdlen < 0)
{
pr_error_info("read");
return rdlen;
}
entry->name[rdlen] = 0;
#if CAVAN_EXT2_DEBUG
show_ext2_directory_entry(entry);
#endif
return 0;
}
static int cavan_alarm_thread_handler(struct cavan_thread *thread, void *data)
{
struct cavan_alarm_thread *alarm_thread = data;
struct double_link_node *node;
pthread_mutex_lock(&alarm_thread->lock);
node = double_link_get_first_node(&alarm_thread->link);
if (node == NULL)
{
alarm(0);
cavan_thread_suspend(thread);
}
else
{
struct cavan_alarm_node *alarm_node = double_link_get_container(&alarm_thread->link, node);
time_t curr_time;
curr_time = time(NULL);
if (curr_time < 0)
{
pr_error_info("get current time");
pthread_mutex_unlock(&thread->lock);
return curr_time;
}
cavan_show_date2(curr_time, "curr_time = ");
cavan_show_date2(alarm_node->time, "alarm_time = ");
if (curr_time < alarm_node->time)
{
alarm(alarm_node->time - curr_time);
cavan_thread_suspend(thread);
}
else
{
double_link_remove(&alarm_thread->link, node);
alarm_node->handler(alarm_node, alarm_thread, alarm_node->private_data);
if (alarm_node->repeat)
{
alarm_node->time += alarm_node->repeat;
cavan_alarm_insert_node_base(alarm_thread, alarm_node);
}
else if (alarm_node->destroy)
{
alarm_node->destroy(alarm_node, alarm_node->private_data);
}
}
}
pthread_mutex_unlock(&alarm_thread->lock);
return 0;
}
static int ftp_data_service_open(struct network_service *service, struct network_client *client, char *buff, size_t size)
{
u8 *ip;
int ret;
u16 port;
struct in_addr addr;
struct network_url url;
network_url_init(&url, "tcp", "any", 0, NULL);
ret = network_service_open(service, &url, 0);
if (ret < 0)
{
pr_red_info("network_service_open");
return ret;
}
ret = network_service_get_local_port(service);
if (ret < 0)
{
pr_error_info("network_service_get_local_port");
goto out_network_service_close;
}
port = ret;
ret = network_client_get_local_ip(client, &addr);
if (ret < 0)
{
pr_error_info("network_client_getsockname");
goto out_network_service_close;
}
ip = (u8 *) &addr;
return snprintf(buff, size, "227 Entering Passive Mode (%d,%d,%d,%d,%d,%d).\r\n", ip[0], ip[1], ip[2], ip[3], port & 0xFF, (port >> 8) & 0xFF);
out_network_service_close:
network_service_close(service);
return ret;
}
bool cavan_single_touch_device_matcher(struct cavan_event_matcher *matcher, void *data)
{
int ret;
uint8_t abs_bitmask[ABS_BITMASK_SIZE];
uint8_t key_bitmask[KEY_BITMASK_SIZE];
ret = cavan_event_get_abs_bitmask(matcher->fd, abs_bitmask);
if (ret < 0)
{
pr_error_info("cavan_event_get_abs_bitmask");
return false;
}
ret = cavan_event_get_key_bitmask(matcher->fd, key_bitmask);
if (ret < 0)
{
pr_error_info("cavan_event_get_key_bitmask");
return false;
}
return cavan_single_touch_device_match(abs_bitmask, key_bitmask);
}
jwp_bool jwp_comm_init2(struct jwp_comm_desc *comm, const char *pathname, void *data)
{
int fd;
fd = open(pathname, O_RDWR);
if (fd < 0)
{
pr_error_info("open %s", pathname);
return fd;
}
return jwp_comm_init(comm, fd, data);
}
bool cavan_mouse_device_matcher(struct cavan_event_matcher *matcher, void *data)
{
int ret;
uint8_t key_bitmask[KEY_BITMASK_SIZE];
uint8_t rel_bitmask[REL_BITMASK_SIZE];
ret = cavan_event_get_rel_bitmask(matcher->fd, rel_bitmask);
if (ret < 0)
{
pr_error_info("cavan_event_get_rel_bitmask");
return ret;
}
ret = cavan_event_get_key_bitmask(matcher->fd, key_bitmask);
if (ret < 0)
{
pr_error_info("cavan_event_get_key_bitmask");
return ret;
}
return cavan_mouse_device_match(key_bitmask, rel_bitmask);
}
int cavan_cache_init(struct cavan_cache *cache, void *mem, size_t size)
{
int ret;
ret = pthread_mutex_init(&cache->lock, NULL);
if (ret < 0)
{
pr_error_info("pthread_mutex_init");
return ret;
}
ret = pthread_cond_init(&cache->rdcond, NULL);
if (ret < 0)
{
pr_error_info("pthread_cond_init");
goto out_pthread_mutex_destroy_lock;
}
ret = pthread_cond_init(&cache->wrcond, NULL);
if (ret < 0)
{
pr_error_info("pthread_cond_init");
goto out_pthread_cond_destroy_rdcond;
}
cache->size = size;
cache->mem = mem;
cache->mem_end = cache->mem + size;
return 0;
pthread_cond_destroy(&cache->wrcond);
out_pthread_cond_destroy_rdcond:
pthread_cond_destroy(&cache->rdcond);
out_pthread_mutex_destroy_lock:
pthread_mutex_destroy(&cache->lock);
return ret;
}
static jwp_size_t jwp_comm_hw_write(struct jwp_desc *jwp, const void *buff, jwp_size_t size)
{
ssize_t wrlen;
struct jwp_comm_desc *comm = (struct jwp_comm_desc *) jwp;
wrlen = write(comm->fd, buff, size);
if (wrlen < 0)
{
pr_error_info("write");
return 0;
}
return wrlen;
}
static jwp_size_t jwp_comm_hw_read(struct jwp_desc *jwp, void *buff, jwp_size_t size)
{
ssize_t rdlen;
struct jwp_comm_desc *comm = (struct jwp_comm_desc *) jwp;
rdlen = read(comm->fd, buff, size);
if (rdlen < 0)
{
pr_error_info("read");
return 0;
}
return rdlen;
}
struct cavan_xml_tag *cavan_xml_tag_alloc(const char *name, const char *content, int flags)
{
struct cavan_xml_tag *tag;
#if CONFIG_CAVAN_XML_DEBUG
pr_green_info("tag: name = %s", name);
#endif
tag = malloc(sizeof(*tag));
if (tag == NULL) {
pr_error_info("malloc");
return NULL;
}
tag->flags = 0;
if (name && (flags & CAVAN_XML_FLAG_NAME_ALLOC)) {
name = strdup(name);
if (name == NULL) {
goto out_free_tag;
}
tag->flags |= CAVAN_XML_FLAG_NAME_ALLOC;
}
if (content && (flags & CAVAN_XML_FLAG_CONTENT_ALLOC)) {
content = strdup(content);
if (content == NULL) {
goto out_free_name;
}
tag->flags |= CAVAN_XML_FLAG_CONTENT_ALLOC;
}
tag->name = name;
tag->content = content;
tag->child = NULL;
tag->next = NULL;
tag->attr = NULL;
return tag;
out_free_name:
if ((flags & CAVAN_XML_FLAG_NAME_ALLOC)) {
free((char *) name);
}
out_free_tag:
free(tag);
return NULL;
}
bool huamobile_multi_touch_device_matcher(int fd, const char *name, void *data)
{
int ret;
uint8_t abs_bitmask[ABS_BITMASK_SIZE];
pr_pos_info();
ret = huamobile_event_get_abs_bitmask(fd, abs_bitmask);
if (ret < 0) {
pr_error_info("huamobile_event_get_abs_bitmask");
return false;
}
return huamobile_multi_touch_device_match(abs_bitmask);
}
bool huamobile_mouse_device_matcher(int fd, const char *name, void *data)
{
int ret;
uint8_t key_bitmask[KEY_BITMASK_SIZE];
uint8_t rel_bitmask[REL_BITMASK_SIZE];
pr_pos_info();
ret = huamobile_event_get_rel_bitmask(fd, rel_bitmask);
if (ret < 0)
{
pr_error_info("huamobile_event_get_rel_bitmask");
return ret;
}
ret = huamobile_event_get_key_bitmask(fd, key_bitmask);
if (ret < 0)
{
pr_error_info("huamobile_event_get_key_bitmask");
return ret;
}
return huamobile_mouse_device_match(key_bitmask, rel_bitmask);
}
struct cavan_xml_attribute *cavan_xml_attribute_alloc(const char *name, const char *value, int flags)
{
struct cavan_xml_attribute *attr;
#if CONFIG_CAVAN_XML_DEBUG
pr_green_info("attr: name = %s, value = %s", name, value);
#endif
attr = malloc(sizeof(*attr));
if (attr == NULL) {
pr_error_info("malloc");
return NULL;
}
attr->flags = 0;
if (name && (flags & CAVAN_XML_FLAG_NAME_ALLOC)) {
name = strdup(name);
if (name == NULL) {
goto out_free_attr;
}
attr->flags |= CAVAN_XML_FLAG_NAME_ALLOC;
}
if (value && (flags & CAVAN_XML_FLAG_VALUE_ALLOC)) {
value = strdup(value);
if (value == NULL) {
goto out_free_name;
}
attr->flags |= CAVAN_XML_FLAG_VALUE_ALLOC;
}
attr->name = name;
attr->value = value;
attr->next = NULL;
return attr;
out_free_name:
if ((flags & CAVAN_XML_FLAG_NAME_ALLOC)) {
free((char *) name);
}
out_free_attr:
free(attr);
return NULL;
}
int cavan_thread_recv_event_timeout(struct cavan_thread *thread, u32 *event, u32 msec)
{
int ret;
ret = cavan_thread_epoll_wait_event(thread, msec);
if (ret < 0) {
pr_error_info("poll");
return ret;
}
if (ret < 1) {
return 0;
}
return cavan_thread_recv_event(thread, event);
}
char *address_to_symbol(const void *addr, char *buff, size_t size)
{
char **strings;
void *ptrs[] = { (void *) addr };
strings = backtrace_symbols(ptrs, 1);
if (strings == NULL) {
pr_error_info("backtrace_symbols");
return NULL;
}
strncpy(buff, strings[0], size);
free(strings);
return buff;
}
