Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    rd6ff08a0 r870f78c  
    3131#include <stdlib.h>
    3232#include <fibril_synch.h>
    33 #include <inet/addr.h>
    34 #include <inet/endpoint.h>
    35 #include <inet/tcp.h>
    3633#include <inttypes.h>
    3734#include <str.h>
    … …  
    4138#include <io/log.h>
    4239
     40#include <net/in.h>
     41#include <net/inet.h>
     42#include <net/socket.h>
     43
    4344#include "rfb.h"
    44 
    45 static void rfb_new_conn(tcp_listener_t *, tcp_conn_t *);
    46 
    47 static tcp_listen_cb_t listen_cb = {
    48         .new_conn = rfb_new_conn
    49 };
    50 
    51 static tcp_cb_t conn_cb = {
    52         .connected = NULL
    53 };
    5445
    5546/** Buffer for receiving the request. */
    … …  
    6253
    6354/** Receive one character (with buffering) */
    64 static int recv_char(tcp_conn_t *conn, char *c)
    65 {
    66         size_t nrecv;
    67         int rc;
    68 
     55static int recv_char(int fd, char *c)
     56{
    6957        if (rbuf_out == rbuf_in) {
    7058                rbuf_out = 0;
    7159                rbuf_in = 0;
    7260               
    73                 rc = tcp_conn_recv_wait(conn, rbuf, BUFFER_SIZE, &nrecv);
    74                 if (rc != EOK)
     61                ssize_t rc = recv(fd, rbuf, BUFFER_SIZE, 0);
     62                if (rc <= 0)
    7563                        return rc;
    7664               
    77                 rbuf_in = nrecv;
     65                rbuf_in = rc;
    7866        }
    7967       
    … …  
    8371
    8472/** Receive count characters (with buffering) */
    85 static int recv_chars(tcp_conn_t *conn, char *c, size_t count)
     73static int recv_chars(int fd, char *c, size_t count)
    8674{
    8775        for (size_t i = 0; i < count; i++) {
    88                 int rc = recv_char(conn, c);
     76                int rc = recv_char(fd, c);
    8977                if (rc != EOK)
    9078                        return rc;
    … …  
    9482}
    9583
    96 static int recv_skip_chars(tcp_conn_t *conn, size_t count)
     84static int recv_skip_chars(int fd, size_t count)
    9785{
    9886        for (size_t i = 0; i < count; i++) {
    9987                char c;
    100                 int rc = recv_char(conn, &c);
     88                int rc = recv_char(fd, &c);
    10189                if (rc != EOK)
    10290                        return rc;
    … …  
    216204}
    217205
    218 static int recv_message(tcp_conn_t *conn, char type, void *buf, size_t size)
     206static int recv_message(int conn_sd, char type, void *buf, size_t size)
    219207{
    220208        memcpy(buf, &type, 1);
    221         return recv_chars(conn, ((char *) buf) + 1, size -1);
     209        return recv_chars(conn_sd, ((char *) buf) + 1, size -1);
    222210}
    223211
    … …  
    489477}
    490478
    491 static int rfb_send_framebuffer_update(rfb_t *rfb, tcp_conn_t *conn,
    492     bool incremental)
     479static int rfb_send_framebuffer_update(rfb_t *rfb, int conn_sd, bool incremental)
    493480{
    494481        fibril_mutex_lock(&rfb->lock);
    … …  
    553540       
    554541        if (!rfb->pixel_format.true_color) {
    555                 int rc = tcp_conn_send(conn, send_palette, send_palette_size);
     542                int rc = send(conn_sd, send_palette, send_palette_size, 0);
    556543                if (rc != EOK) {
    557544                        free(buf);
    … …  
    560547        }
    561548       
    562         int rc = tcp_conn_send(conn, buf, buf_size);
     549        int rc = send(conn_sd, buf, buf_size, 0);
    563550        free(buf);
    564551       
    … …  
    593580}
    594581
    595 static void rfb_socket_connection(rfb_t *rfb, tcp_conn_t *conn)
     582static void rfb_socket_connection(rfb_t *rfb, int conn_sd)
    596583{
    597584        /* Version handshake */
    598         int rc = tcp_conn_send(conn, "RFB 003.008\n", 12);
     585        int rc = send(conn_sd, "RFB 003.008\n", 12, 0);
    599586        if (rc != EOK) {
    600587                log_msg(LOG_DEFAULT, LVL_WARN, "Failed sending server version %d", rc);
    … …  
    603590       
    604591        char client_version[12];
    605         rc = recv_chars(conn, client_version, 12);
     592        rc = recv_chars(conn_sd, client_version, 12);
    606593        if (rc != EOK) {
    607594                log_msg(LOG_DEFAULT, LVL_WARN, "Failed receiving client version: %d", rc);
    … …  
    620607        sec_types[0] = 1; /* length */
    621608        sec_types[1] = RFB_SECURITY_NONE;
    622         rc = tcp_conn_send(conn, sec_types, 2);
     609        rc = send(conn_sd, sec_types, 2, 0);
    623610        if (rc != EOK) {
    624611                log_msg(LOG_DEFAULT, LVL_WARN,
    … …  
    628615       
    629616        char selected_sec_type = 0;
    630         rc = recv_char(conn, &selected_sec_type);
     617        rc = recv_char(conn_sd, &selected_sec_type);
    631618        if (rc != EOK) {
    632619                log_msg(LOG_DEFAULT, LVL_WARN, "Failed receiving security type: %d", rc);
    … …  
    639626        }
    640627        uint32_t security_result = RFB_SECURITY_HANDSHAKE_OK;
    641         rc = tcp_conn_send(conn, &security_result, sizeof(uint32_t));
     628        rc = send(conn_sd, &security_result, sizeof(uint32_t), 0);
    642629        if (rc != EOK) {
    643630                log_msg(LOG_DEFAULT, LVL_WARN, "Failed sending security result: %d", rc);
    … …  
    647634        /* Client init */
    648635        char shared_flag;
    649         rc = recv_char(conn, &shared_flag);
     636        rc = recv_char(conn_sd, &shared_flag);
    650637        if (rc != EOK) {
    651638                log_msg(LOG_DEFAULT, LVL_WARN, "Failed receiving client init: %d", rc);
    … …  
    670657        memcpy(server_init->name, rfb->name, name_length);
    671658        fibril_mutex_unlock(&rfb->lock);
    672         rc = tcp_conn_send(conn, server_init, msg_length);
     659        rc = send(conn_sd, server_init, msg_length, 0);
    673660        if (rc != EOK) {
    674661                log_msg(LOG_DEFAULT, LVL_WARN, "Failed sending server init: %d", rc);
    … …  
    678665        while (true) {
    679666                char message_type = 0;
    680                 rc = recv_char(conn, &message_type);
     667                rc = recv_char(conn_sd, &message_type);
    681668                if (rc != EOK) {
    682669                        log_msg(LOG_DEFAULT, LVL_WARN,
    … …  
    693680                switch (message_type) {
    694681                case RFB_CMSG_SET_PIXEL_FORMAT:
    695                         recv_message(conn, message_type, &spf, sizeof(spf));
     682                        recv_message(conn_sd, message_type, &spf, sizeof(spf));
    696683                        rfb_pixel_format_to_host(&spf.pixel_format, &spf.pixel_format);
    697684                        log_msg(LOG_DEFAULT, LVL_DEBUG2, "Received SetPixelFormat message");
    … …  
    703690                        break;
    704691                case RFB_CMSG_SET_ENCODINGS:
    705                         recv_message(conn, message_type, &se, sizeof(se));
     692                        recv_message(conn_sd, message_type, &se, sizeof(se));
    706693                        rfb_set_encodings_to_host(&se, &se);
    707694                        log_msg(LOG_DEFAULT, LVL_DEBUG2, "Received SetEncodings message");
    708695                        for (uint16_t i = 0; i < se.count; i++) {
    709696                                int32_t encoding = 0;
    710                                 rc = recv_chars(conn, (char *) &encoding, sizeof(int32_t));
     697                                rc = recv_chars(conn_sd, (char *) &encoding, sizeof(int32_t));
    711698                                if (rc != EOK)
    712699                                        return;
    … …  
    720707                        break;
    721708                case RFB_CMSG_FRAMEBUFFER_UPDATE_REQUEST:
    722                         recv_message(conn, message_type, &fbur, sizeof(fbur));
     709                        recv_message(conn_sd, message_type, &fbur, sizeof(fbur));
    723710                        rfb_framebuffer_update_request_to_host(&fbur, &fbur);
    724711                        log_msg(LOG_DEFAULT, LVL_DEBUG2,
    725712                            "Received FramebufferUpdateRequest message");
    726                         rfb_send_framebuffer_update(rfb, conn, fbur.incremental);
     713                        rfb_send_framebuffer_update(rfb, conn_sd, fbur.incremental);
    727714                        break;
    728715                case RFB_CMSG_KEY_EVENT:
    729                         recv_message(conn, message_type, &ke, sizeof(ke));
     716                        recv_message(conn_sd, message_type, &ke, sizeof(ke));
    730717                        rfb_key_event_to_host(&ke, &ke);
    731718                        log_msg(LOG_DEFAULT, LVL_DEBUG2, "Received KeyEvent message");
    732719                        break;
    733720                case RFB_CMSG_POINTER_EVENT:
    734                         recv_message(conn, message_type, &pe, sizeof(pe));
     721                        recv_message(conn_sd, message_type, &pe, sizeof(pe));
    735722                        rfb_pointer_event_to_host(&pe, &pe);
    736723                        log_msg(LOG_DEFAULT, LVL_DEBUG2, "Received PointerEvent message");
    737724                        break;
    738725                case RFB_CMSG_CLIENT_CUT_TEXT:
    739                         recv_message(conn, message_type, &cct, sizeof(cct));
     726                        recv_message(conn_sd, message_type, &cct, sizeof(cct));
    740727                        rfb_client_cut_text_to_host(&cct, &cct);
    741728                        log_msg(LOG_DEFAULT, LVL_DEBUG2, "Received ClientCutText message");
    742                         recv_skip_chars(conn, cct.length);
     729                        recv_skip_chars(conn_sd, cct.length);
    743730                        break;
    744731                default:
    … …  
    750737}
    751738
    752 int 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         rc = tcp_create(&tcp);
    760         if (rc != EOK) {
    761                 log_msg(LOG_DEFAULT, LVL_ERROR, "Error initializing TCP.");
    762                 goto error;
    763         }
    764        
    765         inet_ep_init(&ep);
    766         ep.port = port;
    767        
    768         rc = tcp_listener_create(tcp, &ep, &listen_cb, rfb, &conn_cb, rfb,
    769             &lst);
    770         if (rc != EOK) {
    771                 log_msg(LOG_DEFAULT, LVL_ERROR, "Error creating listener.");
    772                 goto error;
    773         }
    774        
    775         rfb->tcp = tcp;
    776         rfb->lst = lst;
     739int 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);
     747        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;
    777774       
    778775        return EOK;
    779 error:
    780         tcp_listener_destroy(lst);
    781         tcp_destroy(tcp);
    782         return rc;
    783 }
    784 
    785 static void rfb_new_conn(tcp_listener_t *lst, tcp_conn_t *conn)
    786 {
    787         rfb_t *rfb = (rfb_t *)tcp_listener_userptr(lst);
    788         log_msg(LOG_DEFAULT, LVL_DEBUG, "Connection accepted");
    789 
    790         rbuf_out = 0;
    791         rbuf_in = 0;
    792 
    793         rfb_socket_connection(rfb, conn);
    794 }
     776}
     777
     778void 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}
Note: See TracChangeset for help on using the changeset viewer.