Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/app/websrv/websrv.c

    rb99f6e2 r3e6a98c5  
    4444#include <task.h>
    4545
    46 #include <inet/addr.h>
    47 #include <inet/endpoint.h>
    48 #include <inet/tcp.h>
     46#include <net/in.h>
     47#include <net/inet.h>
     48#include <net/socket.h>
    4949
    5050#include <arg_parse.h>
     
    5656
    5757#define DEFAULT_PORT  8080
     58#define BACKLOG_SIZE  3
    5859
    5960#define WEB_ROOT  "/data/web"
     
    6162/** Buffer for receiving the request. */
    6263#define BUFFER_SIZE  1024
    63 
    64 static void websrv_new_conn(tcp_listener_t *, tcp_conn_t *);
    65 
    66 static tcp_listen_cb_t listen_cb = {
    67         .new_conn = websrv_new_conn
    68 };
    69 
    70 static tcp_cb_t conn_cb = {
    71         .connected = NULL
    72 };
    7364
    7465static uint16_t port = DEFAULT_PORT;
     
    131122
    132123/** Receive one character (with buffering) */
    133 static int recv_char(tcp_conn_t *conn, char *c)
    134 {
    135         size_t nrecv;
    136         int rc;
    137        
     124static int recv_char(int fd, char *c)
     125{
    138126        if (rbuf_out == rbuf_in) {
    139127                rbuf_out = 0;
    140128                rbuf_in = 0;
    141129               
    142                 rc = tcp_conn_recv_wait(conn, rbuf, BUFFER_SIZE, &nrecv);
    143                 if (rc != EOK) {
    144                         fprintf(stderr, "tcp_conn_recv() failed (%d)\n", rc);
     130                ssize_t rc = recv(fd, rbuf, BUFFER_SIZE, 0);
     131                if (rc <= 0) {
     132                        fprintf(stderr, "recv() failed (%zd)\n", rc);
    145133                        return rc;
    146134                }
    147135               
    148                 rbuf_in = nrecv;
     136                rbuf_in = rc;
    149137        }
    150138       
     
    154142
    155143/** Receive one line with length limit */
    156 static int recv_line(tcp_conn_t *conn)
     144static int recv_line(int fd)
    157145{
    158146        char *bp = lbuf;
     
    161149        while (bp < lbuf + BUFFER_SIZE) {
    162150                char prev = c;
    163                 int rc = recv_char(conn, &c);
     151                int rc = recv_char(fd, &c);
    164152               
    165153                if (rc != EOK)
     
    199187}
    200188
    201 static int send_response(tcp_conn_t *conn, const char *msg)
     189static int send_response(int conn_sd, const char *msg)
    202190{
    203191        size_t response_size = str_size(msg);
     
    206194            fprintf(stderr, "Sending response\n");
    207195       
    208         int rc = tcp_conn_send(conn, (void *) msg, response_size);
    209         if (rc != EOK) {
    210                 fprintf(stderr, "tcp_conn_send() failed\n");
     196        ssize_t rc = send(conn_sd, (void *) msg, response_size, 0);
     197        if (rc < 0) {
     198                fprintf(stderr, "send() failed\n");
    211199                return rc;
    212200        }
     
    215203}
    216204
    217 static int uri_get(const char *uri, tcp_conn_t *conn)
     205static int uri_get(const char *uri, int conn_sd)
    218206{
    219207        if (str_cmp(uri, "/") == 0)
     
    227215        int fd = open(fname, O_RDONLY);
    228216        if (fd < 0) {
    229                 rc = send_response(conn, msg_not_found);
     217                rc = send_response(conn_sd, msg_not_found);
    230218                free(fname);
    231219                return rc;
     
    234222        free(fname);
    235223       
    236         rc = send_response(conn, msg_ok);
     224        rc = send_response(conn_sd, msg_ok);
    237225        if (rc != EOK)
    238226                return rc;
     
    248236                }
    249237               
    250                 rc = tcp_conn_send(conn, fbuf, nr);
    251                 if (rc != EOK) {
    252                         fprintf(stderr, "tcp_conn_send() failed\n");
     238                rc = send(conn_sd, fbuf, nr, 0);
     239                if (rc < 0) {
     240                        fprintf(stderr, "send() failed\n");
    253241                        close(fd);
    254242                        return rc;
     
    261249}
    262250
    263 static int req_process(tcp_conn_t *conn)
    264 {
    265         int rc = recv_line(conn);
     251static int req_process(int conn_sd)
     252{
     253        int rc = recv_line(conn_sd);
    266254        if (rc != EOK) {
    267255                fprintf(stderr, "recv_line() failed\n");
     
    273261       
    274262        if (str_lcmp(lbuf, "GET ", 4) != 0) {
    275                 rc = send_response(conn, msg_not_implemented);
     263                rc = send_response(conn_sd, msg_not_implemented);
    276264                return rc;
    277265        }
     
    289277       
    290278        if (!uri_is_valid(uri)) {
    291                 rc = send_response(conn, msg_bad_request);
    292                 return rc;
    293         }
    294        
    295         return uri_get(uri, conn);
     279                rc = send_response(conn_sd, msg_bad_request);
     280                return rc;
     281        }
     282       
     283        return uri_get(uri, conn_sd);
    296284}
    297285
     
    358346}
    359347
    360 static void websrv_new_conn(tcp_listener_t *lst, tcp_conn_t *conn)
    361 {
    362         int rc;
    363        
    364         if (verbose)
    365                 fprintf(stderr, "New connection, waiting for request\n");
    366        
    367         rbuf_out = 0;
    368         rbuf_in = 0;
    369        
    370         rc = req_process(conn);
    371         if (rc != EOK) {
    372                 fprintf(stderr, "Error processing request (%s)\n",
    373                     str_error(rc));
    374                 return;
    375         }
    376 
    377         rc = tcp_conn_send_fin(conn);
    378         if (rc != EOK) {
    379                 fprintf(stderr, "Error sending FIN.\n");
    380                 return;
    381         }
    382 }
    383 
    384348int main(int argc, char *argv[])
    385349{
    386         inet_ep_t ep;
    387         tcp_listener_t *lst;
    388         tcp_t *tcp;
    389         int rc;
    390        
    391350        /* Parse command line arguments */
    392351        for (int i = 1; i < argc; i++) {
    393352                if (argv[i][0] == '-') {
    394                         rc = parse_option(argc, argv, &i);
     353                        int rc = parse_option(argc, argv, &i);
    395354                        if (rc != EOK)
    396355                                return rc;
     
    401360        }
    402361       
     362        struct sockaddr_in addr;
     363       
     364        addr.sin_family = AF_INET;
     365        addr.sin_port = htons(port);
     366       
     367        int rc = inet_pton(AF_INET, "127.0.0.1", (void *)
     368            &addr.sin_addr.s_addr);
     369        if (rc != EOK) {
     370                fprintf(stderr, "Error parsing network address (%s)\n",
     371                    str_error(rc));
     372                return 1;
     373        }
     374       
    403375        printf("%s: HelenOS web server\n", NAME);
    404376
    405377        if (verbose)
    406                 fprintf(stderr, "Creating listener\n");
    407        
    408         inet_ep_init(&ep);
    409         ep.port = port;
    410 
    411         rc = tcp_create(&tcp);
     378                fprintf(stderr, "Creating socket\n");
     379       
     380        int listen_sd = socket(PF_INET, SOCK_STREAM, 0);
     381        if (listen_sd < 0) {
     382                fprintf(stderr, "Error creating listening socket (%s)\n",
     383                    str_error(listen_sd));
     384                return 2;
     385        }
     386       
     387        rc = bind(listen_sd, (struct sockaddr *) &addr, sizeof(addr));
    412388        if (rc != EOK) {
    413                 fprintf(stderr, "Error initializing TCP.\n");
    414                 return 1;
    415         }
    416 
    417         rc = tcp_listener_create(tcp, &ep, &listen_cb, NULL, &conn_cb, NULL,
    418             &lst);
     389                fprintf(stderr, "Error binding socket (%s)\n",
     390                    str_error(rc));
     391                return 3;
     392        }
     393       
     394        rc = listen(listen_sd, BACKLOG_SIZE);
    419395        if (rc != EOK) {
    420                 fprintf(stderr, "Error creating listener.\n");
    421                 return 2;
     396                fprintf(stderr, "listen() failed (%s)\n", str_error(rc));
     397                return 4;
    422398        }
    423399       
     
    426402
    427403        task_retval(0);
    428         async_manager();
     404
     405        while (true) {
     406                struct sockaddr_in raddr;
     407                socklen_t raddr_len = sizeof(raddr);
     408                int conn_sd = accept(listen_sd, (struct sockaddr *) &raddr,
     409                    &raddr_len);
     410               
     411                if (conn_sd < 0) {
     412                        fprintf(stderr, "accept() failed (%s)\n", str_error(rc));
     413                        continue;
     414                }
     415               
     416                if (verbose) {
     417                        fprintf(stderr, "Connection accepted (sd=%d), "
     418                            "waiting for request\n", conn_sd);
     419                }
     420               
     421                rbuf_out = 0;
     422                rbuf_in = 0;
     423               
     424                rc = req_process(conn_sd);
     425                if (rc != EOK)
     426                        fprintf(stderr, "Error processing request (%s)\n",
     427                            str_error(rc));
     428               
     429                rc = closesocket(conn_sd);
     430                if (rc != EOK) {
     431                        fprintf(stderr, "Error closing connection socket (%s)\n",
     432                            str_error(rc));
     433                        closesocket(listen_sd);
     434                        return 5;
     435                }
     436               
     437                if (verbose)
     438                        fprintf(stderr, "Connection closed\n");
     439        }
    429440       
    430441        /* Not reached */
Note: See TracChangeset for help on using the changeset viewer.