Changeset 70253688 in mainline for uspace/srv

Timestamp:

2012-09-07T08:12:05Z (14 years ago)

Author:

Vojtech Horky <vojtechhorky@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

e0c836e8

Parents:

131d9a4 (diff), 8cf4823 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge mainline changes

Location:

uspace/srv

Files:

• fs/udf/Makefile (added)
• fs/udf/udf.c (added)
• fs/udf/udf.h (added)
• fs/udf/udf_cksum.c (added)
• fs/udf/udf_cksum.h (added)
• fs/udf/udf_file.c (added)
• fs/udf/udf_file.h (added)
• fs/udf/udf_idx.c (added)
• fs/udf/udf_idx.h (added)
• fs/udf/udf_ops.c (added)
• fs/udf/udf_osta.c (added)
• fs/udf/udf_osta.h (added)
• fs/udf/udf_types.h (added)
• fs/udf/udf_volume.c (added)
• fs/udf/udf_volume.h (added)
• hid/compositor/compositor.c (modified) (35 diffs)
• hid/compositor/compositor.h (modified) (1 diff)
• hid/console/console.c (modified) (18 diffs)
• hid/remcons/remcons.c (modified) (8 diffs)
• hid/remcons/user.c (modified) (3 diffs)
• hid/remcons/user.h (modified) (3 diffs)
• net/ethip/pdu.c (modified) (2 diffs)
• net/tcp/conn.c (modified) (2 diffs)
• net/tcp/segment.c (modified) (1 diff)
• net/tcp/sock.c (modified) (3 diffs)
• net/tcp/tqueue.c (modified) (1 diff)
• net/udp/sock.c (modified) (1 diff)

uspace/srv/hid/compositor/compositor.c

@@ -49 +49 @@
 #include <adt/prodcons.h>
 #include <adt/list.h>
+#include <io/input.h>
 #include <ipc/graph.h>
-#include <ipc/input.h>
 #include <ipc/window.h>
 
@@ -92 +92 @@
         sysarg_t id;
         uint8_t state;
-        sysarg_t hpos;
-        sysarg_t vpos;
+        desktop_point_t pos;
         sysarg_t btn_num;
-        sysarg_t btn_hpos;
-        sysarg_t btn_vpos;
-        int accum_dx;
-        int accum_dy;
+        desktop_point_t btn_pos;
+        desktop_vector_t accum;
         sysarg_t grab_flags;
         bool pressed;
@@ -135 +132 @@
         vslmode_t mode;
         async_sess_t *sess;
-        sysarg_t hpos;
-        sysarg_t vpos;
+        desktop_point_t pos;
         surface_t *surface;
 } viewport_t;
@@ -143 +139 @@
 static LIST_INITIALIZE(viewport_list);
 
-static async_sess_t *input_sess;
+/** Input server proxy */
+static input_t *input;
+
+static int comp_key_press(input_t *, kbd_event_type_t, keycode_t, keymod_t, wchar_t);
+static int comp_mouse_move(input_t *, int, int);
+static int comp_abs_move(input_t *, unsigned, unsigned, unsigned, unsigned);
+static int comp_mouse_button(input_t *, int, int);
+
+static input_ev_ops_t input_ev_ops = {
+        .key = comp_key_press,
+        .move = comp_mouse_move,
+        .abs_move = comp_abs_move,
+        .button = comp_mouse_button
+};
+
+static void input_disconnect(void);
+
+
+static pointer_t *input_pointer(input_t *input)
+{
+        return input->user;
+}
 
 static pointer_t *pointer_create()
@@ -153 +170 @@
 
         link_initialize(&p->link);
-        p->hpos = coord_origin;
-        p->vpos = coord_origin;
+        p->pos.x = coord_origin;
+        p->pos.y = coord_origin;
         p->btn_num = 1;
-        p->btn_hpos = p->hpos;
-        p->btn_vpos = p->vpos;
-        p->accum_dx = 0;
-        p->accum_dy = 0;
+        p->btn_pos = p->pos;
+        p->accum.x = 0;
+        p->accum.y = 0;
         p->grab_flags = GF_EMPTY;
         p->pressed = false;
@@ -286 +302 @@
                 bool isec_vp = rectangle_intersect(
                     x_dmg_glob, y_dmg_glob, w_dmg_glob, h_dmg_glob,
-                    vp->hpos, vp->vpos, w_dmg_vp, h_dmg_vp,
+                    vp->pos.x, vp->pos.y, w_dmg_vp, h_dmg_vp,
                     &x_dmg_vp, &y_dmg_vp, &w_dmg_vp, &h_dmg_vp);
 
@@ -292 +308 @@
 
                         /* Paint background color. */
-                        for (sysarg_t y = y_dmg_vp - vp->vpos; y <  y_dmg_vp - vp->vpos + h_dmg_vp; ++y) {
-                                for (sysarg_t x = x_dmg_vp - vp->hpos; x < x_dmg_vp - vp->hpos + w_dmg_vp; ++x) {
+                        for (sysarg_t y = y_dmg_vp - vp->pos.y; y <  y_dmg_vp - vp->pos.y + h_dmg_vp; ++y) {
+                                for (sysarg_t x = x_dmg_vp - vp->pos.x; x < x_dmg_vp - vp->pos.x + w_dmg_vp; ++x) {
                                         surface_put_pixel(vp->surface, x, y, bg_color);
                                 }
@@ -331 +347 @@
                                          * coordinates. */
                                         transform = win->transform;
-                                        double hpos = vp->hpos;
-                                        double vpos = vp->vpos;
-                                        transform_translate(&transform, -hpos, -vpos);
+                                        double_point_t pos;
+                                        pos.x = vp->pos.x;
+                                        pos.y = vp->pos.y;
+                                        transform_translate(&transform, -pos.x, -pos.y);
 
                                         source_set_transform(&source, transform);                               
@@ -340 +357 @@
 
                                         drawctx_transfer(&context,
-                                            x_dmg_win - vp->hpos, y_dmg_win - vp->vpos, w_dmg_win, h_dmg_win);
+                                            x_dmg_win - vp->pos.x, y_dmg_win - vp->pos.y, w_dmg_win, h_dmg_win);
                                 }
                         }
@@ -354 +371 @@
                                 bool isec_ptr = rectangle_intersect(
                                     x_dmg_vp, y_dmg_vp, w_dmg_vp, h_dmg_vp,
-                                    ptr->hpos, ptr->vpos, w_dmg_ptr, h_dmg_ptr,
+                                    ptr->pos.x, ptr->pos.y, w_dmg_ptr, h_dmg_ptr,
                                     &x_dmg_ptr, &y_dmg_ptr, &w_dmg_ptr, &h_dmg_ptr);
 
@@ -365 +382 @@
 
                                         pixel_t pix = 0;
