static int file_bd_init(const char *fname) { async_set_client_connection(file_bd_connection); int rc = loc_server_register(NAME); if (rc != EOK) { printf("%s: Unable to register driver.\n", NAME); return rc; } img = fopen(fname, "rb+"); if (img == NULL) return EINVAL; if (fseek(img, 0, SEEK_END) != 0) { fclose(img); return EIO; } off64_t img_size = ftell(img); if (img_size < 0) { fclose(img); return EIO; } num_blocks = img_size / block_size; fibril_mutex_initialize(&dev_lock); return EOK; }
int main(int argc, char **argv) { printf("%s: HelenOS VFS server\n", NAME); /* * Initialize VFS node hash table. */ if (!vfs_nodes_init()) { printf("%s: Failed to initialize VFS node hash table\n", NAME); return ENOMEM; } /* * Allocate and initialize the Path Lookup Buffer. */ plb = as_area_create(AS_AREA_ANY, PLB_SIZE, AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE); if (plb == AS_MAP_FAILED) { printf("%s: Cannot create address space area\n", NAME); return ENOMEM; } memset(plb, 0, PLB_SIZE); /* * Set client data constructor and destructor. */ async_set_client_data_constructor(vfs_client_data_create); async_set_client_data_destructor(vfs_client_data_destroy); /* * Set a connection handling function/fibril. */ async_set_client_connection(vfs_connection); /* * Set notification handler and subscribe to notifications. */ async_set_interrupt_received(notification_received); event_task_subscribe(EVENT_TASK_STATE_CHANGE, VFS_TASK_STATE_CHANGE); /* * Register at the naming service. */ int rc = service_register(SERVICE_VFS); if (rc != EOK) { printf("%s: Cannot register VFS service\n", NAME); return rc; } /* * Start accepting connections. */ printf("%s: Accepting connections\n", NAME); async_manager(); return 0; }
int tcp_sock_init(void) { socket_ports_initialize(&gsock); async_set_client_connection(tcp_sock_connection); int rc = service_register(SERVICE_TCP); if (rc != EOK) return EEXIST; return EOK; }
static int ethip_init(void) { async_set_client_connection(ethip_client_conn); int rc = loc_server_register(NAME); if (rc != EOK) { log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering server."); return rc; } rc = ethip_nic_discovery_start(); if (rc != EOK) return rc; return EOK; }
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; }
/** Program loader main function. */ int main(int argc, char *argv[]) { /* Set a handler of incomming connections. */ async_set_client_connection(ldr_connection); /* Introduce this task to the NS (give it our task ID). */ task_id_t id = task_get_id(); int rc = ns_intro(id); if (rc != EOK) return rc; /* Register at naming service. */ rc = service_register(SERVICE_LOAD); if (rc != EOK) return rc; async_manager(); /* Never reached */ return 0; }
int main(int argc, char *argv[]) { printf(NAME ": HelenOS Logging Service\n"); parse_initial_settings(); for (int i = 1; i < argc; i++) { parse_level_settings(argv[i]); } async_set_client_connection(connection_handler); int rc = service_register(SERVICE_LOGGER); if (rc != EOK) { printf(NAME ": failed to register: %s.\n", str_error(rc)); return -1; } printf(NAME ": Accepting connections\n"); async_manager(); /* Never reached */ 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) { 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(EXCHANGE_SERIALIZE, svc_id, 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_client_connection(mouse_connection); 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; }