Changeset fab2746 in mainline for uspace/srv/hid


Ignore:
Timestamp:
2015-04-08T21:25:30Z (11 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
99ea91b2
Parents:
ba0eac5
Message:

New transport layer API. Only UDP implemented.

Location:
uspace/srv/hid
Files:
7 edited

Legend:

Unmodified
Added
Removed

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

    rba0eac5 rfab2746  
    4444#include <fibril_synch.h>
    4545#include <task.h>
    46 #include <net/in.h>
    47 #include <net/inet.h>
    48 #include <net/socket.h>
     46#include <inet/addr.h>
     47#include <inet/endpoint.h>
     48#include <inet/tcp.h>
    4949#include <io/console.h>
    5050#include <inttypes.h>
    … …  
    9999};
    100100
     101static void remcons_new_conn(tcp_listener_t *lst, tcp_conn_t *conn);
     102
     103static tcp_listen_cb_t listen_cb = {
     104        .new_conn = remcons_new_conn
     105};
     106
     107static tcp_cb_t conn_cb = {
     108        .connected = NULL
     109};
     110
    101111static telnet_user_t *srv_to_user(con_srv_t *srv)
    102112{
    … …  
    111121
    112122        /* Force character mode. */
    113         send(user->socket, (void *)telnet_force_character_mode_command,
    114             telnet_force_character_mode_command_count, 0);
     123        (void) tcp_conn_send(user->conn, (void *)telnet_force_character_mode_command,
     124            telnet_force_character_mode_command_count);
    115125
    116126        return EOK;
    … …  
    298308        while (!user_can_be_destroyed_no_lock(user)) {
    299309                if (user->task_finished) {
    300                         closesocket(user->socket);
     310                        tcp_conn_destroy(user->conn);
     311                        user->conn = NULL;
    301312                        user->socket_closed = true;
    302313                        user->srvs.aborted = true;
    … …  
    324335}
    325336
     337static void remcons_new_conn(tcp_listener_t *lst, tcp_conn_t *conn)
     338{
     339        telnet_user_t *user = telnet_user_create(conn);
     340        assert(user);
     341
     342        con_srvs_init(&user->srvs);
     343        user->srvs.ops = &con_ops;
     344        user->srvs.sarg = user;
     345        user->srvs.abort_timeout = 1000;
     346
     347        telnet_user_add(user);
     348
     349        fid_t fid = fibril_create(network_user_fibril, user);
     350        assert(fid);
     351        fibril_add_ready(fid);
     352}
     353
    326354int main(int argc, char *argv[])
    327355{
    328         int port = 2223;
    329        
     356        int rc;
     357        tcp_listener_t *lst;
     358        tcp_t *tcp;
     359        inet_ep_t ep;
     360
    330361        async_set_client_connection(client_connection);
    331         int rc = loc_server_register(NAME);
     362        rc = loc_server_register(NAME);
    332363        if (rc != EOK) {
    333364                fprintf(stderr, "%s: Unable to register server\n", NAME);
    334365                return rc;
    335366        }
    336        
    337         struct sockaddr_in addr;
    338        
    339         addr.sin_family = AF_INET;
    340         addr.sin_port = htons(port);
    341        
    342         rc = inet_pton(AF_INET, "127.0.0.1", (void *)
    343             &addr.sin_addr.s_addr);
    344         if (rc != EOK) {
    345                 fprintf(stderr, "Error parsing network address: %s.\n",
    346                     str_error(rc));
    347                 return 2;
    348         }
    349 
    350         int listen_sd = socket(PF_INET, SOCK_STREAM, 0);
    351         if (listen_sd < 0) {
    352                 fprintf(stderr, "Error creating listening socket: %s.\n",
    353                     str_error(listen_sd));
    354                 return 3;
    355         }
    356 
    357         rc = bind(listen_sd, (struct sockaddr *) &addr, sizeof(addr));
    358         if (rc != EOK) {
    359                 fprintf(stderr, "Error binding socket: %s.\n",
    360                     str_error(rc));
    361                 return 4;
    362         }
    363 
    364         rc = listen(listen_sd, BACKLOG_SIZE);
    365         if (rc != EOK) {
    366                 fprintf(stderr, "listen() failed: %s.\n", str_error(rc));
    367                 return 5;
     367
     368        rc = tcp_create(&tcp);
     369        if (tcp != EOK) {
     370                fprintf(stderr, "%s: Error initialzing TCP.\n", NAME);
     371                return rc;
     372        }
     373
     374        inet_ep_init(&ep);
     375        ep.port = 2223;
     376
     377        rc = tcp_listener_create(tcp, &ep, &listen_cb, NULL, &conn_cb, NULL,
     378            &lst);
     379        if (rc != EOK) {
     380                fprintf(stderr, "%s: Error creating listener.\n", NAME);
     381                return rc;
    368382        }
    369383
    370384        printf("%s: HelenOS Remote console service\n", NAME);
    371385        task_retval(0);
    372 
    373         while (true) {
    374                 struct sockaddr_in raddr;
    375                 socklen_t raddr_len = sizeof(raddr);
    376                 int conn_sd = accept(listen_sd, (struct sockaddr *) &raddr,
    377                     &raddr_len);
    378 
    379                 if (conn_sd < 0) {
    380                         fprintf(stderr, "accept() failed: %s.\n",
    381                             str_error(rc));
    382                         continue;
    383                 }
    384 
    385                 telnet_user_t *user = telnet_user_create(conn_sd);
    386                 assert(user);
    387 
    388                 con_srvs_init(&user->srvs);
    389                 user->srvs.ops = &con_ops;
    390                 user->srvs.sarg = user;
    391                 user->srvs.abort_timeout = 1000;
    392 
    393                 telnet_user_add(user);
    394 
    395                 fid_t fid = fibril_create(network_user_fibril, user);
    396                 assert(fid);
    397                 fibril_add_ready(fid);
    398         }
    399 
     386        async_manager();
     387
     388        /* Not reached */
    400389        return 0;
    401390}

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

    rba0eac5 rfab2746  
    3838#define NAME       "remcons"
    3939#define NAMESPACE  "term"
    40 #define BACKLOG_SIZE  5
    4140
    4241#endif

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

    rba0eac5 rfab2746  
    4444#include <fibril_synch.h>
    4545#include <task.h>
    46 #include <net/in.h>
    47 #include <net/inet.h>
    48 #include <net/socket.h>
     46#include <inet/tcp.h>
    4947#include <io/console.h>
    5048#include <inttypes.h>
    … …  
    5856/** Create new telnet user.
    5957 *
    60  * @param socket Socket the user communicates through.
     58 * @param conn Incoming connection.
    6159 * @return New telnet user or NULL when out of memory.
    6260 */
    63 telnet_user_t *telnet_user_create(int socket)
     61telnet_user_t *telnet_user_create(tcp_conn_t *conn)
    6462{
    6563        static int telnet_user_id_counter = 0;
    … …  
    7876        }
    7977
    80         user->socket = socket;
     78        user->conn = conn;
    8179        user->service_id = (service_id_t) -1;
    8280        prodcons_initialize(&user->in_events);
    … …  
    193191        /* No more buffered data? */
    194192        if (user->socket_buffer_len <= user->socket_buffer_pos) {
    195                 int recv_length = recv(user->socket, user->socket_buffer, BUFFER_SIZE, 0);
    196                 if ((recv_length == 0) || (recv_length == ENOTCONN)) {
     193                int rc;
     194                size_t recv_length;
     195
     196                rc = tcp_conn_recv_wait(user->conn, user->socket_buffer,
     197                    BUFFER_SIZE, &recv_length);
     198                if (rc != EOK)
     199                        return rc;
     200
     201                if (recv_length == 0) {
    197202                        user->socket_closed = true;
    198203                        user->srvs.aborted = true;
    199204                        return ENOENT;
    200205                }
    201                 if (recv_length < 0) {
    202                         return recv_length;
    203                 }
     206
    204207                user->socket_buffer_len = recv_length;
    205208                user->socket_buffer_pos = 0;
    … …  
    359362
    360363
    361         int rc = send(user->socket, converted, converted_size, 0);
     364        int rc = tcp_conn_send(user->conn, converted, converted_size);
    362365        free(converted);
    363366

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

    rba0eac5 rfab2746  
    3838#include <adt/prodcons.h>
    3939#include <fibril_synch.h>
     40#include <inet/tcp.h>
    4041#include <inttypes.h>
    4142#include <io/con_srv.h>
    … …  
    5152        /** Internal id, used for creating locfs entries. */
    5253        int id;
    53         /** Associated socket. */
    54         int socket;
     54        /** Associated connection. */
     55        tcp_conn_t *conn;
    5556        /** Location service id assigned to the virtual terminal. */
    5657        service_id_t service_id;
    … …  
    8081} telnet_user_t;
    8182
    82 extern telnet_user_t *telnet_user_create(int);
     83extern telnet_user_t *telnet_user_create(tcp_conn_t *);
    8384extern void telnet_user_add(telnet_user_t *);
    8485extern void telnet_user_destroy(telnet_user_t *);

  • uspace/srv/hid/rfb/main.c

    rba0eac5 rfab2746  
    150150}
    151151
    152 static int socket_fibril(void *unused)
    153 {
    154         rfb_accept(&rfb);
    155        
    156         /* Not reached */
    157         return EOK;
    158 }
    159 
    160152int main(int argc, char **argv)
    161153{
    … …  
    267259        }
    268260       
    269         fid_t fib = fibril_create(socket_fibril, NULL);
    270         if (!fib) {
    271                 fprintf(stderr, NAME ": Unable to create socket fibril.\n");
    272                 return 2;
    273         }
    274        
    275         fibril_add_ready(fib);
    276        
    277261        printf("%s: Accepting connections\n", NAME);
    278262        task_retval(0);

  • uspace/srv/hid/rfb/rfb.c

    rba0eac5 rfab2746  
    3131#include <stdlib.h>
    3232#include <fibril_synch.h>
     33#include <inet/addr.h>
     34#include <inet/endpoint.h>
     35#include <inet/tcp.h>
    3336#include <inttypes.h>
    3437#include <str.h>
    … …  
    3841#include <io/log.h>
    3942
    40 #include <net/in.h>
    41 #include <net/inet.h>
    42 #include <net/socket.h>
    43 
    4443#include "rfb.h"
     44
     45static void rfb_new_conn(tcp_listener_t *, tcp_conn_t *);
     46
     47static tcp_listen_cb_t listen_cb = {
     48        .new_conn = rfb_new_conn
     49};
     50
     51static tcp_cb_t conn_cb = {
     52        .connected = NULL
     53};
    4554
    4655/** Buffer for receiving the request. */
    … …  
    5362
    5463/** Receive one character (with buffering) */
    55 static int recv_char(int fd, char *c)
    56 {
     64static int recv_char(tcp_conn_t *conn, char *c)
     65{
     66        size_t nrecv;
     67        int rc;
     68
    5769        if (rbuf_out == rbuf_in) {
    5870                rbuf_out = 0;
    5971                rbuf_in = 0;
    6072               
    61                 ssize_t rc = recv(fd, rbuf, BUFFER_SIZE, 0);
    62                 if (rc <= 0)
     73                rc = tcp_conn_recv_wait(conn, rbuf, BUFFER_SIZE, &nrecv);
     74                if (rc != EOK)
    6375                        return rc;
    6476               
    65                 rbuf_in = rc;
     77                rbuf_in = nrecv;
    6678        }
    6779       
    … …  
    7183
    7284/** Receive count characters (with buffering) */
    73 static int recv_chars(int fd, char *c, size_t count)
     85static int recv_chars(tcp_conn_t *conn, char *c, size_t count)
    7486{
    7587        for (size_t i = 0; i < count; i++) {
    76                 int rc = recv_char(fd, c);
     88                int rc = recv_char(conn, c);
    7789                if (rc != EOK)
    7890                        return rc;
    … …  
    8294}
    8395
    84 static int recv_skip_chars(int fd, size_t count)
     96static int recv_skip_chars(tcp_conn_t *conn, size_t count)
    8597{
    8698        for (size_t i = 0; i < count; i++) {
    8799                char c;
    88                 int rc = recv_char(fd, &c);
     100                int rc = recv_char(conn, &c);
    89101                if (rc != EOK)
    90102                        return rc;
    … …  
    204216}
    205217
    206 static int recv_message(int conn_sd, char type, void *buf, size_t size)
     218static int recv_message(tcp_conn_t *conn, char type, void *buf, size_t size)
    207219{
    208220        memcpy(buf, &type, 1);
    209         return recv_chars(conn_sd, ((char *) buf) + 1, size -1);
     221        return recv_chars(conn, ((char *) buf) + 1, size -1);
    210222}
    211223
    … …  
    477489}
    478490
    479 static int rfb_send_framebuffer_update(rfb_t *rfb, int conn_sd, bool incremental)
     491static int rfb_send_framebuffer_update(rfb_t *rfb, tcp_conn_t *conn,
     492    bool incremental)
    480493{
    481494        fibril_mutex_lock(&rfb->lock);
    … …  
    540553       
    541554        if (!rfb->pixel_format.true_color) {
    542                 int rc = send(conn_sd, send_palette, send_palette_size, 0);
     555                int rc = tcp_conn_send(conn, send_palette, send_palette_size);
    543556                if (rc != EOK) {
    544557                        free(buf);
    … …  
    547560        }
    548561       
    549         int rc = send(conn_sd, buf, buf_size, 0);
     562        int rc = tcp_conn_send(conn, buf, buf_size);
    550563        free(buf);
    551564       
    … …  
    580593}
    581594
    582 static void rfb_socket_connection(rfb_t *rfb, int conn_sd)
     595static void rfb_socket_connection(rfb_t *rfb, tcp_conn_t *conn)
    583596{
    584597        /* Version handshake */
    585         int rc = send(conn_sd, "RFB 003.008\n", 12, 0);
     598        int rc = tcp_conn_send(conn, "RFB 003.008\n", 12);
    586599        if (rc != EOK) {
    587600                log_msg(LOG_DEFAULT, LVL_WARN, "Failed sending server version %d", rc);
    … …  
    590603       
    591604        char client_version[12];
    592         rc = recv_chars(conn_sd, client_version, 12);
     605        rc = recv_chars(conn, client_version, 12);
    593606        if (rc != EOK) {
    594607                log_msg(LOG_DEFAULT, LVL_WARN, "Failed receiving client version: %d", rc);
    … …  
    607620        sec_types[0] = 1; /* length */
    608621        sec_types[1] = RFB_SECURITY_NONE;
    609         rc = send(conn_sd, sec_types, 2, 0);
     622        rc = tcp_conn_send(conn, sec_types, 2);
    610623        if (rc != EOK) {
    611624                log_msg(LOG_DEFAULT, LVL_WARN,
    … …  
    615628       
    616629        char selected_sec_type = 0;
    617         rc = recv_char(conn_sd, &selected_sec_type);
     630        rc = recv_char(conn, &selected_sec_type);
    618631        if (rc != EOK) {
    619632                log_msg(LOG_DEFAULT, LVL_WARN, "Failed receiving security type: %d", rc);
    … …  
    626639        }
    627640        uint32_t security_result = RFB_SECURITY_HANDSHAKE_OK;
    628         rc = send(conn_sd, &security_result, sizeof(uint32_t), 0);
     641        rc = tcp_conn_send(conn, &security_result, sizeof(uint32_t));
    629642        if (rc != EOK) {
    630643                log_msg(LOG_DEFAULT, LVL_WARN, "Failed sending security result: %d", rc);
    … …  
    634647        /* Client init */
    635648        char shared_flag;
    636         rc = recv_char(conn_sd, &shared_flag);
     649        rc = recv_char(conn, &shared_flag);
    637650        if (rc != EOK) {
    638651                log_msg(LOG_DEFAULT, LVL_WARN, "Failed receiving client init: %d", rc);
    … …  
    657670        memcpy(server_init->name, rfb->name, name_length);
    658671        fibril_mutex_unlock(&rfb->lock);
    659         rc = send(conn_sd, server_init, msg_length, 0);
     672        rc = tcp_conn_send(conn, server_init, msg_length);
    660673        if (rc != EOK) {
    661674                log_msg(LOG_DEFAULT, LVL_WARN, "Failed sending server init: %d", rc);
    … …  
    665678        while (true) {
    666679                char message_type = 0;
    667                 rc = recv_char(conn_sd, &message_type);
     680                rc = recv_char(conn, &message_type);
    668681                if (rc != EOK) {
    669682                        log_msg(LOG_DEFAULT, LVL_WARN,
    … …  
    680693                switch (message_type) {
    681694                case RFB_CMSG_SET_PIXEL_FORMAT:
    682                         recv_message(conn_sd, message_type, &spf, sizeof(spf));
     695                        recv_message(conn, message_type, &spf, sizeof(spf));
    683696                        rfb_pixel_format_to_host(&spf.pixel_format, &spf.pixel_format);
    684697                        log_msg(LOG_DEFAULT, LVL_DEBUG2, "Received SetPixelFormat message");
    … …  
    690703                        break;
    691704                case RFB_CMSG_SET_ENCODINGS:
    692                         recv_message(conn_sd, message_type, &se, sizeof(se));
     705                        recv_message(conn, message_type, &se, sizeof(se));
    693706                        rfb_set_encodings_to_host(&se, &se);
    694707                        log_msg(LOG_DEFAULT, LVL_DEBUG2, "Received SetEncodings message");
    695708                        for (uint16_t i = 0; i < se.count; i++) {
    696709                                int32_t encoding = 0;
    697                                 rc = recv_chars(conn_sd, (char *) &encoding, sizeof(int32_t));
     710                                rc = recv_chars(conn, (char *) &encoding, sizeof(int32_t));
    698711                                if (rc != EOK)
    699712                                        return;
    … …  
    707720                        break;
    708721                case RFB_CMSG_FRAMEBUFFER_UPDATE_REQUEST:
    709                         recv_message(conn_sd, message_type, &fbur, sizeof(fbur));
     722                        recv_message(conn, message_type, &fbur, sizeof(fbur));
    710723                        rfb_framebuffer_update_request_to_host(&fbur, &fbur);
    711724                        log_msg(LOG_DEFAULT, LVL_DEBUG2,
    712725                            "Received FramebufferUpdateRequest message");
    713                         rfb_send_framebuffer_update(rfb, conn_sd, fbur.incremental);
     726                        rfb_send_framebuffer_update(rfb, conn, fbur.incremental);
    714727                        break;
    715728                case RFB_CMSG_KEY_EVENT:
    716                         recv_message(conn_sd, message_type, &ke, sizeof(ke));
     729                        recv_message(conn, message_type, &ke, sizeof(ke));
    717730                        rfb_key_event_to_host(&ke, &ke);
    718731                        log_msg(LOG_DEFAULT, LVL_DEBUG2, "Received KeyEvent message");
    719732                        break;
    720733                case RFB_CMSG_POINTER_EVENT:
    721                         recv_message(conn_sd, message_type, &pe, sizeof(pe));
     734                        recv_message(conn, message_type, &pe, sizeof(pe));
    722735                        rfb_pointer_event_to_host(&pe, &pe);
    723736                        log_msg(LOG_DEFAULT, LVL_DEBUG2, "Received PointerEvent message");
    724737                        break;
    725738                case RFB_CMSG_CLIENT_CUT_TEXT:
    726                         recv_message(conn_sd, message_type, &cct, sizeof(cct));
     739                        recv_message(conn, message_type, &cct, sizeof(cct));
    727740                        rfb_client_cut_text_to_host(&cct, &cct);
    728741                        log_msg(LOG_DEFAULT, LVL_DEBUG2, "Received ClientCutText message");
    729                         recv_skip_chars(conn_sd, cct.length);
     742                        recv_skip_chars(conn, cct.length);
    730743                        break;
    731744                default:
    … …  
    737750}
    738751
    739 int rfb_listen(rfb_t *rfb, uint16_t port) {
    740         struct sockaddr_in addr;
    741        
    742         addr.sin_family = AF_INET;
    743         addr.sin_port = htons(port);
    744        
    745         int rc = inet_pton(AF_INET, "127.0.0.1", (void *)
    746             &addr.sin_addr.s_addr);
     752int rfb_listen(rfb_t *rfb, uint16_t port)
     753{
     754        tcp_t *tcp = NULL;
     755        tcp_listener_t *lst = NULL;
     756        inet_ep_t ep;
     757        int rc;
     758       
     759        inet_ep_init(&ep);
     760        ep.port = port;
     761       
     762        rc = tcp_listener_create(tcp, &ep, &listen_cb, rfb, &conn_cb, rfb,
     763            &lst);
    747764        if (rc != EOK) {
    748                 log_msg(LOG_DEFAULT, LVL_ERROR, "Error parsing network address (%s)",
    749                     str_error(rc));
    750                 return rc;
    751         }
    752 
    753         int listen_sd = socket(PF_INET, SOCK_STREAM, 0);
    754         if (listen_sd < 0) {
    755                 log_msg(LOG_DEFAULT, LVL_ERROR, "Error creating listening socket (%s)",
    756                     str_error(listen_sd));
    757                 return rc;
    758         }
    759        
    760         rc = bind(listen_sd, (struct sockaddr *) &addr, sizeof(addr));
    761         if (rc != EOK) {
    762                 log_msg(LOG_DEFAULT, LVL_ERROR, "Error binding socket (%s)",
    763                     str_error(rc));
    764                 return rc;
    765         }
    766        
    767         rc = listen(listen_sd, 2);
    768         if (rc != EOK) {
    769                 log_msg(LOG_DEFAULT, LVL_ERROR, "listen() failed (%s)", str_error(rc));
    770                 return rc;
    771         }
    772        
    773         rfb->listen_sd = listen_sd;
     765                log_msg(LOG_DEFAULT, LVL_ERROR, "Error creating listener.\n");
     766                goto error;
     767        }
     768       
     769        rfb->tcp = tcp;
     770        rfb->lst = lst;
    774771       
    775772        return EOK;
    776 }
    777 
    778 void rfb_accept(rfb_t *rfb)
    779 {
    780         while (true) {
    781                 struct sockaddr_in raddr;
    782                 socklen_t raddr_len = sizeof(raddr);
    783                 int conn_sd = accept(rfb->listen_sd, (struct sockaddr *) &raddr,
    784                     &raddr_len);
    785                
    786                 if (conn_sd < 0) {
    787                         log_msg(LOG_DEFAULT, LVL_WARN, "accept() failed (%s)",
    788                             str_error(conn_sd));
    789                         continue;
    790                 }
    791                
    792                 log_msg(LOG_DEFAULT, LVL_DEBUG, "Connection accepted");
    793                
    794                 rbuf_out = 0;
    795                 rbuf_in = 0;
    796                
    797                 rfb_socket_connection(rfb, conn_sd);
    798                 closesocket(conn_sd);
    799         }
    800 }
     773error:
     774        tcp_listener_destroy(lst);
     775        tcp_destroy(tcp);
     776        return rc;
     777}
     778
     779static void rfb_new_conn(tcp_listener_t *lst, tcp_conn_t *conn)
     780{
     781        rfb_t *rfb = (rfb_t *)tcp_listener_userptr(lst);
     782        log_msg(LOG_DEFAULT, LVL_DEBUG, "Connection accepted");
     783
     784        rbuf_out = 0;
     785        rbuf_in = 0;
     786
     787        rfb_socket_connection(rfb, conn);
     788}

  • uspace/srv/hid/rfb/rfb.h

    rba0eac5 rfab2746  
    3030#define RFB_H__
    3131
     32#include <inet/tcp.h>
    3233#include <io/pixelmap.h>
    3334#include <fibril_synch.h>
    … …  
    151152        rfb_pixel_format_t pixel_format;
    152153        const char *name;
    153         int listen_sd;
     154        tcp_t *tcp;
     155        tcp_listener_t *lst;
    154156        pixelmap_t framebuffer;
    155157        rfb_rectangle_t damage_rect;
    … …  
    165167extern int rfb_set_size(rfb_t *, uint16_t, uint16_t);
    166168extern int rfb_listen(rfb_t *, uint16_t);
    167 extern void rfb_accept(rfb_t *);
    168169
    169170#endif
Note: See TracChangeset for help on using the changeset viewer.