-                                        sysarg_t x_vp = x_dmg_ptr - vp->hpos;
-                                        sysarg_t y_vp = y_dmg_ptr - vp->vpos;
-                                        sysarg_t x_ptr = x_dmg_ptr - ptr->hpos;
-                                        sysarg_t y_ptr = y_dmg_ptr - ptr->vpos;
+                                        sysarg_t x_vp = x_dmg_ptr - vp->pos.x;
+                                        sysarg_t y_vp = y_dmg_ptr - vp->pos.y;
+                                        sysarg_t x_ptr = x_dmg_ptr - ptr->pos.x;
+                                        sysarg_t y_ptr = y_dmg_ptr - ptr->pos.y;
 
                                         for (sysarg_t y = 0; y < h_dmg_ptr; ++y) {
@@ -759 +776 @@
                 fibril_mutex_unlock(&viewport_list_mtx);
                 loc_service_unregister(winreg_id);
-                async_hangup(input_sess);
+                input_disconnect();
 
                 /* Close all clients and their windows. */
@@ -880 +897 @@
 
         link_initialize(&vp->link);
-        vp->hpos = coord_origin;
-        vp->vpos = coord_origin;
+        vp->pos.x = coord_origin;
+        vp->pos.y = coord_origin;
 
         /* Establish output bidirectional connection. */
@@ -981 +998 @@
         /* window_list_mtx locked by caller */
 
-        int dx = pointer->accum_dx;
-        int dy = pointer->accum_dy;
-        pointer->accum_dx = 0;
-        pointer->accum_dy = 0;
+        int dx = pointer->accum.x;
+        int dy = pointer->accum.y;
+        pointer->accum.x = 0;
+        pointer->accum.y = 0;
 
         bool move = (pointer->grab_flags & GF_MOVE_X) || (pointer->grab_flags & GF_MOVE_Y);
@@ -1055 +1072 @@
 }
 
-static void comp_mouse_move(pointer_t *pointer, ipc_callid_t iid, ipc_call_t *icall)
-{
-        int dx = (int) IPC_GET_ARG1(*icall);
-        int dy = (int) IPC_GET_ARG2(*icall);
+static int comp_abs_move(input_t *input, unsigned x , unsigned y,
+    unsigned max_x, unsigned max_y)
+{
+        /* XXX TODO Use absolute coordinates directly */
+        
+        pointer_t *pointer = input_pointer(input);
+        
+        sysarg_t width, height;
+        
+        fibril_mutex_lock(&viewport_list_mtx);
+        if (list_empty(&viewport_list)) {
+                printf("No viewport found\n");
+                fibril_mutex_unlock(&viewport_list_mtx);
+                return EOK; /* XXX */
+        }
+        link_t *link = list_first(&viewport_list);
+        viewport_t *vp = list_get_instance(link, viewport_t, link);
+        surface_get_resolution(vp->surface, &width, &height);
+        desktop_point_t vp_pos = vp->pos;
+        fibril_mutex_unlock(&viewport_list_mtx);
+
+        desktop_point_t pos_in_viewport;
+        pos_in_viewport.x = x * width / max_x;
+        pos_in_viewport.y = y * height / max_y;
+        
+        /* Calculate offset from pointer */
+        fibril_mutex_lock(&pointer_list_mtx);
+        desktop_vector_t delta;
+        delta.x = (vp_pos.x + pos_in_viewport.x) - pointer->pos.x;
+        delta.y = (vp_pos.y + pos_in_viewport.y) - pointer->pos.y;
+        fibril_mutex_unlock(&pointer_list_mtx);
+        
+        return comp_mouse_move(input, delta.x, delta.y);
+}
+
+static int comp_mouse_move(input_t *input, int dx, int dy)
+{
+        pointer_t *pointer = input_pointer(input);
 
         /* Update pointer position. */
         fibril_mutex_lock(&pointer_list_mtx);
-        sysarg_t old_hpos = pointer->hpos;
-        sysarg_t old_vpos = pointer->vpos;
+        desktop_point_t old_pos = pointer->pos;
         sysarg_t cursor_width;
         sysarg_t cursor_height;
         surface_get_resolution(pointer->cursor.states[pointer->state], 
              &cursor_width, &cursor_height);
-        pointer->hpos += dx;
-        pointer->vpos += dy;
+        pointer->pos.x += dx;
+        pointer->pos.y += dy;
         fibril_mutex_unlock(&pointer_list_mtx);
-        comp_damage(old_hpos, old_vpos, cursor_width, cursor_height);
-        comp_damage(old_hpos + dx, old_vpos + dy, cursor_width, cursor_height);
+        comp_damage(old_pos.x, old_pos.y, cursor_width, cursor_height);
+        comp_damage(old_pos.x + dx, old_pos.y + dy, cursor_width, cursor_height);
 
         fibril_mutex_lock(&window_list_mtx);
@@ -1084 +1134 @@
                         sysarg_t width, height;
                         surface_get_resolution(top->surface, &width, &height);
-                        within_client = comp_coord_to_client(pointer->hpos, pointer->vpos,
+                        within_client = comp_coord_to_client(pointer->pos.x, pointer->pos.y,
                             top->transform, width, height, &point_x, &point_y);
                         fibril_mutex_unlock(&window_list_mtx);
@@ -1103 +1153 @@
                 } else {
                         /* Pointer is grabbed by top-level window action. */
-                        pointer->accum_dx += dx;
-                        pointer->accum_dy += dy;
+                        pointer->accum.x += dx;
+                        pointer->accum.y += dy;
 #if ANIMATE_WINDOW_TRANSFORMS == 1
                         sysarg_t x, y, width, height;
@@ -1118 +1168 @@
         }
 
-        async_answer_0(iid, EOK);
-}
-
-static void comp_mouse_button(pointer_t *pointer, ipc_callid_t iid, ipc_call_t *icall)
-{
-        sysarg_t btn_num = IPC_GET_ARG1(*icall);
-        bool pressed = (bool) IPC_GET_ARG2(*icall);
-
-        if (pressed) {
-                pointer->btn_hpos = pointer->hpos;
-                pointer->btn_vpos = pointer->vpos;
-                pointer->btn_num = btn_num;
+        return EOK;
+}
+
+static int comp_mouse_button(input_t *input, int bnum, int bpress)
+{
+        pointer_t *pointer = input_pointer(input);
+
+        if (bpress) {
+                pointer->btn_pos = pointer->pos;
+                pointer->btn_num = bnum;
                 pointer->pressed = true;
 
@@ -1137 +1185 @@
                 if (!win || !win->surface) {
                         fibril_mutex_unlock(&window_list_mtx);
-                        async_answer_0(iid, EOK);
-                        return;
+                        return EOK;
                 }
                 sysarg_t x, y, width, height;
                 surface_get_resolution(win->surface, &width, &height);
-                bool within_client = comp_coord_to_client(pointer->hpos, pointer->vpos,
+                bool within_client = comp_coord_to_client(pointer->pos.x, pointer->pos.y,
                     win->transform, width, height, &x, &y);
                 fibril_mutex_unlock(&window_list_mtx);
@@ -1154 +1201 @@
                                 event->data.pos.pos_id = pointer->id;
                                 event->data.pos.type = POS_PRESS;
-                                event->data.pos.btn_num = btn_num;
+                                event->data.pos.btn_num = bnum;
                                 event->data.pos.hpos = x;
                                 event->data.pos.vpos = y;
                                 comp_post_event(event);
                         } else {
-                                async_answer_0(iid, ENOMEM);
-                                return;
-                        }
-                }
-        } else if (pointer->pressed && pointer->btn_num == btn_num) {
+                                return ENOMEM;
+                        }
+                }
+        } else if (pointer->pressed && pointer->btn_num == (unsigned)bnum) {
                 pointer->pressed = false;
 
@@ -1178 +1224 @@
                         if (win->surface) {
                                 surface_get_resolution(win->surface, &width, &height);
-                                within_client = comp_coord_to_client(pointer->hpos, pointer->vpos,
+                                within_client = comp_coord_to_client(pointer->pos.x, pointer->pos.y,
                                     win->transform, width, height, &point_x, &point_y);
                         }
@@ -1191 +1237 @@
                         pointer->grab_flags = GF_EMPTY;
                         fibril_mutex_unlock(&window_list_mtx);
-                        async_answer_0(iid, EOK);
-                        return;
+                        return EOK;
                 }
 
@@ -1257 +1302 @@
                                 event->data.pos.pos_id = pointer->id;
                                 event->data.pos.type = POS_RELEASE;
-                                event->data.pos.btn_num = btn_num;
+                                event->data.pos.btn_num = bnum;
                                 event->data.pos.hpos = point_x;
                                 event->data.pos.vpos = point_y;
@@ -1263 +1308 @@
                         pointer->grab_flags = GF_EMPTY;
                         
-                } else if (within_client && (pointer->grab_flags == GF_EMPTY) && (btn_num == 1)) {
+                } else if (within_client && (pointer->grab_flags == GF_EMPTY) && (bnum == 1)) {
 
                         /* Bring the window to the foreground. */
@@ -1286 +1331 @@
         }
 
