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;
}
