Changeset b39eb79 in mainline for uspace/app

Timestamp:

2011-12-26T17:21:21Z (14 years ago)

Author:

Jan Vesely <jano.vesely@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

9b56a8dd

Parents:

cf5c05c0 (diff), 7e1b130 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Mainline changes.

Location:

uspace/app

Files:

• klog/klog.c (modified) (1 diff)
• mkbd/main.c (modified) (1 diff)
• netecho/netecho.c (modified) (3 diffs)
• nettest3/Makefile (added)
• nettest3/nettest3.c (added)
• tester/mm/common.c (modified) (1 diff)
• tester/mm/mapping1.c (modified) (2 diffs)
• trace/syscalls.c (modified) (1 diff)
• usbinfo/dev.c (modified) (2 diffs)
• usbinfo/info.c (modified) (2 diffs)
• usbinfo/main.c (modified) (1 diff)
• usbinfo/usbinfo.h (modified) (1 diff)
• websrv/websrv.c (modified) (7 diffs)

uspace/app/klog/klog.c

@@ -205 +205 @@
         klog_length = size / sizeof(wchar_t);
         
-        klog = (wchar_t *) as_get_mappable_page(size);
-        if (klog == NULL) {
-                fprintf(stderr, "%s: Unable to allocate virtual memory area\n",
-                    NAME);
-                return ENOMEM;
-        }
-        
-        rc = physmem_map((void *) faddr, (void *) klog, pages,
-            AS_AREA_READ | AS_AREA_CACHEABLE);
+        rc = physmem_map((void *) faddr, pages,
+            AS_AREA_READ | AS_AREA_CACHEABLE, (void *) &klog);
         if (rc != EOK) {
                 fprintf(stderr, "%s: Unable to map klog\n", NAME);

uspace/app/mkbd/main.c

@@ -48 +48 @@
 #include <usb/dev/pipes.h>
 #include <async.h>
+#include <usb/dev.h>
 #include <usb/hid/usages/core.h>
 #include <usb/hid/hidparser.h>

uspace/app/netecho/netecho.c

@@ -241 +241 @@
                 /* Accept a socket if a stream socket is used */
                 addrlen = sizeof(address_buf);
+                if (verbose)
+                        printf("accept()\n");
                 socket_id = accept(listening_id, (void *) address_buf, &addrlen);
                 if (socket_id <= 0) {
@@ -258 +260 @@
 
                 /* Receive a message to echo */
+                if (verbose)
+                        printf("recvfrom()\n");
                 rcv_size = recvfrom(socket_id, data, size, 0, address,
                     &addrlen);
@@ -297 +301 @@
 
                         /* Answer the request either with the static reply or the original data */
-                        rc = sendto(socket_id, reply ? reply : data, reply ? reply_length : length, 0, address, addrlen);
-                        if (rc != EOK)
-                                socket_print_error(stderr, rc, "Socket send: ", "\n");
+                        if (type == SOCK_STREAM) {
+                                if (verbose)
+                                        printf("send()\n");
+                                rc = send(socket_id, reply ? reply : data, reply ? reply_length : length, 0);
+                                if (rc != EOK)
+                                        socket_print_error(stderr, rc, "Socket send: ", "\n");
+                        } else {
+                                if (verbose)
+                                        printf("sendto()\n");
+                                rc = sendto(socket_id, reply ? reply : data, reply ? reply_length : length, 0, address, addrlen);
+                                if (rc != EOK)
+                                        socket_print_error(stderr, rc, "Socket send: ", "\n");
+                        }
                 }
 

uspace/app/tester/mm/common.c

@@ -342 +342 @@
         link_initialize(&area->link);
         
-        /* Map the memory area */
-        void *addr = as_get_mappable_page(size);
-        if (addr == NULL) {
+        area->addr = as_area_create((void *) -1, size,
+            AS_AREA_WRITE | AS_AREA_READ);
+        if (area->addr == (void *) -1) {
                 free(area);
                 check_consistency("map_area (a)");
-                return NULL;
-        }
-        
-        area->addr = as_area_create(addr, size, AS_AREA_WRITE | AS_AREA_READ);
-        if (area->addr == (void *) -1) {
-                free(area);
-                check_consistency("map_area (b)");
                 return NULL;
         }

uspace/app/tester/mm/mapping1.c

@@ -35 +35 @@
 #include "../tester.h"
 
-#define BUFFER1_PAGES 4
-#define BUFFER2_PAGES 2
+#define BUFFER1_PAGES  4
+#define BUFFER2_PAGES  2
 
 static void *create_as_area(size_t size)
 {
-        void *result = as_get_mappable_page(size);
         TPRINTF("Creating AS area...\n");
-        if (as_area_create(result, size,
-            AS_AREA_READ | AS_AREA_WRITE) != result) {
+        
+        void *result = as_area_create((void *) -1, size,
+            AS_AREA_READ | AS_AREA_WRITE);
+        if (result == (void *) -1)
                 return NULL;
-        }
+        
         return result;
 }
@@ -71 +72 @@
         int i;
         for (i = 0; i < page_count; i++) {
-                void *page_start = ((char *)area) + PAGE_SIZE * i;
+                void *page_start = ((char *) area) + PAGE_SIZE * i;
                 int rc = as_get_physical_mapping(page_start, NULL);
                 if (rc != expected_rc) {

uspace/app/trace/syscalls.c

@@ -72 +72 @@
     [SYS_PHYSMEM_MAP] = { "physmem_map",                4,      V_ERRNO },
     [SYS_IOSPACE_ENABLE] = { "iospace_enable",          1,      V_ERRNO },
-    [SYS_REGISTER_IRQ] = { "register_irq",      4,      V_ERRNO },
-    [SYS_UNREGISTER_IRQ] = { "unregister_irq",  2,      V_ERRNO },
+    [SYS_IRQ_REGISTER] = { "irq_register",      4,      V_ERRNO },
+    [SYS_IRQ_UNREGISTER] = { "irq_unregister",  2,      V_ERRNO },
 
     [SYS_SYSINFO_GET_VAL_TYPE] = { "sysinfo_get_val_type",              2,      V_INTEGER },

uspace/app/usbinfo/dev.c

@@ -34 +34 @@
  * Representation of queried device.
  */
-#include <usb/dev/pipes.h>
+#include <usb/dev.h>
+#include <usb/hc.h>
 #include <errno.h>
 #include <str_error.h>
@@ -52 +53 @@
         bool transfer_started = false;
 
-        rc = usb_device_connection_initialize(&dev->wire, hc_handle, dev_addr);
+        usb_hc_connection_initialize(&dev->hc_conn, hc_handle);
+
+        rc = usb_device_connection_initialize(
+            &dev->wire, &dev->hc_conn, dev_addr);
         if (rc != EOK) {
                 fprintf(stderr,

uspace/app/usbinfo/info.c

@@ -287 +287 @@
 void dump_strings(usbinfo_device_t *dev)
 {
+        /* Find used indexes. Devices with more than 64 strings are very rare.*/
+        uint64_t str_mask = 0;
+        find_string_indexes_callback((uint8_t *)&dev->device_descriptor, 0,
+            &str_mask);
+        usb_dp_walk_simple(dev->full_configuration_descriptor,
+            dev->full_configuration_descriptor_size,
+            usb_dp_standard_descriptor_nesting,
+            find_string_indexes_callback,
+            &str_mask);
+
+        if (str_mask == 0) {
+                printf("Device does not support string descriptors.\n");
+                return;
+        }
+
         /* Get supported languages. */
         l18_win_locales_t *langs;
@@ -305 +320 @@
         }
         printf(".\n");
-
-        /* Find used indexes. Device with more than 64 strings are very rare.
-         */
-        uint64_t str_mask = 0;
-        find_string_indexes_callback((uint8_t *)&dev->device_descriptor, 0,
-            &str_mask);
-        usb_dp_walk_simple(dev->full_configuration_descriptor,
-            dev->full_configuration_descriptor_size,
-            usb_dp_standard_descriptor_nesting,
-            find_string_indexes_callback,
-            &str_mask);
 
         /* Get all strings and dump them. */

uspace/app/usbinfo/main.c

@@ -44 +44 @@
 #include <loc.h>
 #include <usb/hc.h>
+#include <usb/dev.h>
 #include <usb/dev/pipes.h>
 #include "usbinfo.h"

uspace/app/usbinfo/usbinfo.h

@@ -44 +44 @@
 
 typedef struct {
+        usb_hc_connection_t hc_conn;
+        usb_device_connection_t wire;
         usb_pipe_t ctrl_pipe;
-        usb_device_connection_t wire;
         usb_standard_device_descriptor_t device_descriptor;
         uint8_t *full_configuration_descriptor;

uspace/app/websrv/websrv.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2010 Jiri Svoboda
+ * Copyright (c) 2011 Jiri Svoboda
  * All rights reserved.
  *
@@ -31 +31 @@
  */
 /**
- * @file (Less-than-skeleton) web server.
+ * @file Skeletal web server.
  */
 
+#include <bool.h>
+#include <errno.h>
 #include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <stdlib.h>
+#include <fcntl.h>
 
 #include <net/in.h>
@@ -44 +50 @@
 #define PORT_NUMBER 8080
 
+#define WEB_ROOT "/data/web"
+
 /** Buffer for receiving the request. */
 #define BUFFER_SIZE 1024
-static char buf[BUFFER_SIZE];
+static char rbuf[BUFFER_SIZE];
+static size_t rbuf_out, rbuf_in;
+
+static char lbuf[BUFFER_SIZE + 1];
+static size_t lbuf_used;
+
+static char fbuf[BUFFER_SIZE];
 
 /** Response to send to client. */
-static const char *response_msg =
+static const char *ok_msg =
     "HTTP/1.0 200 OK\r\n"
-    "\r\n"
-    "<h1>Hello from HelenOS!</h1>\r\n";
+    "\r\n";
+
+/** Receive one character (with buffering) */
+static int recv_char(int fd, char *c)
+{
+        ssize_t rc;
+
+        if (rbuf_out == rbuf_in) {
+                rbuf_out = 0;
+                rbuf_in = 0;
+
+                rc = recv(fd, rbuf, BUFFER_SIZE, 0);
+                if (rc <= 0) {
+                        printf("recv() failed (%zd)\n", rc);
+                        return rc;
+                }
+
+                rbuf_in = rc;
+        }
+
+        *c = rbuf[rbuf_out++];
+        return EOK;
+}
+
+/** Receive one line with length limit. */
+static int recv_line(int fd)
+{
+        char c, prev;
+        int rc;
+        char *bp;
+
+        bp = lbuf; c = '\0';
+        while (bp < lbuf + BUFFER_SIZE) {
+                prev = c;
+                rc = recv_char(fd, &c);
+                if (rc != EOK)
+                        return rc;
+
+                *bp++ = c;
+                if (prev == '\r' && c == '\n')
+                        break;
+        }
+
+        lbuf_used = bp - lbuf;
+        *bp = '\0';
+
+        if (bp == lbuf + BUFFER_SIZE)
+                return ELIMIT;
+
+        return EOK;
+}
+
+static bool uri_is_valid(char *uri)
+{
+        char *cp;
+        char c;
+
+        if (uri[0] != '/')
+                return false;
+        if (uri[1] == '.')
+                return false;
+
+        cp = uri + 1;
+        while (*cp != '\0') {
+                c = *cp++;
+                if (c == '/')
+                        return false;
+        }
+
+        return true;
+}
+
+static int send_response(int conn_sd, const char *msg)
+{
+        size_t response_size;
+        ssize_t rc;
+
+        response_size = str_size(msg);
+
+        /* Send a canned response. */
+        printf("Send response...\n");
+        rc = send(conn_sd, (void *) msg, response_size, 0);
+        if (rc < 0) {
+                printf("send() failed.\n");
+                return rc;
+        }
+
+        return EOK;
+}
+
+static int uri_get(const char *uri, int conn_sd)
+{
+        int rc;
+        char *fname;
+        int fd;
+        ssize_t nr;
+
+        if (str_cmp(uri, "/") == 0)
+                uri = "/index.htm";
+
+        rc = asprintf(&fname, "%s%s", WEB_ROOT, uri);
+        if (rc < 0)
+                return ENOMEM;
+
+        fd = open(fname, O_RDONLY);
+        if (fd < 0) {
+                printf("File '%s' not found.\n", fname);
+                free(fname);
+                return ENOENT;
+        }
+
+        free(fname);
+
+        rc = send_response(conn_sd, ok_msg);
+        if (rc != EOK)
+                return rc;
+
+        while (true) {
+                nr = read(fd, fbuf, BUFFER_SIZE);
+                if (nr == 0)
+                        break;
+
+                if (nr < 0) {
+                        close(fd);
+                        return EIO;
+                }
+
+                rc = send(conn_sd, fbuf, nr, 0);
+                if (rc < 0) {
+                        printf("send() failed\n");
+                        close(fd);
+                        return rc;
+                }
+        }
+
+        close(fd);
+
+        return EOK;
+}
+
+static int req_process(int conn_sd)
+{
+        int rc;
+        char *uri, *end_uri;
+
+        rc = recv_line(conn_sd);
+        if (rc != EOK) {
+                printf("recv_line() failed\n");
+                return rc;
+        }
+
+        printf("%s", lbuf);
+
+        if (str_lcmp(lbuf, "GET ", 4) != 0) {
+                printf("Invalid HTTP method.\n");
+                return EINVAL;
+        }
+
+        uri = lbuf + 4;
+        end_uri = str_chr(uri, ' ');
+        if (end_uri == NULL) {
+                end_uri = lbuf + lbuf_used - 2;
+                assert(*end_uri == '\r');
+        }
+
+        *end_uri = '\0';
+        printf("Requested URI '%s'.\n", uri);
+
+        if (!uri_is_valid(uri)) {
+                printf("Invalid request URI.\n");
+                return EINVAL;
+        }
+
+        return uri_get(uri, conn_sd);
+}
 
 int main(int argc, char *argv[])
@@ -64 +251 @@
         int rc;
 
-        size_t response_size;
 
         addr.sin_family = AF_INET;
@@ -94 +280 @@
                 return 1;
         }
-
-        response_size = str_size(response_msg);
 
         printf("Listening for connections at port number %u.\n", PORT_NUMBER);
@@ -105 +289 @@
                 if (conn_sd < 0) {
                         printf("accept() failed.\n");
-                        return 1;
+                        continue;
                 }
 
@@ -111 +295 @@
 
                 printf("Wait for client request\n");
-
-                /* Really we should wait for a blank line. */
-                rc = recv(conn_sd, buf, BUFFER_SIZE, 0);
-                if (rc < 0) {
-                        printf("recv() failed\n");
-                        return 1;
-                }
-
-                /* Send a canned response. */
-                printf("Send response...\n");
-                rc = send(conn_sd, (void *) response_msg, response_size, 0);
-                if (rc < 0) {
-                        printf("send() failed.\n");
-                        return 1;
-                }
+                rbuf_out = rbuf_in = 0;
+
+                rc = req_process(conn_sd);
+                if (rc != EOK) 
+                        printf("Error processing request.\n");
 
                 rc = closesocket(conn_sd);
                 if (rc != EOK) {
                         printf("Error closing connection socket: %d\n", rc);
+                        closesocket(listen_sd);
                         return 1;
                 }