-        async_answer_0(iid, EOK);
-}
-
-static void comp_key_press(ipc_callid_t iid, ipc_call_t *icall)
-{
-        kbd_event_type_t type = IPC_GET_ARG1(*icall);
-        keycode_t key = IPC_GET_ARG2(*icall);
-        keymod_t mods = IPC_GET_ARG3(*icall);
-        wchar_t c = IPC_GET_ARG4(*icall);
-
+        return EOK;
+}
+
+static int comp_key_press(input_t *input, kbd_event_type_t type, keycode_t key,
+    keymod_t mods, wchar_t c)
+{
         bool win_transform = (mods & KM_ALT) && (
             key == KC_W || key == KC_S || key == KC_A || key == KC_D ||
@@ -1378 +1419 @@
                         if (event == NULL) {
                                 fibril_mutex_unlock(&window_list_mtx);
-                                async_answer_0(iid, ENOMEM);
-                                return;
+                                return ENOMEM;
                         }
 
@@ -1448 +1488 @@
         } else if (win_close) {
                 window_event_t *event = (window_event_t *) malloc(sizeof(window_event_t));
-                if (event == NULL) {
-                        async_answer_0(iid, ENOMEM);
-                        return;
-                }
+                if (event == NULL)
+                        return ENOMEM;
 
                 link_initialize(&event->link);
@@ -1502 +1540 @@
                         switch (key) {
                         case KC_I:
-                                vp->hpos += 0;
-                                vp->vpos += -20;
+                                vp->pos.x += 0;
+                                vp->pos.y += -20;
                                 break;
                         case KC_K:
-                                vp->hpos += 0;
-                                vp->vpos += 20;
+                                vp->pos.x += 0;
+                                vp->pos.y += 20;
                                 break;
                         case KC_J:
-                                vp->hpos += -20;
-                                vp->vpos += 0;
+                                vp->pos.x += -20;
+                                vp->pos.y += 0;
                                 break;
                         case KC_L:
-                                vp->hpos += 20;
-                                vp->vpos += 0;
+                                vp->pos.x += 20;
+                                vp->pos.y += 0;
                                 break;
                         default:
-                                vp->hpos += 0;
-                                vp->vpos += 0;
+                                vp->pos.x += 0;
+                                vp->pos.y += 0;
                                 break;
                         }
                         
-                        sysarg_t x = vp->hpos;
-                        sysarg_t y = vp->vpos;
+                        sysarg_t x = vp->pos.x;
+                        sysarg_t y = vp->pos.y;
                         sysarg_t width, height;
                         surface_get_resolution(vp->surface, &width, &height);
@@ -1594 +1632 @@
         } else {
                 window_event_t *event = (window_event_t *) malloc(sizeof(window_event_t));
-                if (event == NULL) {
-                        async_answer_0(iid, ENOMEM);
-                        return;
-                }
+                if (event == NULL)
+                        return ENOMEM;
 
                 link_initialize(&event->link);
@@ -1609 +1645 @@
         }
 
-        async_answer_0(iid, EOK);
-}
-
-static void input_events(ipc_callid_t iid, ipc_call_t *icall, void *arg)
-{
+        return EOK;
+}
+
+static int input_connect(const char *svc)
+{
+        async_sess_t *sess;
+        service_id_t dsid;
+
+        int rc = loc_service_get_id(svc, &dsid, 0);
+        if (rc != EOK) {
+                printf("%s: Input service %s not found\n", NAME, svc);
+                return rc;
+        }
+
+        sess = loc_service_connect(EXCHANGE_ATOMIC, dsid, 0);
+        if (sess == NULL) {
+                printf("%s: Unable to connect to input service %s\n", NAME,
+                    svc);
+                return EIO;
+        }
+
         fibril_mutex_lock(&pointer_list_mtx);
         pointer_t *pointer = pointer_create();
@@ -1622 +1674 @@
         fibril_mutex_unlock(&pointer_list_mtx);
 
-        /* Ignore parameters, the connection is already opened. */
-        while (true) {
-                ipc_call_t call;
-                ipc_callid_t callid = async_get_call(&call);
-
-                if (!IPC_GET_IMETHOD(call)) {
-                        fibril_mutex_lock(&pointer_list_mtx);
-                        if (pointer != NULL) {
-                                list_remove(&pointer->link);
-                                pointer_destroy(pointer);
-                        }
-                        fibril_mutex_unlock(&pointer_list_mtx);
-                        async_hangup(input_sess);
-                        return;
-                }
-
-                switch (IPC_GET_IMETHOD(call)) {
-                case INPUT_EVENT_KEY:
-                        comp_key_press(callid, &call);
-                        break;
-                case INPUT_EVENT_MOVE:
-                        comp_mouse_move(pointer, callid, &call);
-                        break;
-                case INPUT_EVENT_BUTTON:
-                        comp_mouse_button(pointer, callid, &call);
-                        break;
-                default:
-                        async_answer_0(callid, EINVAL);
-                }
-        }
-}
-
-static async_sess_t *input_connect(const char *svc)
-{
-        async_sess_t *sess;
-        service_id_t dsid;
-
-        int rc = loc_service_get_id(svc, &dsid, 0);
-        if (rc == EOK) {
-                sess = loc_service_connect(EXCHANGE_ATOMIC, dsid, 0);
-                if (sess == NULL) {
-                        printf("%s: Unable to connect to input service %s\n", NAME, svc);
-                        return NULL;
-                }
-        } else
-                return NULL;
-
-        async_exch_t *exch = async_exchange_begin(sess);
-        rc = async_connect_to_me(exch, 0, 0, 0, input_events, NULL);
-        async_exchange_end(exch);
-
+        if (pointer == NULL) {
+                printf("%s: Cannot create pointer.\n", NAME);
+                async_hangup(sess);
+                return ENOMEM;
+        }
+
+        rc = input_open(sess, &input_ev_ops, pointer, &input);
         if (rc != EOK) {
                 async_hangup(sess);
-                printf("%s: Unable to create callback connection to service %s (%s)\n",
+                printf("%s: Unable to communicate with service %s (%s)\n",
                     NAME, svc, str_error(rc));
-                return NULL;
-        }
-
-        return sess;
+                return rc;
+        }
+
+        return EOK;
+}
+
+static void input_disconnect(void)
+{
+        pointer_t *pointer = input->user;
+        input_close(input);
+        pointer_destroy(pointer);
 }
 
@@ -1733 +1748 @@
 
         /* Establish input bidirectional connection. */
-        input_sess = input_connect(input_svc);
-        if (input_sess == NULL) {
-                return -1;
-        }
+        rc = input_connect(input_svc);
+        if (rc != EOK)
+                return rc;
 
         /* Create viewports and connect them to visualizers. */
@@ -1742 +1756 @@
         rc = loc_category_get_id("visualizer", &cat_id, IPC_FLAG_BLOCKING);
         if (rc != EOK) {
-                async_hangup(input_sess);
+                input_disconnect();
                 return -1;
         }
