Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset da0fef6 in mainline


Ignore:
Timestamp:
2012-06-23T18:24:21Z (8 years ago)
Author:
Sean Bartell <wingedtachikoma@…>
Branches:
master
Children:
03b2b2c
Parents:
d5070ef
Message:

Bithenge: port to Linux and allow choosing a data source

Location:
uspace/app/bithenge
Files:
5 added
9 edited
2 moved

Legend:

Unmodified
Added
Removed
  • uspace/app/bithenge/Makefile

    rd5070ef rda0fef6  
    2929USPACE_PREFIX = ../..
    3030LIBS = $(LIBBLOCK_PREFIX)/libblock.a
    31 EXTRA_CFLAGS = -I$(LIBBLOCK_PREFIX)
     31EXTRA_CFLAGS = -I$(LIBBLOCK_PREFIX) -D__HELENOS__ -Ihelenos
    3232BINARY = bithenge
    3333
    3434SOURCES = \
     35        helenos/block.c \
    3536        blob.c \
    36         block.c \
    3737        file.c \
    3838        print.c \
     39        source.c \
    3940        test.c \
    4041        transform.c \
  • uspace/app/bithenge/blob.c

    rd5070ef rda0fef6  
    3636
    3737#include <assert.h>
    38 #include <bool.h>
    3938#include <errno.h>
    40 #include <macros.h>
    41 #include <mem.h>
    4239#include <stdlib.h>
    4340#include "blob.h"
     41#include "os.h"
    4442#include "tree.h"
    4543
     
    215213        memory_blob_t *blob = memory_from_blob(base);
    216214        if (blob->needs_free)
    217                 free(blob->buffer);
     215                free((void *)blob->buffer);
    218216        free(blob);
    219217        return EOK;
     
    272270 * destroyed.
    273271 * @param len The length of the data.
    274  * @param needs_free Whether the buffer should be freed with free() when the
    275  * blob is destroyed.
     272 * @param needs_free If true, the buffer will be freed with free() if this
     273 * function fails or the blob is destroyed.
    276274 * @return EOK on success or an error code from errno.h. */
    277275int bithenge_new_blob_from_buffer(bithenge_node_t **out, const void *buffer,
  • uspace/app/bithenge/file.c

    rd5070ef rda0fef6  
    3939#include <errno.h>
    4040#include <fcntl.h>
    41 #include <macros.h>
    4241#include <stdio.h>
    4342#include <stdlib.h>
    4443#include <sys/stat.h>
     44#include <sys/types.h>
     45#include <unistd.h>
    4546#include "blob.h"
    4647#include "file.h"
     48#include "os.h"
    4749
    4850typedef struct {
     
    7678        if (offset > blob->size)
    7779                return ELIMIT;
    78         *size = min(*size, blob->size - offset);
    79         int rc = lseek(blob->fd, offset, SEEK_SET);
    80         if (rc != EOK)
    81                 return rc;
    82         return read(blob->fd, buffer, *size);
     80        if (lseek(blob->fd, offset, SEEK_SET) < 0)
     81                return errno;
     82
     83        ssize_t amount_read;
     84        aoff64_t remaining_size = *size;
     85        *size = 0;
     86        do {
     87                amount_read = read(blob->fd, buffer, remaining_size);
     88                if (amount_read < 0)
     89                        return errno;
     90                buffer += amount_read;
     91                *size += amount_read;
     92                remaining_size -= amount_read;
     93        } while (remaining_size && amount_read);
     94        return EOK;
    8395}
    8496
     
    125137        }
    126138        blob->fd = fd;
     139#ifdef __HELENOS__
    127140        blob->size = stat.size;
     141#else
     142        blob->size = stat.st_size;
     143#endif
    128144        blob->needs_close = needs_close;
    129145        *out = bithenge_blob_as_node(blob_from_file(blob));
  • uspace/app/bithenge/helenos/block.c

    rd5070ef rda0fef6  
    4242#include <macros.h>
    4343#include <stdlib.h>
    44 #include "blob.h"
     44#include "../blob.h"
    4545#include "block.h"
    4646
  • uspace/app/bithenge/helenos/block.h

    rd5070ef rda0fef6  
    3939
    4040#include <loc.h>
    41 #include "blob.h"
     41#include "../blob.h"
    4242
    4343int bithenge_new_block_blob(bithenge_node_t **, service_id_t);
  • uspace/app/bithenge/print.c

    rd5070ef rda0fef6  
    104104static int print_string(bithenge_print_type_t type, bithenge_node_t *node)
    105105{
    106         size_t off = 0;
    107106        const char *value = bithenge_string_node_value(node);
    108         wchar_t ch;
    109107        printf("\"");
    110         while ((ch = str_decode(value, &off, STR_NO_LIMIT)) != 0) {
     108        for (string_iterator_t i = string_iterator(value); !string_iterator_done(&i); ) {
     109                wchar_t ch;
     110                int rc = string_iterator_next(&i, &ch);
     111                if (rc != EOK)
     112                        return rc;
    111113                if (ch == '"' || ch == '\\') {
    112114                        printf("\\%lc", (wint_t) ch);
     
    134136                        return rc;
    135137                for (aoff64_t i = 0; i < size; i++)
    136                         printf("\\x%02x", buffer[i]);
     138                        printf("\\x%02x", (unsigned int)(uint8_t)buffer[i]);
    137139                pos += size;
    138140        } while (size == sizeof(buffer));
  • uspace/app/bithenge/test.c

    rd5070ef rda0fef6  
    3535 */
    3636
    37 #include <loc.h>
     37#include <errno.h>
    3838#include <stdio.h>
     39#include <stdlib.h>
    3940#include <sys/types.h>
    4041#include "blob.h"
    41 #include "block.h"
    42 #include "file.h"
     42#include "source.h"
    4343#include "print.h"
    4444#include "tree.h"
    4545
    46 static void
    47 print_data(const char *data, size_t len)
    48 {
    49         while (len--)
    50                 printf("%02x ", (uint8_t)(*data++));
    51         printf("\n");
    52 }
    53 
    54 static void
    55 print_blob(bithenge_node_t *node)
    56 {
    57         bithenge_blob_t *blob = bithenge_node_as_blob(node);
    58         aoff64_t size;
    59         bithenge_blob_size(blob, &size);
    60         printf("Size: %d; ", (int)size);
    61         char buffer[64];
    62         size = sizeof(buffer);
    63         bithenge_blob_read(blob, 0, buffer, &size);
    64         print_data(buffer, size);
    65 }
    66 
    6746int main(int argc, char *argv[])
    6847{
    69         bithenge_node_t *node;
    70 
    71         service_id_t service_id;
    72         loc_service_get_id("bd/initrd", &service_id, 0);
    73         bithenge_new_block_blob(&node, service_id);
    74         printf("Data from block:bd/initrd: ");
    75         print_blob(node);
    76         bithenge_node_destroy(node);
    77 
    78         const char data[] = "'Twas brillig, and the slithy toves";
    79         bithenge_new_blob_from_data(&node, data, sizeof(data));
    80         printf("Data from memory (from_data): ");
    81         print_blob(node);
    82         bithenge_node_destroy(node);
    83 
    84         bithenge_new_blob_from_buffer(&node, data, sizeof(data), false);
    85         printf("Data from memory (from_buffer): ");
    86         print_blob(node);
    87         bithenge_node_destroy(node);
    88 
    89         bithenge_new_file_blob(&node, "/textdemo");
    90         printf("Data from file:/textdemo: ");
    91         print_blob(node);
    92         bithenge_node_destroy(node);
    93 
    94         bithenge_new_file_blob_from_fd(&node, 0);
    95         printf("Data from fd:0: ");
    96         print_blob(node);
    97         bithenge_node_destroy(node);
    98 
    99         // {True: {}, -1351: "\"false\"", "true": False, 0: b"..."}
    100         bithenge_node_t *nodes[8];
    101         bithenge_new_boolean_node(&nodes[0], true);
    102         bithenge_new_simple_internal_node(&nodes[1], NULL, 0, false);
    103         bithenge_new_integer_node(&nodes[2], -1351);
    104         bithenge_new_string_node(&nodes[3], "\"false\"", false);
    105         bithenge_new_string_node(&nodes[4], "true", false);
    106         bithenge_new_boolean_node(&nodes[5], false);
    107         bithenge_new_integer_node(&nodes[6], 0);
    108         bithenge_new_blob_from_data(&nodes[7], data, sizeof(data));
    109         bithenge_new_simple_internal_node(&node, nodes, 4, false);
    110         bithenge_print_node(BITHENGE_PRINT_PYTHON, node);
    111         printf("\n");
    112         bithenge_print_node(BITHENGE_PRINT_JSON, node);
    113         printf("\n");
    114         bithenge_node_destroy(node);
     48        if (argc < 2) {
     49                // {True: {}, -1351: "\"false\"", "true": False, 0: b"..."}
     50                const char data[] = "'Twas brillig, and the slithy toves";
     51                bithenge_node_t *node;
     52                bithenge_node_t *subnodes[8];
     53                bithenge_new_boolean_node(&subnodes[0], true);
     54                bithenge_new_simple_internal_node(&subnodes[1], NULL, 0, false);
     55                bithenge_new_integer_node(&subnodes[2], -1351);
     56                bithenge_new_string_node(&subnodes[3], "\"false\"", false);
     57                bithenge_new_string_node(&subnodes[4], "true", false);
     58                bithenge_new_boolean_node(&subnodes[5], false);
     59                bithenge_new_integer_node(&subnodes[6], 0);
     60                bithenge_new_blob_from_data(&subnodes[7], data, sizeof(data));
     61                bithenge_new_simple_internal_node(&node, subnodes, 4, false);
     62                bithenge_print_node(BITHENGE_PRINT_PYTHON, node);
     63                printf("\n");
     64                bithenge_print_node(BITHENGE_PRINT_JSON, node);
     65                printf("\n");
     66                bithenge_node_destroy(node);
     67        } else {
     68                bithenge_node_t *node;
     69                int rc = bithenge_node_from_source(&node, argv[1]);
     70                if (rc != EOK) {
     71                        printf("Error creating node from source: %s\n", str_error(rc));
     72                        return 1;
     73                }
     74                rc = bithenge_print_node(BITHENGE_PRINT_PYTHON, node);
     75                if (rc != EOK) {
     76                        printf("Error printing node: %s\n", str_error(rc));
     77                        return 1;
     78                }
     79                printf("\n");
     80                bithenge_node_destroy(node);
     81        }
    11582
    11683        return 0;
  • uspace/app/bithenge/transform.c

    rd5070ef rda0fef6  
    3535 */
    3636
    37 #include <byteorder.h>
    3837#include <errno.h>
    3938#include "blob.h"
  • uspace/app/bithenge/transform.h

    rd5070ef rda0fef6  
    7575/** Find the length of the prefix of a blob this transform can use as input. In
    7676 * other words, figure out how many bytes this transform will use up.  This
    77  * method is optional and can return an error, but it is required for struct
     77 * method is optional and can return an error, but it must succeed for struct
    7878 * subtransforms.
    7979 * @memberof bithenge_transform_t
  • uspace/app/bithenge/tree.c

    rd5070ef rda0fef6  
    3737#include <errno.h>
    3838#include <stdlib.h>
    39 #include <str.h>
    4039#include "blob.h"
     40#include "os.h"
    4141#include "tree.h"
    4242
     
    5959        case BITHENGE_NODE_STRING:
    6060                if (node->string_value.needs_free)
    61                         free(node->string_value.ptr);
     61                        free((void *)node->string_value.ptr);
    6262                break;
    6363        case BITHENGE_NODE_INTERNAL:
  • uspace/app/bithenge/tree.h

    rd5070ef rda0fef6  
    3939
    4040#include <assert.h>
    41 #include <bool.h>
    4241#include <inttypes.h>
    4342#include <sys/types.h>
     43#include "os.h"
    4444
    4545#ifdef INTMAX_MAX
Note: See TracChangeset for help on using the changeset viewer.