Ignore:
File:
1 edited

Legend:

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

    ra35b458 r5a6cc679  
    137137{
    138138        recv_t *recv;
    139 
     139       
    140140        recv = calloc(1, sizeof(recv_t));
    141141        if (recv == NULL)
    142142                return ENOMEM;
    143 
     143       
    144144        recv->conn = conn;
    145145        recv->rbuf_out = 0;
    146146        recv->rbuf_in = 0;
    147147        recv->lbuf_used = 0;
    148 
     148       
    149149        *rrecv = recv;
    150150        return EOK;
     
    161161        size_t nrecv;
    162162        errno_t rc;
    163 
     163       
    164164        if (recv->rbuf_out == recv->rbuf_in) {
    165165                recv->rbuf_out = 0;
    166166                recv->rbuf_in = 0;
    167 
     167               
    168168                rc = tcp_conn_recv_wait(recv->conn, recv->rbuf, BUFFER_SIZE, &nrecv);
    169169                if (rc != EOK) {
     
    171171                        return rc;
    172172                }
    173 
     173               
    174174                recv->rbuf_in = nrecv;
    175175        }
    176 
     176       
    177177        *c = recv->rbuf[recv->rbuf_out++];
    178178        return EOK;
     
    184184        char *bp = recv->lbuf;
    185185        char c = '\0';
    186 
     186       
    187187        while (bp < recv->lbuf + BUFFER_SIZE) {
    188188                char prev = c;
    189189                errno_t rc = recv_char(recv, &c);
    190 
     190               
    191191                if (rc != EOK)
    192192                        return rc;
    193 
     193               
    194194                *bp++ = c;
    195195                if ((prev == '\r') && (c == '\n'))
    196196                        break;
    197197        }
    198 
     198       
    199199        recv->lbuf_used = bp - recv->lbuf;
    200200        *bp = '\0';
    201 
     201       
    202202        if (bp == recv->lbuf + BUFFER_SIZE)
    203203                return ELIMIT;
    204 
     204       
    205205        *rbuf = recv->lbuf;
    206206        return EOK;
     
    211211        if (uri[0] != '/')
    212212                return false;
    213 
     213       
    214214        if (uri[1] == '.')
    215215                return false;
    216 
     216       
    217217        char *cp = uri + 1;
    218 
     218       
    219219        while (*cp != '\0') {
    220220                char c = *cp++;
     
    222222                        return false;
    223223        }
    224 
     224       
    225225        return true;
    226226}
     
    229229{
    230230        size_t response_size = str_size(msg);
    231 
     231       
    232232        if (verbose)
    233233            fprintf(stderr, "Sending response\n");
    234 
     234       
    235235        errno_t rc = tcp_conn_send(conn, (void *) msg, response_size);
    236236        if (rc != EOK) {
     
    238238                return rc;
    239239        }
    240 
     240       
    241241        return EOK;
    242242}
     
    249249        size_t nr;
    250250        int fd = -1;
    251 
     251       
    252252        fbuf = calloc(BUFFER_SIZE, 1);
    253253        if (fbuf == NULL) {
     
    255255                goto out;
    256256        }
    257 
     257       
    258258        if (str_cmp(uri, "/") == 0)
    259259                uri = "/index.html";
    260 
     260       
    261261        if (asprintf(&fname, "%s%s", WEB_ROOT, uri) < 0) {
    262262                rc = ENOMEM;
    263263                goto out;
    264264        }
    265 
     265       
    266266        rc = vfs_lookup_open(fname, WALK_REGULAR, MODE_READ, &fd);
    267267        if (rc != EOK) {
     
    269269                goto out;
    270270        }
    271 
     271       
    272272        free(fname);
    273273        fname = NULL;
    274 
     274       
    275275        rc = send_response(conn, msg_ok);
    276276        if (rc != EOK)
    277277                goto out;
    278 
     278       
    279279        aoff64_t pos = 0;
    280280        while (true) {
     
    282282                if (rc != EOK)
    283283                        goto out;
    284 
     284               
    285285                if (nr == 0)
    286286                        break;
    287 
     287               
    288288                rc = tcp_conn_send(conn, fbuf, nr);
    289289                if (rc != EOK) {
     
    292292                }
    293293        }
    294 
     294       
    295295        rc = EOK;
    296296out:
     
    311311                return rc;
    312312        }
    313 
     313       
    314314        if (verbose)
    315315                fprintf(stderr, "Request: %s", reqline);
    316 
     316       
    317317        if (str_lcmp(reqline, "GET ", 4) != 0) {
    318318                rc = send_response(conn, msg_not_implemented);
    319319                return rc;
    320320        }
    321 
     321       
    322322        char *uri = reqline + 4;
    323323        char *end_uri = str_chr(uri, ' ');
     
    326326                assert(*end_uri == '\r');
    327327        }
    328 
     328       
    329329        *end_uri = '\0';
    330330        if (verbose)
    331331                fprintf(stderr, "Requested URI: %s\n", uri);
    332 
     332       
    333333        if (!uri_is_valid(uri)) {
    334334                rc = send_response(conn, msg_bad_request);
    335335                return rc;
    336336        }
    337 
     337       
    338338        return uri_get(uri, conn);
    339339}
     
    359359        int value;
    360360        errno_t rc;
    361 
     361       
    362362        switch (argv[*index][1]) {
    363363        case 'h':
     
    369369                if (rc != EOK)
    370370                        return rc;
    371 
     371               
    372372                port = (uint16_t) value;
    373373                break;
     
    384384                        if (rc != EOK)
    385385                                return rc;
    386 
     386                       
    387387                        port = (uint16_t) value;
    388388                } else if (str_cmp(argv[*index] +2, "verbose") == 0) {
     
    397397                return EINVAL;
    398398        }
    399 
     399       
    400400        return EOK;
    401401}
     
    405405        errno_t rc;
    406406        recv_t *recv = NULL;
    407 
     407       
    408408        if (verbose)
    409409                fprintf(stderr, "New connection, waiting for request\n");
    410 
     410       
    411411        rc = recv_create(conn, &recv);
    412412        if (rc != EOK) {
     
    414414                goto error;
    415415        }
    416 
     416       
    417417        rc = req_process(conn, recv);
    418418        if (rc != EOK) {
     
    421421                goto error;
    422422        }
    423 
     423       
    424424        rc = tcp_conn_send_fin(conn);
    425425        if (rc != EOK) {
     
    434434        if (rc != EOK)
    435435                fprintf(stderr, "Error resetting connection.\n");
    436 
     436       
    437437        recv_destroy(recv);
    438438}
     
    444444        tcp_t *tcp;
    445445        errno_t rc;
    446 
     446       
    447447        /* Parse command line arguments */
    448448        for (int i = 1; i < argc; i++) {
     
    456456                }
    457457        }
    458 
     458       
    459459        printf("%s: HelenOS web server\n", NAME);
    460460
    461461        if (verbose)
    462462                fprintf(stderr, "Creating listener\n");
    463 
     463       
    464464        inet_ep_init(&ep);
    465465        ep.port = port;
     
    477477                return 2;
    478478        }
    479 
     479       
    480480        fprintf(stderr, "%s: Listening for connections at port %" PRIu16 "\n",
    481481            NAME, port);
     
    483483        task_retval(0);
    484484        async_manager();
    485 
     485       
    486486        /* Not reached */
    487487        return 0;
Note: See TracChangeset for help on using the changeset viewer.