@@ -1750 +1764 @@
         rc = loc_category_get_svcs(cat_id, &svcs, &svcs_cnt);
         if (rc != EOK || svcs_cnt == 0) {
-                async_hangup(input_sess);
+                input_disconnect();
                 return -1;
         }
@@ -1766 +1780 @@
         
         if (list_empty(&viewport_list)) {
-                async_hangup(input_sess);
+                input_disconnect();
                 return -1;
         }

uspace/srv/hid/compositor/compositor.h

@@ -36 +36 @@
 #define COMPOSITOR_COMPOSITOR_H_
 
+typedef native_t desktop_coord_t;
+typedef struct {
+        desktop_coord_t x;
+        desktop_coord_t y;
+} desktop_point_t;
+typedef desktop_point_t desktop_vector_t;
+
+/* TODO remove? */
+typedef struct {
+        double x;
+        double y;
+} double_point_t;
+typedef double_point_t double_vector_t;
+
 #endif
 

uspace/srv/hid/console/console.c

@@ -36 +36 @@
 #include <stdio.h>
 #include <adt/prodcons.h>
-#include <ipc/input.h>
-#include <ipc/console.h>
+#include <io/input.h>
 #include <ipc/vfs.h>
 #include <errno.h>
@@ -43 +42 @@
 #include <loc.h>
 #include <event.h>
+#include <io/con_srv.h>
+#include <io/kbd_event.h>
 #include <io/keycode.h>
 #include <io/chargrid.h>
-#include <io/console.h>
 #include <io/output.h>
 #include <align.h>
@@ -79 +79 @@
         chargrid_t *frontbuf;    /**< Front buffer */
         frontbuf_handle_t fbid;  /**< Front buffer handle */
+        con_srvs_t srvs;         /**< Console service setup */
 } console_t;
 
-/** Session to the input server */
-static async_sess_t *input_sess;
+/** Input server proxy */
+static input_t *input;
 
 /** Session to the output server */
@@ -101 +102 @@
 static console_t *kernel_console = &consoles[KERNEL_CONSOLE];
 
+static int input_ev_key(input_t *, kbd_event_type_t, keycode_t, keymod_t, wchar_t);
+static int input_ev_move(input_t *, int, int);
+static int input_ev_abs_move(input_t *, unsigned, unsigned, unsigned, unsigned);
+static int input_ev_button(input_t *, int, int);
+
+static input_ev_ops_t input_ev_ops = {
+        .key = input_ev_key,
+        .move = input_ev_move,
+        .abs_move = input_ev_abs_move,
+        .button = input_ev_button
+};
+
+static int cons_open(con_srvs_t *, con_srv_t *);
+static int cons_close(con_srv_t *);
+static int cons_read(con_srv_t *, void *, size_t);
+static int cons_write(con_srv_t *, void *, size_t);
+static void cons_sync(con_srv_t *);
+static void cons_clear(con_srv_t *);
+static void cons_set_pos(con_srv_t *, sysarg_t col, sysarg_t row);
+static int cons_get_pos(con_srv_t *, sysarg_t *, sysarg_t *);
+static int cons_get_size(con_srv_t *, sysarg_t *, sysarg_t *);
+static int cons_get_color_cap(con_srv_t *, console_caps_t *);
+static void cons_set_style(con_srv_t *, console_style_t);
+static void cons_set_color(con_srv_t *, console_color_t, console_color_t,
+    console_color_attr_t);
+static void cons_set_rgb_color(con_srv_t *, pixel_t, pixel_t);
+static void cons_set_cursor_visibility(con_srv_t *, bool);
+static int cons_get_event(con_srv_t *, kbd_event_t *);
+
+static con_ops_t con_ops = {
+        .open = cons_open,
+        .close = cons_close,
+        .read = cons_read,
+        .write = cons_write,
+        .sync = cons_sync,
+        .clear = cons_clear,
+        .set_pos = cons_set_pos,
+        .get_pos = cons_get_pos,
+        .get_size = cons_get_size,
+        .get_color_cap = cons_get_color_cap,
+        .set_style = cons_set_style,
+        .set_color = cons_set_color,
+        .set_rgb_color = cons_set_rgb_color,
+        .set_cursor_visibility = cons_set_cursor_visibility,
+        .get_event = cons_get_event
+};
+
+static console_t *srv_to_console(con_srv_t *srv)
+{
+        return srv->srvs->sarg;
+}
+
 static void cons_update(console_t *cons)
 {
@@ -125 +178 @@
         fibril_mutex_unlock(&cons->mtx);
         fibril_mutex_unlock(&switch_mtx);
-}
-
-static void cons_clear(console_t *cons)
-{
-        fibril_mutex_lock(&cons->mtx);
-        chargrid_clear(cons->frontbuf);
-        fibril_mutex_unlock(&cons->mtx);
-        
-        cons_update(cons);
 }
 
@@ -195 +239 @@
 }
 
-static void input_events(ipc_callid_t iid, ipc_call_t *icall, void *arg)
-{
-        /* Ignore parameters, the connection is already opened */
-        while (true) {
-                ipc_call_t call;
-                ipc_callid_t callid = async_get_call(&call);
-                
-                if (!IPC_GET_IMETHOD(call)) {
-                        /* TODO: Handle hangup */
-                        async_hangup(input_sess);
-                        return;
-                }
-                
-                kbd_event_type_t type;
-                keycode_t key;
-                keymod_t mods;
-                wchar_t c;
-                
-                switch (IPC_GET_IMETHOD(call)) {
-                case INPUT_EVENT_KEY:
-                        type = IPC_GET_ARG1(call);
-                        key = IPC_GET_ARG2(call);
-                        mods = IPC_GET_ARG3(call);
-                        c = IPC_GET_ARG4(call);
-                        
-                        if ((key >= KC_F1) && (key < KC_F1 + CONSOLE_COUNT) &&
-                            ((mods & KM_CTRL) == 0))
-                                cons_switch(&consoles[key - KC_F1]);
-                        else {
-                                /* Got key press/release event */
-                                kbd_event_t *event =
-                                    (kbd_event_t *) malloc(sizeof(kbd_event_t));
-                                if (event == NULL) {
-                                        async_answer_0(callid, ENOMEM);
-                                        break;
-                                }
-                                
-                                link_initialize(&event->link);
-                                event->type = type;
-                                event->key = key;
-                                event->mods = mods;
-                                event->c = c;
-                                
-                                /*
-                                 * Kernel console does not read events
-                                 * from us, so we will redirect them
-                                 * to the (last) active userspace console
-                                 * if necessary.
-                                 */
-                                console_t *target_console = cons_get_active_uspace();
-                                
-                                prodcons_produce(&target_console->input_pc,
-                                    &event->link);
-                        }
-                        
-                        async_answer_0(callid, EOK);
-                        break;
-                case INPUT_EVENT_MOVE:
-                        async_answer_0(callid, EOK);
-                        break;
-                case INPUT_EVENT_BUTTON:
-                        async_answer_0(callid, EOK);
-                        break;
-                default:
-                        async_answer_0(callid, EINVAL);
-                }
-        }
+static int input_ev_key(input_t *input, kbd_event_type_t type, keycode_t key,
+    keymod_t mods, wchar_t c)
+{
+        if ((key >= KC_F1) && (key < KC_F1 + CONSOLE_COUNT) &&
+            ((mods & KM_CTRL) == 0)) {
+                cons_switch(&consoles[key - KC_F1]);
+        } else {
+                /* Got key press/release event */
+                kbd_event_t *event =
+                    (kbd_event_t *) malloc(sizeof(kbd_event_t));
+                if (event == NULL) {
+                        return ENOMEM;
+                }
+                
+                link_initialize(&event->link);
+                event->type = type;
+                event->key = key;
+                event->mods = mods;
+                event->c = c;
+                
+                /*
+                 * Kernel console does not read events
+                 * from us, so we will redirect them
+                 * to the (last) active userspace console
+                 * if necessary.
+                 */
+                console_t *target_console = cons_get_active_uspace();
+                
+                prodcons_produce(&target_console->input_pc,
+                    &event->link);
+        }
+        
+        return EOK;
+}
+
+static int input_ev_move(input_t *input, int dx, int dy)
+{
+        return EOK;
+}
+
+static int input_ev_abs_move(input_t *input, unsigned x , unsigned y,
+    unsigned max_x, unsigned max_y)
+{
+        return EOK;
+}
+
+static int input_ev_button(input_t *input, int bnum, int bpress)
+{
+        return EOK;
 }
 
@@ -293 +319 @@
 }
 
