int main(int argc, char *argv[])
{
if (argc < 2) {
printf("Compositor server not specified.\n");
return 1;
}
list_initialize(&led_devs);
int rc = loc_register_cat_change_cb(loc_callback);
if (rc != EOK) {
printf("Unable to register callback for device discovery.\n");
return 1;
}
led_timer = fibril_timer_create(NULL);
if (!led_timer) {
printf("Unable to create LED timer.\n");
return 1;
}
frame_timer = fibril_timer_create(NULL);
if (!frame_timer) {
printf("Unable to create frame timer.\n");
return 1;
}
if (!decode_frames())
return 1;
winreg = argv[1];
window_t *main_window = window_open(argv[1], NULL,
WINDOW_MAIN | WINDOW_DECORATED, "barber");
if (!main_window) {
printf("Cannot open main window.\n");
return 1;
}
frame_canvas = create_canvas(window_root(main_window), NULL,
FRAME_WIDTH, FRAME_HEIGHT, frames[frame]);
if (!frame_canvas) {
window_close(main_window);
printf("Cannot create widgets.\n");
return 1;
}
window_resize(main_window, 0, 0, FRAME_WIDTH + 8, FRAME_HEIGHT + 28,
WINDOW_PLACEMENT_RIGHT | WINDOW_PLACEMENT_BOTTOM);
window_exec(main_window);
plan_led_timer();
plan_frame_timer(0);
task_retval(0);
async_manager();
return 0;
}
int main(int argc, char *argv[])
{
if (argc >= 2) {
window_t *main_window = window_open(argv[1], NULL,
WINDOW_MAIN | WINDOW_DECORATED | WINDOW_RESIZEABLE, "vdemo");
if (!main_window) {
printf("Cannot open main window.\n");
return 1;
}
pixel_t grd_bg = PIXEL(255, 240, 240, 240);
pixel_t btn_bg = PIXEL(255, 240, 240, 240);
pixel_t btn_fg = PIXEL(255, 186, 186, 186);
pixel_t btn_text = PIXEL(255, 0, 0, 0);
pixel_t lbl_bg = PIXEL(255, 240, 240, 240);
pixel_t lbl_text = PIXEL(255, 0, 0, 0);
my_label_t *lbl_action = create_my_label(NULL, "Hello there!", 16,
lbl_bg, lbl_text);
button_t *btn_confirm = create_button(NULL, NULL, "Confirm", 16,
btn_bg, btn_fg, btn_text);
button_t *btn_cancel = create_button(NULL, NULL, "Cancel", 16,
btn_bg, btn_fg, btn_text);
grid_t *grid = create_grid(window_root(main_window), NULL, 2, 2,
grd_bg);
if (!lbl_action || !btn_confirm || !btn_cancel || !grid) {
window_close(main_window);
printf("Cannot create widgets.\n");
return 1;
}
sig_connect(
&btn_confirm->clicked,
&lbl_action->label.widget,
lbl_action->confirm);
sig_connect(
&btn_cancel->clicked,
&lbl_action->label.widget,
lbl_action->cancel);
grid->add(grid, &lbl_action->label.widget, 0, 0, 2, 1);
grid->add(grid, &btn_confirm->widget, 0, 1, 1, 1);
grid->add(grid, &btn_cancel->widget, 1, 1, 1, 1);
window_resize(main_window, 0, 0, 200, 76,
WINDOW_PLACEMENT_CENTER);
window_exec(main_window);
task_retval(0);
async_manager();
return 1;
} else {
printf("Compositor server not specified.\n");
return 1;
}
}
void exit(int status)
{
if (env_setup) {
__stdio_done();
task_retval(status);
fibril_teardown(__tcb_get()->fibril_data);
}
__SYSCALL1(SYS_TASK_EXIT, false);
/* Unreachable */
while (1);
}
int main(int argc, char **argv)
{
printf("%s: HelenOS APIC driver\n", NAME);
if (!apic_init())
return -1;
printf("%s: Accepting connections\n", NAME);
task_retval(0);
async_manager();
/* Never reached */
return 0;
}
int main(int argc, char *argv[])
{
printf("%s: Task Monitoring Service\n", NAME);
if (event_subscribe(EVENT_FAULT, 0) != EOK) {
printf("%s: Error registering fault notifications.\n", NAME);
return -1;
}
async_set_interrupt_received(fault_event);
task_retval(0);
async_manager();
return 0;
}
int main(int argc, char *argv[])
{
service_id_t service_id;
int rc;
int i;
printf(NAME ": VIA-CUDA Apple Desktop Bus driver\n");
for (i = 0; i < ADB_MAX_ADDR; ++i) {
adb_dev[i].client_sess = NULL;
adb_dev[i].service_id = 0;
}
async_set_client_connection(cuda_connection);
rc = loc_server_register(NAME);
if (rc < 0) {
printf(NAME ": Unable to register server.\n");
return rc;
}
rc = loc_service_register("adb/kbd", &service_id);
if (rc != EOK) {
printf(NAME ": Unable to register service %s.\n", "adb/kdb");
return rc;
}
adb_dev[2].service_id = service_id;
adb_dev[8].service_id = service_id;
rc = loc_service_register("adb/mouse", &service_id);
if (rc != EOK) {
printf(NAME ": Unable to register servise %s.\n", "adb/mouse");
return rc;
}
adb_dev[9].service_id = service_id;
if (cuda_init() < 0) {
printf("cuda_init() failed\n");
return 1;
}
task_retval(0);
async_manager();
return 0;
}
int main(int argc, char *argv[])
{
log_init(NAME);
log_msg(LOG_DEFAULT, LVL_NOTE, "HelenOS UDF 1.02 file system server");
if (argc == 3) {
if (!str_cmp(argv[1], "--instance"))
udf_vfs_info.instance = strtol(argv[2], NULL, 10);
else {
log_msg(LOG_DEFAULT, LVL_FATAL, "Unrecognized parameters");
return 1;
}
}
async_sess_t *vfs_sess =
service_connect_blocking(SERVICE_VFS, INTERFACE_VFS_DRIVER, 0);
if (!vfs_sess) {
log_msg(LOG_DEFAULT, LVL_FATAL, "Failed to connect to VFS");
return 2;
}
int rc = fs_register(vfs_sess, &udf_vfs_info, &udf_ops,
&udf_libfs_ops);
if (rc != EOK)
goto err;
rc = udf_idx_init();
if (rc != EOK)
goto err;
log_msg(LOG_DEFAULT, LVL_NOTE, "Accepting connections");
task_retval(0);
async_manager();
/* Not reached */
return 0;
err:
log_msg(LOG_DEFAULT, LVL_FATAL, "Failed to register file system (%d)", rc);
return rc;
}
int main(int argc, char **argv)
{
printf(NAME ": HelenOS FAT file system server\n");
if (argc == 3) {
if (!str_cmp(argv[1], "--instance"))
fat_vfs_info.instance = strtol(argv[2], NULL, 10);
else {
printf(NAME " Unrecognized parameters");
return -1;
}
}
int rc = fat_idx_init();
if (rc != EOK)
goto err;
async_sess_t *vfs_sess = service_connect_blocking(EXCHANGE_SERIALIZE,
SERVICE_VFS, 0, 0);
if (!vfs_sess) {
printf(NAME ": failed to connect to VFS\n");
return -1;
}
rc = fs_register(vfs_sess, &fat_vfs_info, &fat_ops, &fat_libfs_ops);
if (rc != EOK) {
fat_idx_fini();
goto err;
}
printf(NAME ": Accepting connections\n");
task_retval(0);
async_manager();
/* Not reached */
return 0;
err:
printf(NAME ": Failed to register file system (%d)\n", rc);
return rc;
}
int main(int argc, char **argv)
{
printf("%s: HelenOS ext4 file system server\n", NAME);
if (argc == 3) {
if (!str_cmp(argv[1], "--instance"))
ext4fs_vfs_info.instance = strtol(argv[2], NULL, 10);
else {
printf("%s: Unrecognized parameters\n", NAME);
return 1;
}
}
async_sess_t *vfs_sess = service_connect_blocking(EXCHANGE_SERIALIZE,
SERVICE_VFS, 0, 0);
if (!vfs_sess) {
printf("%s: Failed to connect to VFS\n", NAME);
return 2;
}
int rc = ext4fs_global_init();
if (rc != EOK) {
printf("%s: Global initialization failed\n", NAME);
return rc;
}
rc = fs_register(vfs_sess, &ext4fs_vfs_info, &ext4fs_ops,
&ext4fs_libfs_ops);
if (rc != EOK) {
printf("%s: Failed to register file system\n", NAME);
return rc;
}
printf("%s: Accepting connections\n", NAME);
task_retval(0);
async_manager();
/* Not reached */
return 0;
}
int main(int argc, char *argv[])
{
int rc;
printf(NAME ": HelenOS IP over Ethernet service\n");
if (log_init(NAME) != EOK) {
printf(NAME ": Failed to initialize logging.\n");
return 1;
}
rc = ethip_init();
if (rc != EOK)
return 1;
printf(NAME ": Accepting connections.\n");
task_retval(0);
async_manager();
/* Not reached */
return 0;
}
int main(int argc, char **argv)
{
int rc;
char *image_name;
char *device_name;
category_id_t disk_cat;
printf(NAME ": File-backed block device driver\n");
block_size = DEFAULT_BLOCK_SIZE;
++argv; --argc;
while (*argv != NULL && (*argv)[0] == '-') {
/* Option */
if (str_cmp(*argv, "-b") == 0) {
if (argc < 2) {
printf("Argument missing.\n");
print_usage();
return -1;
}
rc = str_size_t(argv[1], NULL, 10, true, &block_size);
if (rc != EOK || block_size == 0) {
printf("Invalid block size '%s'.\n", argv[1]);
print_usage();
return -1;
}
++argv; --argc;
} else {
printf("Invalid option '%s'.\n", *argv);
print_usage();
return -1;
}
++argv; --argc;
}
if (argc < 2) {
printf("Missing arguments.\n");
print_usage();
return -1;
}
image_name = argv[0];
device_name = argv[1];
if (file_bd_init(image_name) != EOK)
return -1;
rc = loc_service_register(device_name, &service_id);
if (rc != EOK) {
printf("%s: Unable to register device '%s'.\n",
NAME, device_name);
return rc;
}
rc = loc_category_get_id("disk", &disk_cat, IPC_FLAG_BLOCKING);
if (rc != EOK) {
printf("%s: Failed resolving category 'disk'.\n", NAME);
return rc;
}
rc = loc_service_add_to_cat(service_id, disk_cat);
if (rc != EOK) {
printf("%s: Failed adding %s to category.",
NAME, device_name);
return rc;
}
printf("%s: Accepting connections\n", NAME);
task_retval(0);
async_manager();
/* Not reached */
return 0;
}
int main(int argc, char *argv[])
{
char buffer[30];
struct timeval tv;
struct tm result;
window_t *main_window = window_open(argv[1], true, true," ",0,720);
if (!main_window) {
printf("Cannot open main window.\n");
return 1;
}
time_t curtime;
gettimeofday(&tv, NULL);
curtime=tv.tv_sec;
time_utc2tm(curtime,&result);
strftime(buffer,30,"%T %m-%d-%Y",&result);
pixel_t grd_bg = PIXEL(255, 25, 25, 112);
pixel_t lbl_bg = PIXEL(255, 25, 25, 112);//(255, 240, 240, 240);
pixel_t lbl_fg = PIXEL(255, 255, 255, 255);
my_label_t *stime= create_my_label(NULL,buffer, 16, lbl_bg, lbl_fg);
grid_t *grid = create_grid(window_root(main_window),1, 10, grd_bg);
grid->add(grid, &stime->label.widget, 0, 7, 1, 2);
window_resize(main_window,1024,60);
window_exec(main_window);
while(1){
gettimeofday(&tv, NULL);
curtime=tv.tv_sec;
time_utc2tm(curtime,&result);
//Converting month to integer
char month[5];
strftime(month,5,"%m",&result);
char *mon;
mon=month;
int value=0;
value=toInteger1(mon);
switch(value){
case 0:
strftime(buffer,30,"%T Jan-%d, %Y",&result);
break;
case 1:
strftime(buffer,30,"%T Feb-%d, %Y",&result);
break;
case 2:
strftime(buffer,30,"%T Mar-%d, %Y",&result);
break;
case 3:
strftime(buffer,30,"%T Apr-%d, %Y",&result);
break;
case 4:
strftime(buffer,30,"%T May-%d, %Y",&result);
break;
case 5:
strftime(buffer,30,"%T Jun-%d, %Y",&result);
break;
case 6:
strftime(buffer,30,"%T Jul-%d, %Y",&result);
break;
case 7:
strftime(buffer,30,"%T Aug-%d, %Y",&result);
break;
case 8:
strftime(buffer,30,"%T Sep-%d, %Y",&result);
break;
case 9:
strftime(buffer,30,"%T Oct-%d, %Y",&result);
break;
case 10:
strftime(buffer,30,"%T Nov-%d, %Y",&result);
break;
case 11:
strftime(buffer,30,"%T Dec-%d, %Y",&result);
break;
}
stime->label.rewrite(&stime->label.widget, (void *)buffer);
}
task_retval(0);
async_manager();
return 0;
}
int main(int argc, char *argv[])
{
int port = 2223;
async_set_client_connection(client_connection);
int rc = loc_server_register(NAME);
if (rc != EOK) {
fprintf(stderr, "%s: Unable to register server\n", NAME);
return rc;
}
struct sockaddr_in addr;
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
rc = inet_pton(AF_INET, "127.0.0.1", (void *)
&addr.sin_addr.s_addr);
if (rc != EOK) {
fprintf(stderr, "Error parsing network address: %s.\n",
str_error(rc));
return 2;
}
int listen_sd = socket(PF_INET, SOCK_STREAM, 0);
if (listen_sd < 0) {
fprintf(stderr, "Error creating listening socket: %s.\n",
str_error(listen_sd));
return 3;
}
rc = bind(listen_sd, (struct sockaddr *) &addr, sizeof(addr));
if (rc != EOK) {
fprintf(stderr, "Error binding socket: %s.\n",
str_error(rc));
return 4;
}
rc = listen(listen_sd, BACKLOG_SIZE);
if (rc != EOK) {
fprintf(stderr, "listen() failed: %s.\n", str_error(rc));
return 5;
}
printf("%s: HelenOS Remote console service\n", NAME);
task_retval(0);
while (true) {
struct sockaddr_in raddr;
socklen_t raddr_len = sizeof(raddr);
int conn_sd = accept(listen_sd, (struct sockaddr *) &raddr,
&raddr_len);
if (conn_sd < 0) {
fprintf(stderr, "accept() failed: %s.\n",
str_error(rc));
continue;
}
telnet_user_t *user = telnet_user_create(conn_sd);
assert(user);
con_srvs_init(&user->srvs);
user->srvs.ops = &con_ops;
user->srvs.sarg = user;
user->srvs.abort_timeout = 1000;
telnet_user_add(user);
fid_t fid = fibril_create(network_user_fibril, user);
assert(fid);
fibril_add_ready(fid);
}
return 0;
}
int main(int argc, char **argv)
{
log_init(NAME);
if (argc <= 3) {
syntax_print();
return 1;
}
const char *rfb_name = argv[1];
char *endptr;
unsigned long width = strtoul(argv[2], &endptr, 0);
if (*endptr != 0) {
fprintf(stderr, "Invalid width\n");
syntax_print();
return 1;
}
unsigned long height = strtoul(argv[3], &endptr, 0);
if (*endptr != 0) {
fprintf(stderr, "Invalid height\n");
syntax_print();
return 1;
}
unsigned long port = 5900;
if (argc > 4) {
port = strtoul(argv[4], &endptr, 0);
if (*endptr != 0) {
fprintf(stderr, "Invalid port number\n");
syntax_print();
return 1;
}
}
rfb_init(&rfb, width, height, rfb_name);
vis = malloc(sizeof(visualizer_t));
if (vis == NULL) {
fprintf(stderr, "Failed allocating visualizer struct\n");
return 3;
}
graph_init_visualizer(vis);
pixel_mode.mode.index = 0;
pixel_mode.mode.version = 0;
pixel_mode.mode.refresh_rate = 0;
pixel_mode.mode.screen_aspect.width = rfb.width;
pixel_mode.mode.screen_aspect.height = rfb.height;
pixel_mode.mode.screen_width = rfb.width;
pixel_mode.mode.screen_height = rfb.height;
pixel_mode.mode.cell_aspect.width = 1;
pixel_mode.mode.cell_aspect.height = 1;
pixel_mode.mode.cell_visual.pixel_visual = VISUAL_RGB_8_8_8;
link_initialize(&pixel_mode.link);
list_append(&pixel_mode.link, &vis->modes);
vis->def_mode_idx = 0;
vis->ops = rfb_ops;
vis->dev_ctx = NULL;
async_set_fallback_port_handler(client_connection, NULL);
int rc = loc_server_register(NAME);
if (rc != EOK) {
printf("%s: Unable to register server.\n", NAME);
return rc;
}
char *service_name;
rc = asprintf(&service_name, "rfb/%s", rfb_name);
if (rc < 0) {
printf(NAME ": Unable to create service name\n");
return rc;
}
service_id_t service_id;
rc = loc_service_register(service_name, &service_id);
if (rc != EOK) {
printf(NAME ": Unable to register service %s.\n", service_name);
return rc;
}
free(service_name);
category_id_t visualizer_category;
rc = loc_category_get_id("visualizer", &visualizer_category, IPC_FLAG_BLOCKING);
if (rc != EOK) {
fprintf(stderr, NAME ": Unable to get visualizer category id.\n");
return 1;
}
rc = loc_service_add_to_cat(service_id, visualizer_category);
if (rc != EOK) {
fprintf(stderr, NAME ": Unable to add service to visualizer category.\n");
return 1;
}
rc = rfb_listen(&rfb, port);
if (rc != EOK) {
fprintf(stderr, NAME ": Unable to listen at rfb port\n");
return 2;
}
printf("%s: Accepting connections\n", NAME);
task_retval(0);
async_manager();
/* Not reached */
return 0;
}
int main(int argc, char **argv)
{
sysarg_t baud = 38400;
service_id_t svc_id;
char *serial_port_name = NULL;
int arg = 1;
int rc;
isdv4_event_fn event_fn = emit_event;
if (argc > arg && str_test_prefix(argv[arg], "--baud=")) {
size_t arg_offset = str_lsize(argv[arg], 7);
char* arg_str = argv[arg] + arg_offset;
if (str_length(arg_str) == 0) {
fprintf(stderr, "--baud requires an argument\n");
syntax_print();
return 1;
}
char *endptr;
baud = strtol(arg_str, &endptr, 10);
if (*endptr != '\0') {
fprintf(stderr, "Invalid value for baud\n");
syntax_print();
return 1;
}
arg++;
}
if (argc > arg && str_cmp(argv[arg], "--print-events") == 0) {
event_fn = print_and_emit_event;
arg++;
}
if (argc > arg) {
serial_port_name = argv[arg];
rc = loc_service_get_id(serial_port_name, &svc_id, 0);
if (rc != EOK) {
fprintf(stderr, "Cannot find device service %s\n",
argv[arg]);
return 1;
}
arg++;
}
else {
category_id_t serial_cat_id;
rc = loc_category_get_id("serial", &serial_cat_id, 0);
if (rc != EOK) {
fprintf(stderr, "Failed getting id of category "
"'serial'\n");
return 1;
}
service_id_t *svc_ids;
size_t svc_count;
rc = loc_category_get_svcs(serial_cat_id, &svc_ids, &svc_count); if (rc != EOK) {
fprintf(stderr, "Failed getting list of services\n");
return 1;
}
if (svc_count == 0) {
fprintf(stderr, "No service in category 'serial'\n");
free(svc_ids);
return 1;
}
svc_id = svc_ids[0];
rc = loc_service_get_name(svc_id, &serial_port_name);
if (rc != EOK) {
fprintf(stderr, "Failed getting name of serial service\n");
return 1;
}
free(svc_ids);
}
if (argc > arg) {
fprintf(stderr, "Too many arguments\n");
syntax_print();
return 1;
}
fibril_mutex_initialize(&client_mutex);
printf(NAME ": Using serial port %s\n", serial_port_name);
async_sess_t *sess = loc_service_connect(svc_id, INTERFACE_DDF,
IPC_FLAG_BLOCKING);
if (!sess) {
fprintf(stderr, "Failed connecting to service\n");
}
async_exch_t *exch = async_exchange_begin(sess);
rc = async_req_4_0(exch, SERIAL_SET_COM_PROPS, baud,
SERIAL_NO_PARITY, 8, 1);
async_exchange_end(exch);
if (rc != EOK) {
fprintf(stderr, "Failed setting serial properties\n");
return 2;
}
rc = isdv4_init(&state, sess, event_fn);
if (rc != EOK) {
fprintf(stderr, "Failed initializing isdv4 state");
return 2;
}
rc = isdv4_init_tablet(&state);
if (rc != EOK) {
fprintf(stderr, "Failed initializing tablet");
return 2;
}
printf("Tablet information:\n");
printf(" Stylus: %ux%u pressure: %u tilt: ", state.stylus_max_x,
state.stylus_max_y, state.stylus_max_pressure);
if (state.stylus_tilt_supported) {
printf("%ux%u\n", state.stylus_max_xtilt, state.stylus_max_ytilt);
}
else {
printf("not supported\n");
}
printf(" Touch: %ux%u type: %s\n", state.touch_max_x, state.touch_max_y,
touch_type(state.touch_type));
fid_t fibril = fibril_create(read_fibril, NULL);
/* From this on, state is to be used only by read_fibril */
fibril_add_ready(fibril);
async_set_fallback_port_handler(mouse_connection, NULL);
rc = loc_server_register(NAME);
if (rc != EOK) {
printf("%s: Unable to register driver.\n", NAME);
return rc;
}
service_id_t service_id;
char *service_name;
rc = asprintf(&service_name, "mouse/isdv4-%" PRIun, svc_id);
if (rc < 0) {
printf(NAME ": Unable to create service name\n");
return rc;
}
rc = loc_service_register(service_name, &service_id);
if (rc != EOK) {
printf(NAME ": Unable to register service %s.\n", service_name);
return rc;
}
category_id_t mouse_category;
rc = loc_category_get_id("mouse", &mouse_category, IPC_FLAG_BLOCKING);
if (rc != EOK) {
printf(NAME ": Unable to get mouse category id.\n");
}
else {
rc = loc_service_add_to_cat(service_id, mouse_category);
if (rc != EOK) {
printf(NAME ": Unable to add device to mouse category.\n");
}
}
printf("%s: Accepting connections\n", NAME);
task_retval(0);
async_manager();
/* Not reached */
return 0;
}
