Changes in / [4c84ada5:16e9d4df] in mainline


Ignore:
Location:
uspace
Files:
3 deleted
11 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/Makefile

    r4c84ada5 r16e9d4df  
    107107        generic/io/vsnprintf.c \
    108108        generic/io/printf_core.c \
    109         generic/io/con_srv.c \
    110109        generic/io/console.c \
    111110        generic/io/visualizer.c \

  • uspace/lib/c/generic/io/console.c

    r4c84ada5 r16e9d4df  
    3838#include <async.h>
    3939#include <errno.h>
     40#include <stdio.h>
    4041#include <malloc.h>
    4142#include <vfs/vfs_sess.h>
    … …  
    125126{
    126127        async_exch_t *exch = async_exchange_begin(ctrl->output_sess);
    127         async_req_1_0(exch, CONSOLE_SET_CURSOR_VISIBILITY, (show != false));
     128        async_req_1_0(exch, CONSOLE_CURSOR_VISIBILITY, (show != false));
    128129        async_exchange_end(exch);
    129130}
    … …  
    150151{
    151152        async_exch_t *exch = async_exchange_begin(ctrl->output_sess);
    152         async_req_2_0(exch, CONSOLE_SET_POS, col, row);
     153        async_req_2_0(exch, CONSOLE_GOTO, col, row);
    153154        async_exchange_end(exch);
    154155}

  • uspace/lib/c/generic/io/output.c

    r4c84ada5 r16e9d4df  
    3737#include <as.h>
    3838#include <ipc/output.h>
    39 #include <io/concaps.h>
    4039#include <io/output.h>
    4140

  • uspace/lib/c/include/io/console.h

    r4c84ada5 r16e9d4df  
    3737
    3838#include <sys/time.h>
    39 #include <io/concaps.h>
    4039#include <io/kbd_event.h>
    4140#include <io/keycode.h>
    … …  
    4342#include <bool.h>
    4443#include <stdio.h>
     44
     45typedef enum {
     46        CONSOLE_CAP_NONE = 0,
     47        CONSOLE_CAP_STYLE = 1,
     48        CONSOLE_CAP_INDEXED = 2,
     49        CONSOLE_CAP_RGB = 4
     50} console_caps_t;
    4551
    4652/** Console control structure. */

  • uspace/lib/c/include/ipc/console.h

    r4c84ada5 r16e9d4df  
    4343        CONSOLE_GET_EVENT,
    4444        CONSOLE_GET_POS,
    45         CONSOLE_SET_POS,
     45        CONSOLE_GOTO,
    4646        CONSOLE_CLEAR,
    4747        CONSOLE_SET_STYLE,
    4848        CONSOLE_SET_COLOR,
    4949        CONSOLE_SET_RGB_COLOR,
    50         CONSOLE_SET_CURSOR_VISIBILITY
     50        CONSOLE_CURSOR_VISIBILITY
    5151} console_request_t;
    5252

  • uspace/lib/gui/terminal.c

    r4c84ada5 r16e9d4df  
    3939#include <surface.h>
    4040#include <gfx/font-8x16.h>
    41 #include <io/con_srv.h>
    42 #include <io/concaps.h>
    4341#include <io/console.h>
     42#include <ipc/console.h>
    4443#include <task.h>
    4544#include <adt/list.h>
    … …  
    6160
    6261static LIST_INITIALIZE(terms);
    63 
    64 static int term_open(con_srvs_t *, con_srv_t *);
    65 static int term_close(con_srv_t *);
    66 static int term_read(con_srv_t *, void *, size_t);
    67 static int term_write(con_srv_t *, void *, size_t);
    68 static void term_sync(con_srv_t *);
    69 static void term_clear(con_srv_t *);
    70 static void term_set_pos(con_srv_t *, sysarg_t col, sysarg_t row);
    71 static int term_get_pos(con_srv_t *, sysarg_t *, sysarg_t *);
    72 static int term_get_size(con_srv_t *, sysarg_t *, sysarg_t *);
    73 static int term_get_color_cap(con_srv_t *, console_caps_t *);
    74 static void term_set_style(con_srv_t *, console_style_t);
    75 static void term_set_color(con_srv_t *, console_color_t, console_color_t,
    76     console_color_attr_t);
    77 static void term_set_rgb_color(con_srv_t *, pixel_t, pixel_t);
    78 static void term_set_cursor_visibility(con_srv_t *, bool);
    79 static int term_get_event(con_srv_t *, kbd_event_t *);
    80 
    81 static con_ops_t con_ops = {
    82         .open = term_open,
    83         .close = term_close,
    84         .read = term_read,
    85         .write = term_write,
    86         .sync = term_sync,
    87         .clear = term_clear,
    88         .set_pos = term_set_pos,
    89         .get_pos = term_get_pos,
    90         .get_size = term_get_size,
    91         .get_color_cap = term_get_color_cap,
    92         .set_style = term_set_style,
    93         .set_color = term_set_color,
    94         .set_rgb_color = term_set_rgb_color,
    95         .set_cursor_visibility = term_set_cursor_visibility,
    96         .get_event = term_get_event
    97 };
    98 
    99 static terminal_t *srv_to_terminal(con_srv_t *srv)
    100 {
    101         return srv->srvs->sarg;
    102 }
    10362
    10463static void getterm(const char *svc, const char *app)
    … …  
    382341}
    383342
    384 static int term_open(con_srvs_t *srvs, con_srv_t *srv)
    385 {
    386         return EOK;
    387 }
    388 
    389 static int term_close(con_srv_t *srv)
    390 {
    391         return EOK;
    392 }
    393 
    394 static int term_read(con_srv_t *srv, void *buf, size_t size)
    395 {
    396         terminal_t *term = srv_to_terminal(srv);
    397         uint8_t *bbuf = buf;
     343static void term_set_cursor(terminal_t *term, sysarg_t col, sysarg_t row)
     344{
     345        fibril_mutex_lock(&term->mtx);
     346        chargrid_set_cursor(term->frontbuf, col, row);
     347        fibril_mutex_unlock(&term->mtx);
     348       
     349        term_update(term);
     350}
     351
     352static void term_set_cursor_visibility(terminal_t *term, bool visible)
     353{
     354        fibril_mutex_lock(&term->mtx);
     355        chargrid_set_cursor_visibility(term->frontbuf, visible);
     356        fibril_mutex_unlock(&term->mtx);
     357       
     358        term_update(term);
     359}
     360
     361static void term_read(terminal_t *term, ipc_callid_t iid, ipc_call_t *icall)
     362{
     363        ipc_callid_t callid;
     364        size_t size;
     365        if (!async_data_read_receive(&callid, &size)) {
     366                async_answer_0(callid, EINVAL);
     367                async_answer_0(iid, EINVAL);
     368                return;
     369        }
     370       
     371        char *buf = (char *) malloc(size);
     372        if (buf == NULL) {
     373                async_answer_0(callid, ENOMEM);
     374                async_answer_0(iid, ENOMEM);
     375                return;
     376        }
     377       
    398378        size_t pos = 0;
    399379       
    … …  
    406386                /* Copy to the buffer remaining characters. */
    407387                while ((pos < size) && (term->char_remains_len > 0)) {
    408                         bbuf[pos] = term->char_remains[0];
     388                        buf[pos] = term->char_remains[0];
    409389                        pos++;
    410390                       
    … …  
    436416        }
    437417       
    438         return size;
     418        (void) async_data_read_finalize(callid, buf, size);
     419        async_answer_1(iid, EOK, size);
     420        free(buf);
    439421}
    440422
    … …  
    467449}
    468450
    469 static int term_write(con_srv_t *srv, void *data, size_t size)
    470 {
    471         terminal_t *term = srv_to_terminal(srv);
     451static void term_write(terminal_t *term, ipc_callid_t iid, ipc_call_t *icall)
     452{
     453        void *buf;
     454        size_t size;
     455        int rc = async_data_write_accept(&buf, false, 0, 0, 0, &size);
     456       
     457        if (rc != EOK) {
     458                async_answer_0(iid, rc);
     459                return;
     460        }
    472461       
    473462        size_t off = 0;
    474463        while (off < size)
    475                 term_write_char(term, str_decode(data, &off, size));
    476        
    477         return size;
    478 }
    479 
    480 static void term_sync(con_srv_t *srv)
    481 {
    482         terminal_t *term = srv_to_terminal(srv);
     464                term_write_char(term, str_decode(buf, &off, size));
     465       
     466        async_answer_1(iid, EOK, size);
     467        free(buf);
     468}
     469
     470static void term_clear(terminal_t *term)
     471{
     472        fibril_mutex_lock(&term->mtx);
     473        chargrid_clear(term->frontbuf);
     474        fibril_mutex_unlock(&term->mtx);
    483475       
    484476        term_update(term);
    485477}
    486478
    487 static void term_clear(con_srv_t *srv)
    488 {
    489         terminal_t *term = srv_to_terminal(srv);
    490        
    491         fibril_mutex_lock(&term->mtx);
    492         chargrid_clear(term->frontbuf);
    493         fibril_mutex_unlock(&term->mtx);
    494        
    495         term_update(term);
    496 }
    497 
    498 static void term_set_pos(con_srv_t *srv, sysarg_t col, sysarg_t row)
    499 {
    500         terminal_t *term = srv_to_terminal(srv);
    501        
    502         fibril_mutex_lock(&term->mtx);
    503         chargrid_set_cursor(term->frontbuf, col, row);
    504         fibril_mutex_unlock(&term->mtx);
    505        
    506         term_update(term);
    507 }
    508 
    509 static int term_get_pos(con_srv_t *srv, sysarg_t *col, sysarg_t *row)
    510 {
    511         terminal_t *term = srv_to_terminal(srv);
    512        
    513         fibril_mutex_lock(&term->mtx);
    514         chargrid_get_cursor(term->frontbuf, col, row);
    515         fibril_mutex_unlock(&term->mtx);
    516        
    517         return EOK;
    518 }
    519 
    520 static int term_get_size(con_srv_t *srv, sysarg_t *cols, sysarg_t *rows)
    521 {
    522         terminal_t *term = srv_to_terminal(srv);
    523        
    524         fibril_mutex_lock(&term->mtx);
    525         *cols = term->cols;
    526         *rows = term->rows;
    527         fibril_mutex_unlock(&term->mtx);
    528        
    529         return EOK;
    530 }
    531 
    532 static int term_get_color_cap(con_srv_t *srv, console_caps_t *caps)
    533 {
    534         (void) srv;
    535         *caps = TERM_CAPS;
    536        
    537         return EOK;
    538 }
    539 
    540 static void term_set_style(con_srv_t *srv, console_style_t style)
    541 {
    542         terminal_t *term = srv_to_terminal(srv);
    543        
     479static void term_get_cursor(terminal_t *term, ipc_callid_t iid, ipc_call_t *icall)
     480{
     481        sysarg_t col;
     482        sysarg_t row;
     483       
     484        fibril_mutex_lock(&term->mtx);
     485        chargrid_get_cursor(term->frontbuf, &col, &row);
     486        fibril_mutex_unlock(&term->mtx);
     487       
     488        async_answer_2(iid, EOK, col, row);
     489}
     490
     491static void term_set_style(terminal_t *term, console_style_t style)
     492{
    544493        fibril_mutex_lock(&term->mtx);
    545494        chargrid_set_style(term->frontbuf, style);
    … …  
    547496}
    548497
    549 static void term_set_color(con_srv_t *srv, console_color_t bgcolor,
     498static void term_set_color(terminal_t *term, console_color_t bgcolor,
    550499    console_color_t fgcolor, console_color_attr_t attr)
    551500{
    552         terminal_t *term = srv_to_terminal(srv);
    553        
    554501        fibril_mutex_lock(&term->mtx);
    555502        chargrid_set_color(term->frontbuf, bgcolor, fgcolor, attr);
    … …  
    557504}
    558505
    559 static void term_set_rgb_color(con_srv_t *srv, pixel_t bgcolor,
     506static void term_set_rgb_color(terminal_t *term, pixel_t bgcolor,
    560507    pixel_t fgcolor)
    561508{
    562         terminal_t *term = srv_to_terminal(srv);
    563        
    564509        fibril_mutex_lock(&term->mtx);
    565510        chargrid_set_rgb_color(term->frontbuf, bgcolor, fgcolor);
    … …  
    567512}
    568513
    569 static void term_set_cursor_visibility(con_srv_t *srv, bool visible)
    570 {
    571         terminal_t *term = srv_to_terminal(srv);
    572        
    573         fibril_mutex_lock(&term->mtx);
    574         chargrid_set_cursor_visibility(term->frontbuf, visible);
    575         fibril_mutex_unlock(&term->mtx);
    576        
    577         term_update(term);
    578 }
    579 
    580 static int term_get_event(con_srv_t *srv, kbd_event_t *event)
    581 {
    582         terminal_t *term = srv_to_terminal(srv);
     514static void term_get_event(terminal_t *term, ipc_callid_t iid, ipc_call_t *icall)
     515{
    583516        link_t *link = prodcons_consume(&term->input_pc);
    584         kbd_event_t *kevent = list_get_instance(link, kbd_event_t, link);
    585        
    586         *event = *kevent;
    587         free(kevent);
    588         return EOK;
     517        kbd_event_t *event = list_get_instance(link, kbd_event_t, link);
     518       
     519        async_answer_4(iid, EOK, event->type, event->key, event->mods, event->c);
     520        free(event);
    589521}
    590522
    … …  
    680612       
    681613        if (atomic_postinc(&term->refcnt) == 0)
    682                 chargrid_set_cursor_visibility(term->frontbuf, true);
    683        
    684         con_conn(iid, icall, &term->srvs);
     614                term_set_cursor_visibility(term, true);
     615       
     616        /* Accept the connection */
     617        async_answer_0(iid, EOK);
     618       
     619        while (true) {
     620                ipc_call_t call;
     621                ipc_callid_t callid = async_get_call(&call);
     622               
     623                if (!IPC_GET_IMETHOD(call))
     624                        return;
     625               
     626                switch (IPC_GET_IMETHOD(call)) {
     627                case VFS_OUT_READ:
     628                        term_read(term, callid, &call);
     629                        break;
     630                case VFS_OUT_WRITE:
     631                        term_write(term, callid, &call);
     632                        break;
     633                case VFS_OUT_SYNC:
     634                        term_update(term);
     635                        async_answer_0(callid, EOK);
     636                        break;
     637                case CONSOLE_CLEAR:
     638                        term_clear(term);
     639                        async_answer_0(callid, EOK);
     640                        break;
     641                case CONSOLE_GOTO:
     642                        term_set_cursor(term, IPC_GET_ARG1(call), IPC_GET_ARG2(call));
     643                        async_answer_0(callid, EOK);
     644                        break;
     645                case CONSOLE_GET_POS:
     646                        term_get_cursor(term, callid, &call);
     647                        break;
     648                case CONSOLE_GET_SIZE:
     649                        async_answer_2(callid, EOK, term->cols, term->rows);
     650                        break;
     651                case CONSOLE_GET_COLOR_CAP:
     652                        async_answer_1(callid, EOK, TERM_CAPS);
     653                        break;
     654                case CONSOLE_SET_STYLE:
     655                        term_set_style(term, IPC_GET_ARG1(call));
     656                        async_answer_0(callid, EOK);
     657                        break;
     658                case CONSOLE_SET_COLOR:
     659                        term_set_color(term, IPC_GET_ARG1(call), IPC_GET_ARG2(call),
     660                            IPC_GET_ARG3(call));
     661                        async_answer_0(callid, EOK);
     662                        break;
     663                case CONSOLE_SET_RGB_COLOR:
     664                        term_set_rgb_color(term, IPC_GET_ARG1(call), IPC_GET_ARG2(call));
     665                        async_answer_0(callid, EOK);
     666                        break;
     667                case CONSOLE_CURSOR_VISIBILITY:
     668                        term_set_cursor_visibility(term, IPC_GET_ARG1(call));
     669                        async_answer_0(callid, EOK);
     670                        break;
     671                case CONSOLE_GET_EVENT:
     672                        term_get_event(term, callid, &call);
     673                        break;
     674                default:
     675                        async_answer_0(callid, EINVAL);
     676                }
     677        }
    685678}
    686679
    … …  
    734727       
    735728        async_set_client_connection(term_connection);
    736         con_srvs_init(&term->srvs);
    737         term->srvs.ops = &con_ops;
    738         term->srvs.sarg = term;
    739        
    740729        int rc = loc_server_register(NAME);
    741730        if (rc != EOK) {

  • uspace/lib/gui/terminal.h

    r4c84ada5 r16e9d4df  
    4141#include <font.h>
    4242#include <io/chargrid.h>
    43 #include <io/con_srv.h>
    4443#include <adt/list.h>
    4544#include <adt/prodcons.h>
    … …  
    6766       
    6867        service_id_t dsid;
    69         con_srvs_t srvs;
    7068} terminal_t;
    7169

  • uspace/srv/hid/console/console.c

    r4c84ada5 r16e9d4df  
    3737#include <adt/prodcons.h>
    3838#include <io/input.h>
     39#include <ipc/console.h>
    3940#include <ipc/vfs.h>
    4041#include <errno.h>
    … …  
    4243#include <loc.h>
    4344#include <event.h>
    44 #include <io/con_srv.h>
    4545#include <io/kbd_event.h>
    4646#include <io/keycode.h>
    4747#include <io/chargrid.h>
     48#include <io/console.h>
    4849#include <io/output.h>
    4950#include <align.h>
    … …  
    7980        chargrid_t *frontbuf;    /**< Front buffer */
    8081        frontbuf_handle_t fbid;  /**< Front buffer handle */
    81         con_srvs_t srvs;         /**< Console service setup */
    8282} console_t;
    8383
    … …  
    114114};
    115115
    116 static int cons_open(con_srvs_t *, con_srv_t *);
    117 static int cons_close(con_srv_t *);
    118 static int cons_read(con_srv_t *, void *, size_t);
    119 static int cons_write(con_srv_t *, void *, size_t);
    120 static void cons_sync(con_srv_t *);
    121 static void cons_clear(con_srv_t *);
    122 static void cons_set_pos(con_srv_t *, sysarg_t col, sysarg_t row);
    123 static int cons_get_pos(con_srv_t *, sysarg_t *, sysarg_t *);
    124 static int cons_get_size(con_srv_t *, sysarg_t *, sysarg_t *);
    125 static int cons_get_color_cap(con_srv_t *, console_caps_t *);
    126 static void cons_set_style(con_srv_t *, console_style_t);
    127 static void cons_set_color(con_srv_t *, console_color_t, console_color_t,
    128     console_color_attr_t);
    129 static void cons_set_rgb_color(con_srv_t *, pixel_t, pixel_t);
    130 static void cons_set_cursor_visibility(con_srv_t *, bool);
    131 static int cons_get_event(con_srv_t *, kbd_event_t *);
    132 
    133 static con_ops_t con_ops = {
    134         .open = cons_open,
    135         .close = cons_close,
    136         .read = cons_read,
    137         .write = cons_write,
    138         .sync = cons_sync,
    139         .clear = cons_clear,
    140         .set_pos = cons_set_pos,
    141         .get_pos = cons_get_pos,
    142         .get_size = cons_get_size,
    143         .get_color_cap = cons_get_color_cap,
    144         .set_style = cons_set_style,
    145         .set_color = cons_set_color,
    146         .set_rgb_color = cons_set_rgb_color,
    147         .set_cursor_visibility = cons_set_cursor_visibility,
    148         .get_event = cons_get_event
    149 };
    150 
    151 static console_t *srv_to_console(con_srv_t *srv)
    152 {
    153         return srv->srvs->sarg;
    154 }
    155 
    156116static void cons_update(console_t *cons)
    157117{
    … …  
    178138        fibril_mutex_unlock(&cons->mtx);
    179139        fibril_mutex_unlock(&switch_mtx);
     140}
     141
     142static void cons_clear(console_t *cons)
     143{
     144        fibril_mutex_lock(&cons->mtx);
     145        chargrid_clear(cons->frontbuf);
     146        fibril_mutex_unlock(&cons->mtx);
     147       
     148        cons_update(cons);
    180149}
    181150
    … …  
    319288}
    320289
    321 static void cons_set_cursor_vis(console_t *cons, bool visible)
     290static void cons_set_cursor(console_t *cons, sysarg_t col, sysarg_t row)
     291{
     292        fibril_mutex_lock(&cons->mtx);
     293        chargrid_set_cursor(cons->frontbuf, col, row);
     294        fibril_mutex_unlock(&cons->mtx);
     295       
     296        cons_update_cursor(cons);
     297}
     298
     299static void cons_set_cursor_visibility(console_t *cons, bool visible)
    322300{
    323301        fibril_mutex_lock(&cons->mtx);
    … …  
    328306}
    329307
    330 static int cons_open(con_srvs_t *srvs, con_srv_t *srv)
    331 {
    332         return EOK;
    333 }
    334 
    335 static int cons_close(con_srv_t *srv)
    336 {
    337         return EOK;
    338 }
    339 
    340 static int cons_read(con_srv_t *srv, void *buf, size_t size)
    341 {
    342         uint8_t *bbuf = buf;
    343         console_t *cons = srv_to_console(srv);
     308static void cons_get_cursor(console_t *cons, ipc_callid_t iid, ipc_call_t *icall)
     309{
     310        sysarg_t col;
     311        sysarg_t row;
     312       
     313        fibril_mutex_lock(&cons->mtx);
     314        chargrid_get_cursor(cons->frontbuf, &col, &row);
     315        fibril_mutex_unlock(&cons->mtx);
     316       
     317        async_answer_2(iid, EOK, col, row);
     318}
     319
     320static void cons_write(console_t *cons, ipc_callid_t iid, ipc_call_t *icall)
     321{
     322        void *buf;
     323        size_t size;
     324        int rc = async_data_write_accept(&buf, false, 0, 0, 0, &size);
     325       
     326        if (rc != EOK) {
     327                async_answer_0(iid, rc);
     328                return;
     329        }
     330       
     331        size_t off = 0;
     332        while (off < size)
     333                cons_write_char(cons, str_decode(buf, &off, size));
     334       
     335        async_answer_1(iid, EOK, size);
     336        free(buf);
     337}
     338
     339static void cons_read(console_t *cons, ipc_callid_t iid, ipc_call_t *icall)
     340{
     341        ipc_callid_t callid;
     342        size_t size;
     343        if (!async_data_read_receive(&callid, &size)) {
     344                async_answer_0(callid, EINVAL);
     345                async_answer_0(iid, EINVAL);
     346                return;
     347        }
     348       
     349        char *buf = (char *) malloc(size);
     350        if (buf == NULL) {
     351                async_answer_0(callid, ENOMEM);
     352                async_answer_0(iid, ENOMEM);
     353                return;
     354        }
     355       
    344356        size_t pos = 0;
    345357       
    … …  
    352364                /* Copy to the buffer remaining characters. */
    353365                while ((pos < size) && (cons->char_remains_len > 0)) {
    354                         bbuf[pos] = cons->char_remains[0];
     366                        buf[pos] = cons->char_remains[0];
    355367                        pos++;
    356368                       
    … …  
    377389                }
    378390        }
    379 
    380         return size;
    381 }
    382 
    383 static int cons_write(con_srv_t *srv, void *data, size_t size)
    384 {
    385         console_t *cons = srv_to_console(srv);
    386 
    387         size_t off = 0;
    388         while (off < size)
    389                 cons_write_char(cons, str_decode(data, &off, size));
    390         return size;
    391 }
    392 
    393 static void cons_sync(con_srv_t *srv)
    394 {
    395         console_t *cons = srv_to_console(srv);
    396        
    397         cons_update(cons);
    398 }
    399 
    400 static void cons_clear(con_srv_t *srv)
    401 {
    402         console_t *cons = srv_to_console(srv);
    403        
    404         fibril_mutex_lock(&cons->mtx);
    405         chargrid_clear(cons->frontbuf);
    406         fibril_mutex_unlock(&cons->mtx);
    407        
    408         cons_update(cons);
    409 }
    410 
    411 static void cons_set_pos(con_srv_t *srv, sysarg_t col, sysarg_t row)
    412 {
    413         console_t *cons = srv_to_console(srv);
    414        
    415         fibril_mutex_lock(&cons->mtx);
    416         chargrid_set_cursor(cons->frontbuf, col, row);
    417         fibril_mutex_unlock(&cons->mtx);
    418        
    419         cons_update_cursor(cons);
    420 }
    421 
    422 static int cons_get_pos(con_srv_t *srv, sysarg_t *col, sysarg_t *row)
    423 {
    424         console_t *cons = srv_to_console(srv);
    425        
    426         fibril_mutex_lock(&cons->mtx);
    427         chargrid_get_cursor(cons->frontbuf, col, row);
    428         fibril_mutex_unlock(&cons->mtx);
    429        
    430         return EOK;
    431 }
    432 
    433 static int cons_get_size(con_srv_t *srv, sysarg_t *cols, sysarg_t *rows)
    434 {
    435         console_t *cons = srv_to_console(srv);
    436        
    437         fibril_mutex_lock(&cons->mtx);
    438         *cols = cons->cols;
    439         *rows = cons->rows;
    440         fibril_mutex_unlock(&cons->mtx);
    441        
    442         return EOK;
    443 }
    444 
    445 static int cons_get_color_cap(con_srv_t *srv, console_caps_t *ccaps)
    446 {
    447         console_t *cons = srv_to_console(srv);
    448        
    449         fibril_mutex_lock(&cons->mtx);
    450         *ccaps = cons->ccaps;
    451         fibril_mutex_unlock(&cons->mtx);
    452        
    453         return EOK;
    454 }
    455 
    456 static void cons_set_style(con_srv_t *srv, console_style_t style)
    457 {
    458         console_t *cons = srv_to_console(srv);
    459        
     391       
     392        (void) async_data_read_finalize(callid, buf, size);
     393        async_answer_1(iid, EOK, size);
     394        free(buf);
     395}
     396
     397static void cons_set_style(console_t *cons, console_style_t style)
     398{
    460399        fibril_mutex_lock(&cons->mtx);
    461400        chargrid_set_style(cons->frontbuf, style);
    … …  
    463402}
    464403
    465 static void cons_set_color(con_srv_t *srv, console_color_t bgcolor,
     404static void cons_set_color(console_t *cons, console_color_t bgcolor,
    466405    console_color_t fgcolor, console_color_attr_t attr)
    467406{
    468         console_t *cons = srv_to_console(srv);
    469        
    470407        fibril_mutex_lock(&cons->mtx);
    471408        chargrid_set_color(cons->frontbuf, bgcolor, fgcolor, attr);
    … …  
    473410}
    474411
    475 static void cons_set_rgb_color(con_srv_t *srv, pixel_t bgcolor,
     412static void cons_set_rgb_color(console_t *cons, pixel_t bgcolor,
    476413    pixel_t fgcolor)
    477414{
    478         console_t *cons = srv_to_console(srv);
    479        
    480415        fibril_mutex_lock(&cons->mtx);
    481416        chargrid_set_rgb_color(cons->frontbuf, bgcolor, fgcolor);
    … …  
    483418}
    484419
    485 static void cons_set_cursor_visibility(con_srv_t *srv, bool visible)
    486 {
    487         console_t *cons = srv_to_console(srv);
    488        
    489         cons_set_cursor_vis(cons, visible);
    490 }
    491 
    492 static int cons_get_event(con_srv_t *srv, kbd_event_t *event)
    493 {
    494         console_t *cons = srv_to_console(srv);
     420static void cons_get_event(console_t *cons, ipc_callid_t iid, ipc_call_t *icall)
     421{
    495422        link_t *link = prodcons_consume(&cons->input_pc);
    496         kbd_event_t *kevent = list_get_instance(link, kbd_event_t, link);
    497        
    498         *event = *kevent;
    499         free(kevent);
    500         return EOK;
     423        kbd_event_t *event = list_get_instance(link, kbd_event_t, link);
     424       
     425        async_answer_4(iid, EOK, event->type, event->key, event->mods, event->c);
     426        free(event);
    501427}
    502428
    … …  
    521447       
    522448        if (atomic_postinc(&cons->refcnt) == 0)
    523                 cons_set_cursor_vis(cons, true);
    524        
    525         con_conn(iid, icall, &cons->srvs);
    526 }
    527 
     449                cons_set_cursor_visibility(cons, true);
     450       
     451        /* Accept the connection */
     452        async_answer_0(iid, EOK);
     453       
     454        while (true) {
     455                ipc_call_t call;
     456                ipc_callid_t callid = async_get_call(&call);
     457               
     458                if (!IPC_GET_IMETHOD(call))
     459                        return;
     460               
     461                switch (IPC_GET_IMETHOD(call)) {
     462                case VFS_OUT_READ:
     463                        cons_read(cons, callid, &call);
     464                        break;
     465                case VFS_OUT_WRITE:
     466                        cons_write(cons, callid, &call);
     467                        break;
     468                case VFS_OUT_SYNC:
     469                        cons_update(cons);
     470                        async_answer_0(callid, EOK);
     471                        break;
     472                case CONSOLE_CLEAR:
     473                        cons_clear(cons);
     474                        async_answer_0(callid, EOK);
     475                        break;
     476                case CONSOLE_GOTO:
     477                        cons_set_cursor(cons, IPC_GET_ARG1(call), IPC_GET_ARG2(call));
     478                        async_answer_0(callid, EOK);
     479                        break;
     480                case CONSOLE_GET_POS:
     481                        cons_get_cursor(cons, callid, &call);
     482                        break;
     483                case CONSOLE_GET_SIZE:
     484                        async_answer_2(callid, EOK, cons->cols, cons->rows);
     485                        break;
     486                case CONSOLE_GET_COLOR_CAP:
     487                        async_answer_1(callid, EOK, cons->ccaps);
     488                        break;
     489                case CONSOLE_SET_STYLE:
     490                        cons_set_style(cons, IPC_GET_ARG1(call));
     491                        async_answer_0(callid, EOK);
     492                        break;
     493                case CONSOLE_SET_COLOR:
     494                        cons_set_color(cons, IPC_GET_ARG1(call), IPC_GET_ARG2(call),
     495                            IPC_GET_ARG3(call));
     496                        async_answer_0(callid, EOK);
     497                        break;
     498                case CONSOLE_SET_RGB_COLOR:
     499                        cons_set_rgb_color(cons, IPC_GET_ARG1(call), IPC_GET_ARG2(call));
     500                        async_answer_0(callid, EOK);
     501                        break;
     502                case CONSOLE_CURSOR_VISIBILITY:
     503                        cons_set_cursor_visibility(cons, IPC_GET_ARG1(call));
     504                        async_answer_0(callid, EOK);
     505                        break;
     506                case CONSOLE_GET_EVENT:
     507                        cons_get_event(cons, callid, &call);
     508                        break;
     509                default:
     510                        async_answer_0(callid, EINVAL);
     511                }
     512        }
     513}
    528514
    529515static int input_connect(const char *svc)
    … …  
    638624                }
    639625               
    640                 con_srvs_init(&consoles[i].srvs);
    641                 consoles[i].srvs.ops = &con_ops;
    642                 consoles[i].srvs.sarg = &consoles[i];
    643                
    644626                char vc[LOC_NAME_MAXLEN + 1];
    645627                snprintf(vc, LOC_NAME_MAXLEN, "%s/vc%zu", NAMESPACE, i);

  • uspace/srv/hid/remcons/remcons.c

    r4c84ada5 r16e9d4df  
    3434
    3535#include <async.h>
     36#include <stdio.h>
     37#include <adt/prodcons.h>
     38#include <ipc/input.h>
     39#include <ipc/console.h>
     40#include <ipc/vfs.h>
    3641#include <errno.h>
    37 #include <io/con_srv.h>
    38 #include <stdio.h>
    39 #include <stdlib.h>
    4042#include <str_error.h>
    4143#include <loc.h>
    … …  
    4345#include <io/keycode.h>
    4446#include <align.h>
     47#include <malloc.h>
     48#include <as.h>
    4549#include <fibril_synch.h>
    4650#include <task.h>
    … …  
    7175    sizeof(telnet_force_character_mode_command) / sizeof(telnet_cmd_t);
    7276
    73 static int remcons_open(con_srvs_t *, con_srv_t *);
    74 static int remcons_close(con_srv_t *);
    75 static int remcons_write(con_srv_t *, void *, size_t);
    76 static void remcons_sync(con_srv_t *);
    77 static void remcons_clear(con_srv_t *);
    78 static void remcons_set_pos(con_srv_t *, sysarg_t col, sysarg_t row);
    79 static int remcons_get_pos(con_srv_t *, sysarg_t *, sysarg_t *);
    80 static int remcons_get_size(con_srv_t *, sysarg_t *, sysarg_t *);
    81 static int remcons_get_color_cap(con_srv_t *, console_caps_t *);
    82 static int remcons_get_event(con_srv_t *, kbd_event_t *);
    83 
    84 static con_ops_t con_ops = {
    85         .open = remcons_open,
    86         .close = remcons_close,
    87         .read = NULL,
    88         .write = remcons_write,
    89         .sync = remcons_sync,
    90         .clear = remcons_clear,
    91         .set_pos = remcons_set_pos,
    92         .get_pos = remcons_get_pos,
    93         .get_size = remcons_get_size,
    94         .get_color_cap = remcons_get_color_cap,
    95         .set_style = NULL,
    96         .set_color = NULL,
    97         .set_rgb_color = NULL,
    98         .set_cursor_visibility = NULL,
    99         .get_event = remcons_get_event
    100 };
    101 
    102 static telnet_user_t *srv_to_user(con_srv_t *srv)
    103 {
    104         return srv->srvs->sarg;
    105 }
    106 
    107 static int remcons_open(con_srvs_t *srvs, con_srv_t *srv)
    108 {
    109         telnet_user_t *user = srv_to_user(srv);
    110 
    111         telnet_user_log(user, "New client connected (%p).", srv);
    112 
    113         /* Force character mode. */
    114         send(user->socket, (void *)telnet_force_character_mode_command,
    115             telnet_force_character_mode_command_count, 0);
    116 
    117         return EOK;
    118 }
    119 
    120 static int remcons_close(con_srv_t *srv)
    121 {
    122         telnet_user_t *user = srv_to_user(srv);
    123 
    124         telnet_user_notify_client_disconnected(user);
    125         telnet_user_log(user, "Client disconnected (%p).", srv);
    126 
    127         return EOK;
    128 }
    129 
    130 static int remcons_write(con_srv_t *srv, void *data, size_t size)
    131 {
    132         telnet_user_t *user = srv_to_user(srv);
    133         int rc;
    134 
    135         rc = telnet_user_send_data(user, data, size);
    136         if (rc != EOK)
    137                 return rc;
    138 
    139         return size;
    140 }
    141 
    142 static void remcons_sync(con_srv_t *srv)
    143 {
    144         (void) srv;
    145 }
    146 
    147 static void remcons_clear(con_srv_t *srv)
    148 {
    149         (void) srv;
    150 }
    151 
    152 static void remcons_set_pos(con_srv_t *srv, sysarg_t col, sysarg_t row)
    153 {
    154         telnet_user_t *user = srv_to_user(srv);
    155 
    156         telnet_user_update_cursor_x(user, col);
    157 }
    158 
    159 static int remcons_get_pos(con_srv_t *srv, sysarg_t *col, sysarg_t *row)
    160 {
    161         telnet_user_t *user = srv_to_user(srv);
    162 
    163         *col = user->cursor_x;
    164         *row = 0;
    165 
    166         return EOK;
    167 }
    168 
    169 static int remcons_get_size(con_srv_t *srv, sysarg_t *cols, sysarg_t *rows)
    170 {
    171         (void) srv;
    172 
    173         *cols = 100;
    174         *rows = 1;
    175 
    176         return EOK;
    177 }
    178 
    179 static int remcons_get_color_cap(con_srv_t *srv, console_caps_t *ccaps)
    180 {
    181         (void) srv;
    182         *ccaps = CONSOLE_CAP_NONE;
    183 
    184         return EOK;
    185 }
    186 
    187 static int remcons_get_event(con_srv_t *srv, kbd_event_t *event)
    188 {
    189         telnet_user_t *user = srv_to_user(srv);
    190         int rc;
    191 
    192         rc = telnet_user_get_next_keyboard_event(user, event);
    193         if (rc != EOK) {
    194                 /* XXX What? */
    195                 memset(event, 0, sizeof(*event));
    196                 return EOK;
    197         }
    198 
    199         return EOK;
     77
     78/** Handling client requests (VFS and console interface).
     79 *
     80 * @param user Telnet user the requests belong to.
     81 */
     82static void client_connection_message_loop(telnet_user_t *user)
     83{
     84        while (true) {
     85                ipc_call_t call;
     86                ipc_callid_t callid = 0;
     87
     88                /*
     89                 * The getterm task might terminate while we are here,
     90                 * waiting for a call. Also, the socket might be closed
     91                 * meanwhile.
     92                 * We want to detect this situation early, so we use a
     93                 * timeout variant of async_get_call().
     94                 */
     95                while (callid == 0) {
     96                        callid = async_get_call_timeout(&call, 1000);
     97
     98                        if (telnet_user_is_zombie(user)) {
     99                                if (callid != 0) {
     100                                        async_answer_0(callid, EINTR);
     101                                }
     102                                return;
     103                        }
     104                }
     105               
     106                if (!IPC_GET_IMETHOD(call)) {
     107                        return;
     108                }
     109
     110                switch (IPC_GET_IMETHOD(call)) {
     111                case CONSOLE_GET_SIZE:
     112                        async_answer_2(callid, EOK, 100, 1);
     113                        break;
     114                case CONSOLE_GET_POS:
     115                        fibril_mutex_lock(&user->guard);
     116                        async_answer_2(callid, EOK, user->cursor_x, 0);
     117                        fibril_mutex_unlock(&user->guard);
     118                        break;
     119                case CONSOLE_GET_EVENT: {
     120                        kbd_event_t event;
     121                        int rc = telnet_user_get_next_keyboard_event(user, &event);
     122                        if (rc != EOK) {
     123                                /* Silently ignore. */
     124                                async_answer_0(callid, EOK);
     125                                break;
     126                        }
     127                        async_answer_4(callid, EOK, event.type, event.key, event.mods, event.c);
     128                        break;
     129                }
     130                case CONSOLE_GOTO: {
     131                        int new_x = IPC_GET_ARG1(call);
     132                        telnet_user_update_cursor_x(user, new_x);
     133                        async_answer_0(callid, ENOTSUP);
     134                        break;
     135                }
     136                case VFS_OUT_READ:
     137                        async_answer_0(callid, ENOTSUP);
     138                        break;
     139                case VFS_OUT_WRITE: {
     140                        uint8_t *buf;
     141                        size_t size;
     142                        int rc = async_data_write_accept((void **)&buf, false, 0, 0, 0, &size);
     143
     144                        if (rc != EOK) {
     145                                async_answer_0(callid, rc);
     146                                break;
     147                        }
     148
     149                        rc = telnet_user_send_data(user, buf, size);
     150                        free(buf);
     151
     152                        if (rc != EOK) {
     153                                async_answer_0(callid, rc);
     154                                break;
     155                        }
     156
     157                        async_answer_1(callid, EOK, size);
     158                        break;
     159                }
     160                case VFS_OUT_SYNC:
     161                        async_answer_0(callid, EOK);
     162                        break;
     163                case CONSOLE_CLEAR:
     164                        async_answer_0(callid, EOK);
     165                        break;
     166
     167                case CONSOLE_GET_COLOR_CAP:
     168                        async_answer_1(callid, EOK, CONSOLE_CAP_NONE);
     169                        break;
     170                case CONSOLE_SET_STYLE:
     171                        async_answer_0(callid, ENOTSUP);
     172                        break;
     173                case CONSOLE_SET_COLOR:
     174                        async_answer_0(callid, ENOTSUP);
     175                        break;
     176                case CONSOLE_SET_RGB_COLOR:
     177                        async_answer_0(callid, ENOTSUP);
     178                        break;
     179
     180                case CONSOLE_CURSOR_VISIBILITY:
     181                        async_answer_0(callid, ENOTSUP);
     182                        break;
     183
     184                default:
     185                        async_answer_0(callid, EINVAL);
     186                        break;
     187                }
     188        }
    200189}
    201190
    … …  
    209198                return;
    210199        }
     200        async_answer_0(iid, EOK);
     201
     202        telnet_user_log(user, "New client connected (%" PRIxn").", iid);
     203
     204        /* Force character mode. */
     205        send(user->socket, (void *)telnet_force_character_mode_command,
     206            telnet_force_character_mode_command_count, 0);
    211207
    212208        /* Handle messages. */
    213         con_conn(iid, icall, &user->srvs);
     209        client_connection_message_loop(user);
     210
     211        telnet_user_notify_client_disconnected(user);
     212        telnet_user_log(user, "Client disconnected (%" PRIxn").", iid);
    214213}
    215214
    … …  
    233232                fibril_mutex_lock(&user->guard);
    234233                user->task_finished = true;
    235                 user->srvs.aborted = true;
    236234                fibril_condvar_signal(&user->refcount_cv);
    237235                fibril_mutex_unlock(&user->guard);
    … …  
    253251        fibril_mutex_lock(&user->guard);
    254252        user->task_finished = true;
    255         user->srvs.aborted = true;
    256253        fibril_condvar_signal(&user->refcount_cv);
    257254        fibril_mutex_unlock(&user->guard);
    … …  
    298295                        closesocket(user->socket);
    299296                        user->socket_closed = true;
    300                         user->srvs.aborted = true;
    301297                        continue;
    302298                } else if (user->socket_closed) {
    … …  
    384380                assert(user);
    385381
    386                 con_srvs_init(&user->srvs);
    387                 user->srvs.ops = &con_ops;
    388                 user->srvs.sarg = user;
    389                 user->srvs.abort_timeout = 1000;
    390 
    391                 telnet_user_add(user);
    392 
    393382                fid_t fid = fibril_create(network_user_fibril, user);
    394383                assert(fid);

  • uspace/srv/hid/remcons/user.c

    r4c84ada5 r16e9d4df  
    3535#include <stdio.h>
    3636#include <adt/prodcons.h>
     37#include <ipc/input.h>
     38#include <ipc/console.h>
     39#include <ipc/vfs.h>
    3740#include <errno.h>
    3841#include <str_error.h>
    … …  
    9295        user->locsrv_connection_count = 0;
    9396
    94         user->cursor_x = 0;
    95 
    96         return user;
    97 }
    98 
    99 void telnet_user_add(telnet_user_t *user)
    100 {
     97
    10198        fibril_mutex_lock(&users_guard);
    10299        list_append(&user->link, &users);
    103100        fibril_mutex_unlock(&users_guard);
     101
     102        user->cursor_x = 0;
     103
     104        return user;
    104105}
    105106
    … …  
    198199                if ((recv_length == 0) || (recv_length == ENOTCONN)) {
    199200                        user->socket_closed = true;
    200                         user->srvs.aborted = true;
    201201                        return ENOENT;
    202202                }

  • uspace/srv/hid/remcons/user.h

    r4c84ada5 r16e9d4df  
    3636#define TELNET_USER_H_
    3737
    38 #include <adt/prodcons.h>
    3938#include <fibril_synch.h>
    4039#include <inttypes.h>
    41 #include <io/con_srv.h>
    4240#include "remcons.h"
    4341
    … …  
    5755        /** Path name of the service. */
    5856        char *service_name;
    59         /** Console service setup */
    60         con_srvs_t srvs;
    6157
    6258        /** Producer-consumer of kbd_event_t. */
    … …  
    8177
    8278extern telnet_user_t *telnet_user_create(int);
    83 extern void telnet_user_add(telnet_user_t *);
    8479extern void telnet_user_destroy(telnet_user_t *);
    8580extern telnet_user_t *telnet_user_get_for_client_connection(service_id_t);
Note: See TracChangeset for help on using the changeset viewer.