-static void cons_set_cursor(console_t *cons, sysarg_t col, sysarg_t row)
-{
-        fibril_mutex_lock(&cons->mtx);
-        chargrid_set_cursor(cons->frontbuf, col, row);
+static void cons_set_cursor_vis(console_t *cons, bool visible)
+{
+        fibril_mutex_lock(&cons->mtx);
+        chargrid_set_cursor_visibility(cons->frontbuf, visible);
         fibril_mutex_unlock(&cons->mtx);
         
@@ -302 +328 @@
 }
 
-static void cons_set_cursor_visibility(console_t *cons, bool visible)
-{
-        fibril_mutex_lock(&cons->mtx);
-        chargrid_set_cursor_visibility(cons->frontbuf, visible);
-        fibril_mutex_unlock(&cons->mtx);
-        
-        cons_update_cursor(cons);
-}
-
-static void cons_get_cursor(console_t *cons, ipc_callid_t iid, ipc_call_t *icall)
-{
-        sysarg_t col;
-        sysarg_t row;
-        
-        fibril_mutex_lock(&cons->mtx);
-        chargrid_get_cursor(cons->frontbuf, &col, &row);
-        fibril_mutex_unlock(&cons->mtx);
-        
-        async_answer_2(iid, EOK, col, row);
-}
-
-static void cons_write(console_t *cons, ipc_callid_t iid, ipc_call_t *icall)
-{
-        void *buf;
-        size_t size;
-        int rc = async_data_write_accept(&buf, false, 0, 0, 0, &size);
-        
-        if (rc != EOK) {
-                async_answer_0(iid, rc);
-                return;
-        }
-        
-        size_t off = 0;
-        while (off < size)
-                cons_write_char(cons, str_decode(buf, &off, size));
-        
-        async_answer_1(iid, EOK, size);
-        free(buf);
-}
-
-static void cons_read(console_t *cons, ipc_callid_t iid, ipc_call_t *icall)
-{
-        ipc_callid_t callid;
-        size_t size;
-        if (!async_data_read_receive(&callid, &size)) {
-                async_answer_0(callid, EINVAL);
-                async_answer_0(iid, EINVAL);
-                return;
-        }
-        
-        char *buf = (char *) malloc(size);
-        if (buf == NULL) {
-                async_answer_0(callid, ENOMEM);
-                async_answer_0(iid, ENOMEM);
-                return;
-        }
-        
+static int cons_open(con_srvs_t *srvs, con_srv_t *srv)
+{
+        return EOK;
+}
+
+static int cons_close(con_srv_t *srv)
+{
+        return EOK;
+}
+
+static int cons_read(con_srv_t *srv, void *buf, size_t size)
+{
+        uint8_t *bbuf = buf;
+        console_t *cons = srv_to_console(srv);
         size_t pos = 0;
         
@@ -369 +352 @@
                 /* Copy to the buffer remaining characters. */
                 while ((pos < size) && (cons->char_remains_len > 0)) {
-                        buf[pos] = cons->char_remains[0];
+                        bbuf[pos] = cons->char_remains[0];
                         pos++;
                         
@@ -394 +377 @@
                 }
         }
-        
-        (void) async_data_read_finalize(callid, buf, size);
-        async_answer_1(iid, EOK, size);
-        free(buf);
-}
-
-static void cons_set_style(console_t *cons, console_style_t style)
-{
+
+        return size;
+}
+
+static int cons_write(con_srv_t *srv, void *data, size_t size)
+{
+        console_t *cons = srv_to_console(srv);
+
+        size_t off = 0;
+        while (off < size)
+                cons_write_char(cons, str_decode(data, &off, size));
+        return size;
+}
+
+static void cons_sync(con_srv_t *srv)
+{
+        console_t *cons = srv_to_console(srv);
+        
+        cons_update(cons);
+}
+
+static void cons_clear(con_srv_t *srv)
+{
+        console_t *cons = srv_to_console(srv);
+        
+        fibril_mutex_lock(&cons->mtx);
+        chargrid_clear(cons->frontbuf);
+        fibril_mutex_unlock(&cons->mtx);
+        
+        cons_update(cons);
+}
+
+static void cons_set_pos(con_srv_t *srv, sysarg_t col, sysarg_t row)
+{
+        console_t *cons = srv_to_console(srv);
+        
+        fibril_mutex_lock(&cons->mtx);
+        chargrid_set_cursor(cons->frontbuf, col, row);
+        fibril_mutex_unlock(&cons->mtx);
+        
+        cons_update_cursor(cons);
+}
+
+static int cons_get_pos(con_srv_t *srv, sysarg_t *col, sysarg_t *row)
+{
+        console_t *cons = srv_to_console(srv);
+        
+        fibril_mutex_lock(&cons->mtx);
+        chargrid_get_cursor(cons->frontbuf, col, row);
+        fibril_mutex_unlock(&cons->mtx);
+        
+        return EOK;
+}
+
+static int cons_get_size(con_srv_t *srv, sysarg_t *cols, sysarg_t *rows)
+{
+        console_t *cons = srv_to_console(srv);
+        
+        fibril_mutex_lock(&cons->mtx);
+        *cols = cons->cols;
+        *rows = cons->rows;
+        fibril_mutex_unlock(&cons->mtx);
+        
+        return EOK;
+}
+
+static int cons_get_color_cap(con_srv_t *srv, console_caps_t *ccaps)
+{
+        console_t *cons = srv_to_console(srv);
+        
+        fibril_mutex_lock(&cons->mtx);
+        *ccaps = cons->ccaps;
+        fibril_mutex_unlock(&cons->mtx);
+        
+        return EOK;
+}
+
+static void cons_set_style(con_srv_t *srv, console_style_t style)
+{
+        console_t *cons = srv_to_console(srv);
+        
         fibril_mutex_lock(&cons->mtx);
         chargrid_set_style(cons->frontbuf, style);
@@ -407 +463 @@
 }
 
-static void cons_set_color(console_t *cons, console_color_t bgcolor,
+static void cons_set_color(con_srv_t *srv, console_color_t bgcolor,
     console_color_t fgcolor, console_color_attr_t attr)
 {
+        console_t *cons = srv_to_console(srv);
+        
         fibril_mutex_lock(&cons->mtx);
         chargrid_set_color(cons->frontbuf, bgcolor, fgcolor, attr);
@@ -415 +473 @@
 }
 
-static void cons_set_rgb_color(console_t *cons, pixel_t bgcolor,
+static void cons_set_rgb_color(con_srv_t *srv, pixel_t bgcolor,
     pixel_t fgcolor)
 {
+        console_t *cons = srv_to_console(srv);
+        
         fibril_mutex_lock(&cons->mtx);
         chargrid_set_rgb_color(cons->frontbuf, bgcolor, fgcolor);
@@ -423 +483 @@
 }
 
-static void cons_get_event(console_t *cons, ipc_callid_t iid, ipc_call_t *icall)
-{
+static void cons_set_cursor_visibility(con_srv_t *srv, bool visible)
+{
+        console_t *cons = srv_to_console(srv);
+        
+        cons_set_cursor_vis(cons, visible);
+}
+
+static int cons_get_event(con_srv_t *srv, kbd_event_t *event)
+{
+        console_t *cons = srv_to_console(srv);
         link_t *link = prodcons_consume(&cons->input_pc);
-        kbd_event_t *event = list_get_instance(link, kbd_event_t, link);
-        
-        async_answer_4(iid, EOK, event->type, event->key, event->mods, event->c);
-        free(event);
+        kbd_event_t *kevent = list_get_instance(link, kbd_event_t, link);
+        
+        *event = *kevent;
+        free(kevent);
+        return EOK;
 }
 
@@ -452 +521 @@
         
         if (atomic_postinc(&cons->refcnt) == 0)
-                cons_set_cursor_visibility(cons, true);
-        
-        /* Accept the connection */
-        async_answer_0(iid, EOK);
-        
-        while (true) {
-                ipc_call_t call;
-                ipc_callid_t callid = async_get_call(&call);
-                
-                if (!IPC_GET_IMETHOD(call))
-                        return;
-                
-                switch (IPC_GET_IMETHOD(call)) {
-                case VFS_OUT_READ:
-                        cons_read(cons, callid, &call);
-                        break;
-                case VFS_OUT_WRITE:
-                        cons_write(cons, callid, &call);
-                        break;
-                case VFS_OUT_SYNC:
-                        cons_update(cons);
-                        async_answer_0(callid, EOK);
-                        break;
-                case CONSOLE_CLEAR:
-                        cons_clear(cons);
-                        async_answer_0(callid, EOK);
-                        break;
-                case CONSOLE_GOTO:
-                        cons_set_cursor(cons, IPC_GET_ARG1(call), IPC_GET_ARG2(call));
-                        async_answer_0(callid, EOK);
-                        break;
-                case CONSOLE_GET_POS:
-                        cons_get_cursor(cons, callid, &call);
-                        break;
-                case CONSOLE_GET_SIZE:
-                        async_answer_2(callid, EOK, cons->cols, cons->rows);
-                        break;
-                case CONSOLE_GET_COLOR_CAP:
-                        async_answer_1(callid, EOK, cons->ccaps);
-                        break;
-                case CONSOLE_SET_STYLE:
-                        cons_set_style(cons, IPC_GET_ARG1(call));
-                        async_answer_0(callid, EOK);
-                        break;
-                case CONSOLE_SET_COLOR:
-                        cons_set_color(cons, IPC_GET_ARG1(call), IPC_GET_ARG2(call),
-                            IPC_GET_ARG3(call));
-                        async_answer_0(callid, EOK);
-                        break;
-                case CONSOLE_SET_RGB_COLOR:
-                        cons_set_rgb_color(cons, IPC_GET_ARG1(call), IPC_GET_ARG2(call));
-                        async_answer_0(callid, EOK);
-                        break;
-                case CONSOLE_CURSOR_VISIBILITY:
-                        cons_set_cursor_visibility(cons, IPC_GET_ARG1(call));
-                        async_answer_0(callid, EOK);
-                        break;
-                case CONSOLE_GET_EVENT:
-                        cons_get_event(cons, callid, &call);
-                        break;
-                default:
-                        async_answer_0(callid, EINVAL);
-                }
-        }
-}
-
-static async_sess_t *input_connect(const char *svc)
+                cons_set_cursor_vis(cons, true);
+        
+        con_conn(iid, icall, &cons->srvs);
+}
+
+
+static int input_connect(const char *svc)
 {
         async_sess_t *sess;
@@ -524 +533 @@
         
         int rc = loc_service_get_id(svc, &dsid, 0);
-        if (rc == EOK) {
-                sess = loc_service_connect(EXCHANGE_ATOMIC, dsid, 0);
-                if (sess == NULL) {
-                        printf("%s: Unable to connect to input service %s\n", NAME,
-                            svc);
-                        return NULL;
-                }
-        } else
-                return NULL;
-        
-        async_exch_t *exch = async_exchange_begin(sess);
-        rc = async_connect_to_me(exch, 0, 0, 0, input_events, NULL);
-        async_exchange_end(exch);
-        
+        if (rc != EOK) {
+                printf("%s: Input service %s not found\n", NAME, svc);
+                return rc;
+        }
+
+        sess = loc_service_connect(EXCHANGE_ATOMIC, dsid, 0);
+        if (sess == NULL) {
+                printf("%s: Unable to connect to input service %s\n", NAME,
+                    svc);
+                return EIO;
+        }
+        
+        rc = input_open(sess, &input_ev_ops, NULL, &input);
         if (rc != EOK) {
                 async_hangup(sess);
-                printf("%s: Unable to create callback connection to service %s (%s)\n",
+                printf("%s: Unable to communicate with service %s (%s)\n",
                     NAME, svc, str_error(rc));
-                return NULL;
-        }
-        
-        return sess;
+                return rc;
+        }
+        
+        return EOK;
 }
 
@@ -574 +582 @@
 static bool console_srv_init(char *input_svc, char *output_svc)
 {
+        int rc;
+        
         /* Connect to input service */
-        input_sess = input_connect(input_svc);
-        if (input_sess == NULL)
+        rc = input_connect(input_svc);
+        if (rc != EOK)
                 return false;
         
@@ -586 +596 @@
         /* Register server */
         async_set_client_connection(client_connection);
-        int rc = loc_server_register(NAME);
+        rc = loc_server_register(NAME);
         if (rc != EOK) {
                 printf("%s: Unable to register server (%s)\n", NAME,
@@ -628 +638 @@
                 }
                 
+                con_srvs_init(&consoles[i].srvs);
+                consoles[i].srvs.ops = &con_ops;
+                consoles[i].srvs.sarg = &consoles[i];
+                
                 char vc[LOC_NAME_MAXLEN + 1];
                 snprintf(vc, LOC_NAME_MAXLEN, "%s/vc%zu", NAMESPACE, i);

uspace/srv/hid/remcons/remcons.c

@@ -34 +34 @@
 
 #include <async.h>
+#include <errno.h>
+#include <io/con_srv.h>
 #include <stdio.h>
-#include <adt/prodcons.h>
-#include <ipc/input.h>
-#include <ipc/console.h>
-#include <ipc/vfs.h>
-#include <errno.h>
+#include <stdlib.h>
 #include <str_error.h>
 #include <loc.h>
@@ -45 +43 @@
 #include <io/keycode.h>
 #include <align.h>
-#include <malloc.h>
-#include <as.h>
 #include <fibril_synch.h>
 #include <task.h>
@@ -75 +71 @@
     sizeof(telnet_force_character_mode_command) / sizeof(telnet_cmd_t);
 
-
-/** Handling client requests (VFS and console interface).
- *
- * @param user Telnet user the requests belong to.
- */
-static void client_connection_message_loop(telnet_user_t *user)
-{
-        while (true) {
-                ipc_call_t call;
-                ipc_callid_t callid = 0;
-
-                /*
-                 * The getterm task might terminate while we are here,
-                 * waiting for a call. Also, the socket might be closed
-                 * meanwhile.
-                 * We want to detect this situation early, so we use a
-                 * timeout variant of async_get_call().
-                 */
-                while (callid == 0) {
-                        callid = async_get_call_timeout(&call, 1000);
-
-                        if (telnet_user_is_zombie(user)) {
-                                if (callid != 0) {
-                                        async_answer_0(callid, EINTR);
-                                }
-                                return;
-                        }
-                }
-                
-                if (!IPC_GET_IMETHOD(call)) {
-                        return;
-                }
-
-                switch (IPC_GET_IMETHOD(call)) {
-                case CONSOLE_GET_SIZE:
-                        async_answer_2(callid, EOK, 100, 1);
-                        break;
-                case CONSOLE_GET_POS:
-                        fibril_mutex_lock(&user->guard);
-                        async_answer_2(callid, EOK, user->cursor_x, 0);
-                        fibril_mutex_unlock(&user->guard);
-                        break;
-                case CONSOLE_GET_EVENT: {
-                        kbd_event_t event;
-                        int rc = telnet_user_get_next_keyboard_event(user, &event);
-                        if (rc != EOK) {
-                                /* Silently ignore. */
-                                async_answer_0(callid, EOK);
-                                break;
-                        }
-                        async_answer_4(callid, EOK, event.type, event.key, event.mods, event.c);
-                        break;
-                }
-                case CONSOLE_GOTO: {
-                        int new_x = IPC_GET_ARG1(call);
-                        telnet_user_update_cursor_x(user, new_x);
-                        async_answer_0(callid, ENOTSUP);
-                        break;
-                }
-                case VFS_OUT_READ:
-                        async_answer_0(callid, ENOTSUP);
-                        break;
-                case VFS_OUT_WRITE: {
-                        uint8_t *buf;
-                        size_t size;
-                        int rc = async_data_write_accept((void **)&buf, false, 0, 0, 0, &size);
-
-                        if (rc != EOK) {
-                                async_answer_0(callid, rc);
-                                break;
-                        }
-
-                        rc = telnet_user_send_data(user, buf, size);
-                        free(buf);
-
-                        if (rc != EOK) {
-                                async_answer_0(callid, rc);
-                                break;
-                        }
-
-                        async_answer_1(callid, EOK, size);
-                        break;
-                }
-                case VFS_OUT_SYNC:
-                        async_answer_0(callid, EOK);
-                        break;
-                case CONSOLE_CLEAR:
-                        async_answer_0(callid, EOK);
-                        break;
-
-                case CONSOLE_GET_COLOR_CAP:
-                        async_answer_1(callid, EOK, CONSOLE_CAP_NONE);
-                        break;
-                case CONSOLE_SET_STYLE:
-                        async_answer_0(callid, ENOTSUP);
-                        break;
-                case CONSOLE_SET_COLOR:
-                        async_answer_0(callid, ENOTSUP);
-                        break;
-                case CONSOLE_SET_RGB_COLOR:
-                        async_answer_0(callid, ENOTSUP);
-                        break;
-
-                case CONSOLE_CURSOR_VISIBILITY:
-                        async_answer_0(callid, ENOTSUP);
-                        break;
-
-                default:
-                        async_answer_0(callid, EINVAL);
-                        break;
-                }
-        }
+static int remcons_open(con_srvs_t *, con_srv_t *);
+static int remcons_close(con_srv_t *);
+static int remcons_write(con_srv_t *, void *, size_t);
+static void remcons_sync(con_srv_t *);
+static void remcons_clear(con_srv_t *);
+static void remcons_set_pos(con_srv_t *, sysarg_t col, sysarg_t row);
+static int remcons_get_pos(con_srv_t *, sysarg_t *, sysarg_t *);
+static int remcons_get_size(con_srv_t *, sysarg_t *, sysarg_t *);
+static int remcons_get_color_cap(con_srv_t *, console_caps_t *);
+static int remcons_get_event(con_srv_t *, kbd_event_t *);
+
+static con_ops_t con_ops = {
+        .open = remcons_open,
+        .close = remcons_close,
+        .read = NULL,
+        .write = remcons_write,
+        .sync = remcons_sync,
+        .clear = remcons_clear,
+        .set_pos = remcons_set_pos,
+        .get_pos = remcons_get_pos,
+        .get_size = remcons_get_size,
+        .get_color_cap = remcons_get_color_cap,
+        .set_style = NULL,
+        .set_color = NULL,
+        .set_rgb_color = NULL,
+        .set_cursor_visibility = NULL,
+        .get_event = remcons_get_event
+};
+
+static telnet_user_t *srv_to_user(con_srv_t *srv)
+{
+        return srv->srvs->sarg;
+}
+
+static int remcons_open(con_srvs_t *srvs, con_srv_t *srv)
+{
+        telnet_user_t *user = srv_to_user(srv);
+
+        telnet_user_log(user, "New client connected (%p).", srv);
+
+        /* Force character mode. */
+        send(user->socket, (void *)telnet_force_character_mode_command,
+            telnet_force_character_mode_command_count, 0);
+
+        return EOK;
+}
+
+static int remcons_close(con_srv_t *srv)
+{
+        telnet_user_t *user = srv_to_user(srv);
+
+        telnet_user_notify_client_disconnected(user);
+        telnet_user_log(user, "Client disconnected (%p).", srv);
+
+        return EOK;
+}
+
+static int remcons_write(con_srv_t *srv, void *data, size_t size)
+{
+        telnet_user_t *user = srv_to_user(srv);
+        int rc;
+
+        rc = telnet_user_send_data(user, data, size);
+        if (rc != EOK)
+                return rc;
+
+        return size;
+}
+
+static void remcons_sync(con_srv_t *srv)
+{
+        (void) srv;
+}
+
+static void remcons_clear(con_srv_t *srv)
+{
+        (void) srv;
+}
+
+static void remcons_set_pos(con_srv_t *srv, sysarg_t col, sysarg_t row)
+{
+        telnet_user_t *user = srv_to_user(srv);
+
+        telnet_user_update_cursor_x(user, col);
+}
+
+static int remcons_get_pos(con_srv_t *srv, sysarg_t *col, sysarg_t *row)
+{
+        telnet_user_t *user = srv_to_user(srv);
+
+        *col = user->cursor_x;
+        *row = 0;
+
+        return EOK;
+}
+
+static int remcons_get_size(con_srv_t *srv, sysarg_t *cols, sysarg_t *rows)
+{
+        (void) srv;
+
+        *cols = 100;
+        *rows = 1;
+
+        return EOK;
+}
+
+static int remcons_get_color_cap(con_srv_t *srv, console_caps_t *ccaps)
+{
+        (void) srv;
+        *ccaps = CONSOLE_CAP_NONE;
+
+        return EOK;
+}
+
+static int remcons_get_event(con_srv_t *srv, kbd_event_t *event)
+{
+        telnet_user_t *user = srv_to_user(srv);
+        int rc;
+
+        rc = telnet_user_get_next_keyboard_event(user, event);
+        if (rc != EOK) {
+                /* XXX What? */
+                memset(event, 0, sizeof(*event));
+                return EOK;
+        }
+
+        return EOK;
 }
 
@@ -198 +209 @@
                 return;
         }
-        async_answer_0(iid, EOK);
-
-        telnet_user_log(user, "New client connected (%" PRIxn").", iid);
-
-        /* Force character mode. */
-        send(user->socket, (void *)telnet_force_character_mode_command,
-            telnet_force_character_mode_command_count, 0);
 
         /* Handle messages. */
-        client_connection_message_loop(user);
-
-        telnet_user_notify_client_disconnected(user);
-        telnet_user_log(user, "Client disconnected (%" PRIxn").", iid);
+        con_conn(iid, icall, &user->srvs);
 }
 
@@ -232 +233 @@
                 fibril_mutex_lock(&user->guard);
                 user->task_finished = true;
+                user->srvs.aborted = true;
                 fibril_condvar_signal(&user->refcount_cv);
                 fibril_mutex_unlock(&user->guard);
@@ -251 +253 @@
         fibril_mutex_lock(&user->guard);
         user->task_finished = true;
+        user->srvs.aborted = true;
         fibril_condvar_signal(&user->refcount_cv);
         fibril_mutex_unlock(&user->guard);
@@ -295 +298 @@
                         closesocket(user->socket);
                         user->socket_closed = true;
+                        user->srvs.aborted = true;
                         continue;
                 } else if (user->socket_closed) {
@@ -380 +384 @@
                 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);

uspace/srv/hid/remcons/user.c

@@ -35 +35 @@
 #include <stdio.h>
 #include <adt/prodcons.h>
-#include <ipc/input.h>
-#include <ipc/console.h>
-#include <ipc/vfs.h>
 #include <errno.h>
 #include <str_error.h>
@@ -95 +92 @@
         user->locsrv_connection_count = 0;
 
-
+        user->cursor_x = 0;
+
+        return user;
+}
+
+void telnet_user_add(telnet_user_t *user)
+{
         fibril_mutex_lock(&users_guard);
         list_append(&user->link, &users);
         fibril_mutex_unlock(&users_guard);
-
-        user->cursor_x = 0;
-
-        return user;
 }
 
@@ -199 +198 @@
                 if ((recv_length == 0) || (recv_length == ENOTCONN)) {
                         user->socket_closed = true;
+                        user->srvs.aborted = true;
                         return ENOENT;
                 }

uspace/srv/hid/remcons/user.h

@@ -36 +36 @@
 #define TELNET_USER_H_
 
+#include <adt/prodcons.h>
 #include <fibril_synch.h>
 #include <inttypes.h>
+#include <io/con_srv.h>
 #include "remcons.h"
 
@@ -55 +57 @@
         /** Path name of the service. */
         char *service_name;
+        /** Console service setup */
+        con_srvs_t srvs;
 
         /** Producer-consumer of kbd_event_t. */
@@ -77 +81 @@
 
 extern telnet_user_t *telnet_user_create(int);
+extern void telnet_user_add(telnet_user_t *);
 extern void telnet_user_destroy(telnet_user_t *);
 extern telnet_user_t *telnet_user_get_for_client_connection(service_id_t);

uspace/srv/net/ethip/pdu.c

@@ -69 +69 @@
             frame->size);
 
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "Encoding Ethernet frame src=%llx dest=%llx etype=%x",
-            frame->src, frame->dest, frame->etype_len);
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "Encoding Ethernet frame "
+            "src=%" PRIx64 " dest=%" PRIx64 " etype=%x",
+            frame->src.addr, frame->dest.addr, frame->etype_len);
         log_msg(LOG_DEFAULT, LVL_DEBUG, "Encoded Ethernet frame (%zu bytes)", size);
 
