extern "C" void kmain(uint64_t magic, multiboot_info_t * info)
{
uint64_t volatile old_count=0;
Video::Install();
show_welcome();
show_boot_msg("test", "info", true);
show_boot_msg("test", "info", false);
Idt::Install();
Isr::install();
Irq::Install();
sti();
VirtualMemory::Install();
old_count = g_cpu_count;
printf("In 64bit now - %d CPU's Active\n", old_count);
for (;;)
{
if (old_count != g_cpu_count)
{
old_count = g_cpu_count;
printf("In 64bit now - %d CPU's Active\n", old_count);
}
}
}
static void menu_select_callback(MenuLayer *menu_layer, MenuIndex *cell_index, void *data) {
switch (cell_index->row) {
case 0:
next_unit_index();
break;
case 1:
next_format();
break;
case 2:
toggle_first_day();
break;
case 3:
if (!get_has_reminders()) {
show_time();
} else {
set_has_reminders(0);
cancell_all_reminders();
menu_layer_reload_data(menu_layer);
}
break;
case 4:
show_welcome();
break;
}
layer_mark_dirty((Layer *)menu_layer_get_scroll_layer(menu_layer));
}
/**
* void main_loop(FILE *stream, int interactive)
*
* Reads, tokenises, parses ane executes input from the given stream. If
* interactive mode is on, outputs a welcome message and a prompt.
*/
void main_loop(FILE *stream, int interactive) {
char buffer[BUFFER_MAX_SIZE];
char last_line[BUFFER_MAX_SIZE];
int more_to_read = TRUE;
tokarray_t *tokens;
expression_t *expr;
bzero(buffer, BUFFER_MAX_SIZE);
bzero(last_line, BUFFER_MAX_SIZE);
if (interactive == TRUE) {
show_welcome();
}
while (more_to_read == TRUE) {
if (interactive == TRUE) {
show_prompt();
}
/* Read a line of input. */
more_to_read = read_data(stream, buffer, BUFFER_MAX_SIZE);
if (strlen(buffer) == 0) {
continue;
}
strcpy(last_line, buffer);
/* Tokenise the input. */
tokens = tokenise_input(buffer);
if (tokens == NULL) {
printf("!tmnsh: Could not tokenise input: %s\n", last_line);
continue;
}
/* Parse the tokens into an expression. */
expr = parse_tokens(tokens);
if (expr == NULL) {
printf("!tmnsh: Could not parse input: %s\n", last_line);
tokarray_destroy(tokens); /* Clean up. */
continue;
}
/* Interpret the expression and execute the commands. */
interpret_expression(expr);
expression_destroy(expr); /* Clean up. */
bzero(buffer, BUFFER_MAX_SIZE);
bzero(last_line, BUFFER_MAX_SIZE);
}
}
//
// Implement the CThread::run() virtual function
//
virtual void run() {
m_con.assign(m_usb, m_usb);
m_usb.enable();
while(1) {
if ( m_usb.isConnected() ) {
show_welcome();
}
LEDs[3] = !LEDs[3];
sleep(500);
}
int main(void)
{
// 设定吃药方案，并上传到服务器
// 设定吃药方案，并传给药盒
// 修改吃药方案，上传服务器
// 接收服务器的信息
// 过往吃药信息查询
// 手机注册
int ret,fd,maxfd;
struct sockaddr_in sin;
char buf[BUFSIZ];
fd_set rset;
struct timeval tout;
sqlite3 *db;
sqlite3_open("./mdc.db", &db);//打开数据库文件
create(db);
show_welcome();
/*1.创建一个套接字*/
fd=socket(AF_INET,SOCK_STREAM,0);//ipV4的TCP编程
if(fd<0)
{
perror("socket fail");
exit(1);
}
/*2.连接服务器*/
/*2.1 填充要连接的服务器信息*/
bzero(&sin,sizeof(sin));
sin.sin_family=AF_INET;
sin.sin_port=htons(SERV_PORT);//主机字节序转换为网络字节序
//十进制点分形式字符串IP地址转换为32位二进制的网络字节
sin.sin_addr.s_addr=inet_addr(SERV_IP1);
/*2.2 连接服务器(在两个套接字之间创建连接)*/
if(connect(fd,(struct sockaddr *)&sin,sizeof(sin))<0)
{
perror("connect fail");
exit(1);
}
printf ("TCP client starting...OK!\n");
/*3.和服务器进行数据交互*/
while(1)
{
tout.tv_sec=5;
tout.tv_usec=0;
/*把rset清零*/
FD_ZERO(&rset);
/*依次把所有要监控的文件描述符加入到集合rset中*/
FD_SET(0,&rset);
FD_SET(fd,&rset);
maxfd=fd;
/*调用select函数*/
ret=select(maxfd+1,&rset,NULL,NULL,&tout);
/*依次判断被监控的文件描述符是否有数据*/
if(FD_ISSET(0,&rset))//标准键盘上有输入
{
bzero(buf,BUFSIZ);
input_handle(fd,buf,BUFSIZ-1,db);
}
if(FD_ISSET(fd,&rset))//套接字上有数据
{
bzero(buf,BUFSIZ);
ser_data_handle(fd,buf,BUFSIZ-1);
}
/*确认是否是超时返回*/
if(!ret||(tout.tv_sec==0&&tout.tv_usec==0))
printf("timeout!\n");
}
sqlite3_close(db);//关闭数据库
close(fd);
return 0;
}
static int signal_update_order(LassiConnection *lc, DBusMessage *m) {
gint32 generation;
DBusError e;
DBusMessageIter iter, sub;
GList *new_order = NULL, *merged_order = NULL;
int r = 0;
int c = 0;
dbus_error_init(&e);
if (!(dbus_message_get_args(
m, &e,
DBUS_TYPE_INT32, &generation,
DBUS_TYPE_INVALID))) {
g_warning("Received invalid message: %s", e.message);
dbus_error_free(&e);
return -1;
}
dbus_message_iter_init(m, &iter);
dbus_message_iter_next(&iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY || dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRING) {
g_debug("Bad connection list fo the left");
return -1;
}
if (lc->server->order_generation > generation) {
g_debug("Ignoring request for layout");
return 0;
}
dbus_message_iter_recurse(&iter, &sub);
while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
const char *id;
dbus_message_iter_get_basic(&sub, &id);
new_order = g_list_prepend(new_order, g_strdup(id));
dbus_message_iter_next(&sub);
}
new_order = g_list_reverse(new_order);
if (!lassi_list_nodups(new_order)) {
g_warning("Received invalid list.");
r = -1;
goto finish;
}
c = lassi_list_compare(lc->server->order, new_order);
if (c == 0) {
g_debug("Requested order identical to ours.");
goto finish;
}
if (lc->server->order_generation == generation && c > 0) {
g_debug("Ignoring request for layout 2");
goto finish;
}
merged_order = lassi_list_merge(lassi_list_copy(new_order), lc->server->order);
if (lassi_list_compare(lc->server->order, merged_order)) {
lassi_server_set_order(lc->server, merged_order);
merged_order = NULL;
}
lassi_server_send_update_order(lc->server, lassi_list_compare(lc->server->order, new_order) ? NULL : lc);
lc->server->order_generation = generation;
finish:
lassi_list_free(new_order);
lassi_list_free(merged_order);
if (lc->delayed_welcome) {
lc->delayed_welcome = FALSE;
show_welcome(lc, TRUE);
}
return r;
}
static int signal_hello(LassiConnection *lc, DBusMessage *m) {
const char *id, *address;
DBusError e;
GList *i;
dbus_bool_t b;
DBusMessage *n;
gint32 active_generation, order_generation, clipboard_generation;
dbus_error_init(&e);
if (lc->id) {
g_debug("Received duplicate HelloNode.");
return -1;
}
if (!(dbus_message_get_args(
m, &e,
DBUS_TYPE_STRING, &id,
DBUS_TYPE_STRING, &address,
DBUS_TYPE_INT32, &active_generation,
DBUS_TYPE_INT32, &order_generation,
DBUS_TYPE_INT32, &clipboard_generation,
DBUS_TYPE_INVALID))) {
g_warning("Received invalid message: %s", e.message);
dbus_error_free(&e);
return -1;
}
if (strcmp(id, lc->server->id) == 0) {
g_debug("Dropping looped back connection.");
return -1;
}
if (g_hash_table_lookup(lc->server->connections_by_id, id)) {
g_debug("Dropping duplicate connection.");
return -1;
}
lc->server->active_generation = MAX(lc->server->active_generation, active_generation);
lc->server->order_generation = MAX(lc->server->order_generation, order_generation);
lc->server->clipboard_generation = MAX(lc->server->clipboard_generation, clipboard_generation);
g_debug("Got welcome from %s (%s)", id, address);
lc->id = g_strdup(id);
lc->address = g_strdup(address);
g_hash_table_insert(lc->server->connections_by_id, lc->id, lc);
server_position_connection(lc->server, lc);
/* Notify all old nodes of the new one */
n = dbus_message_new_signal("/", LASSI_INTERFACE, "NodeAdded");
g_assert(n);
b = dbus_message_append_args(n, DBUS_TYPE_STRING, &id, DBUS_TYPE_STRING, &address, DBUS_TYPE_INVALID);
g_assert(b);
server_broadcast(lc->server, n, lc);
dbus_message_unref(n);
/* Notify new node about old nodes */
for (i = lc->server->connections; i; i = i->next) {
LassiConnection *k = i->data;
if (k == lc || !k->id)
continue;
n = dbus_message_new_signal("/", LASSI_INTERFACE, "NodeAdded");
g_assert(n);
b = dbus_message_append_args(n, DBUS_TYPE_STRING, &id, DBUS_TYPE_STRING, &address, DBUS_TYPE_INVALID);
g_assert(b);
b = dbus_connection_send(lc->dbus_connection, n, NULL);
g_assert(b);
dbus_message_unref(n);
}
if (lc->we_are_client) {
server_send_update_grab(lc->server, -1);
lassi_server_send_update_order(lc->server, NULL);
lc->delayed_welcome = FALSE;
show_welcome(lc, TRUE);
} else
lc->delayed_welcome = TRUE;
server_layout_changed(lc->server, -1);
lassi_prefs_update(&lc->server->prefs_info);
server_dump(lc->server);
return 0;
}
static void connection_unlink(LassiConnection *lc, gboolean remove_from_order) {
LassiServer *ls;
g_assert(lc);
g_debug("Unlinking %s (%s)", lc->id, lc->address);
ls = lc->server;
if (lc->id) {
DBusMessage *n;
dbus_bool_t b;
/* Tell everyone */
n = dbus_message_new_signal("/", LASSI_INTERFACE, "NodeRemoved");
g_assert(n);
b = dbus_message_append_args(n,
DBUS_TYPE_STRING, &lc->id,
DBUS_TYPE_STRING, &lc->address,
DBUS_TYPE_BOOLEAN, &remove_from_order,
DBUS_TYPE_INVALID);
g_assert(b);
server_broadcast(ls, n, NULL);
dbus_message_unref(n);
}
ls->connections = g_list_remove(ls->connections, lc);
ls->n_connections --;
if (lc->id) {
show_welcome(lc, FALSE);
g_hash_table_remove(ls->connections_by_id, lc->id);
ls->connections_left = g_list_remove(ls->connections_left, lc);
ls->connections_right = g_list_remove(ls->connections_right, lc);
if (ls->active_connection == lc)
server_pick_active_connection(ls);
if (ls->clipboard_connection == lc) {
ls->clipboard_connection = NULL;
ls->clipboard_empty = TRUE;
lassi_clipboard_clear(&lc->server->clipboard_info, FALSE);
}
if (ls->primary_connection == lc) {
ls->primary_connection = NULL;
ls->primary_empty = TRUE;
lassi_clipboard_clear(&lc->server->clipboard_info, TRUE);
}
if (remove_from_order) {
GList *i = g_list_find_custom(ls->order, lc->id, (GCompareFunc) strcmp);
if (i)
ls->order = g_list_delete_link(ls->order, i);
}
server_layout_changed(ls, -1);
lassi_prefs_update(&ls->prefs_info);
server_dump(ls);
}
lassi_tray_update(&ls->tray_info, ls->n_connections);
connection_destroy(lc);
}