@@ -104 +105 @@
             frame->size);
 
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "Decoding Ethernet frame src=%llx dest=%llx etype=%x",
-            frame->src, frame->dest, frame->etype_len);
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "Decoding Ethernet frame "
+            "src=%" PRIx64 " dest=%" PRIx64 " etype=%x",
+            frame->src.addr, frame->dest.addr, frame->etype_len);
         log_msg(LOG_DEFAULT, LVL_DEBUG, "Decoded Ethernet frame payload (%zu bytes)", frame->size);
 

uspace/srv/net/tcp/conn.c

@@ -999 +999 @@
         } else {
                 log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: Nothing left in segment, dropping "
-                    "(xfer_size=%zu, SEG.LEN=%zu, seg->ctrl=%u)",
-                    conn->name, xfer_size, seg->len, (unsigned)seg->ctrl);
+                    "(xfer_size=%zu, SEG.LEN=%" PRIu32 ", seg->ctrl=%u)",
+                    conn->name, xfer_size, seg->len, (unsigned int) seg->ctrl);
                 /* Nothing left in segment */
                 tcp_segment_delete(seg);
@@ -1146 +1146 @@
 void tcp_conn_segment_arrived(tcp_conn_t *conn, tcp_segment_t *seg)
 {
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "%c: tcp_conn_segment_arrived(%p)",
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_conn_segment_arrived(%p)",
             conn->name, seg);
 

uspace/srv/net/tcp/segment.c

@@ -250 +250 @@
         log_msg(LOG_DEFAULT, LVL_DEBUG2, "Segment dump:");
         log_msg(LOG_DEFAULT, LVL_DEBUG2, " - ctrl = %u", (unsigned)seg->ctrl);
-        log_msg(LOG_DEFAULT, LVL_DEBUG2, " - seq = % " PRIu32, seg->seq);
-        log_msg(LOG_DEFAULT, LVL_DEBUG2, " - ack = % " PRIu32, seg->ack);
-        log_msg(LOG_DEFAULT, LVL_DEBUG2, " - len = % " PRIu32, seg->len);
-        log_msg(LOG_DEFAULT, LVL_DEBUG2, " - wnd = % " PRIu32, seg->wnd);
-        log_msg(LOG_DEFAULT, LVL_DEBUG2, " - up = % " PRIu32, seg->up);
+        log_msg(LOG_DEFAULT, LVL_DEBUG2, " - seq = %" PRIu32, seg->seq);
+        log_msg(LOG_DEFAULT, LVL_DEBUG2, " - ack = %" PRIu32, seg->ack);
+        log_msg(LOG_DEFAULT, LVL_DEBUG2, " - len = %" PRIu32, seg->len);
+        log_msg(LOG_DEFAULT, LVL_DEBUG2, " - wnd = %" PRIu32, seg->wnd);
+        log_msg(LOG_DEFAULT, LVL_DEBUG2, " - up = %" PRIu32, seg->up);
 }
 

uspace/srv/net/tcp/sock.c

@@ -114 +114 @@
         *rsock = NULL;
 
-        sock = calloc(sizeof(tcp_sockdata_t), 1);
+        sock = calloc(1, sizeof(tcp_sockdata_t));
         if (sock == NULL)
                 return ENOMEM;
@@ -277 +277 @@
 
         socket->backlog = backlog;
-        socket->lconn = calloc(sizeof(tcp_conn_t *), backlog);
+        socket->lconn = calloc(backlog, sizeof(tcp_conn_t *));
         if (socket->lconn == NULL) {
                 fibril_mutex_unlock(&socket->lock);
@@ -293 +293 @@
         for (i = 0; i < backlog; i++) {
 
-                lconn = calloc(sizeof(tcp_sock_lconn_t), 1);
+                lconn = calloc(1, sizeof(tcp_sock_lconn_t));
                 if (lconn == NULL) {
                         /* XXX Clean up */

uspace/srv/net/tcp/tqueue.c

@@ -172 +172 @@
 
         xfer_seqlen = min(snd_buf_seqlen, avail_wnd);
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: snd_buf_seqlen = %zu, SND.WND = %zu, "
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: snd_buf_seqlen = %zu, SND.WND = %" PRIu32 ", "
             "xfer_seqlen = %zu", conn->name, snd_buf_seqlen, conn->snd_wnd,
             xfer_seqlen);

uspace/srv/net/udp/sock.c

@@ -104 +104 @@
 
         log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_socket()");
-        sock = calloc(sizeof(udp_sockdata_t), 1);
+        sock = calloc(1, sizeof(udp_sockdata_t));
         if (sock == NULL) {
                 async_answer_0(callid, ENOMEM);