Exemplo n.º 1
0
/*!
 * @brief Push a bstring to the end of a list
 */
int bstrListPush(struct bstrList *sl, bstring bs)
{
    if (sl->qty == sl->mlen) {
        if ((bstrListAlloc(sl, sl->qty + 1)) != BSTR_OK)
            return BSTR_ERR;
    }

    sl->entry[sl->qty] = bs;
    sl->qty++;
    return BSTR_OK;
}
Exemplo n.º 2
0
/*!
 * @brief Create an empty list with preallocated storage for at least 'min' members
 */
struct bstrList *bstrListCreateMin(int min)
{
    struct bstrList *sl = NULL;

    if ((sl = bstrListCreate()) == NULL)
        return NULL;

    if ((bstrListAlloc(sl, min)) != BSTR_OK) {
        bstrListDestroy(sl);
        return NULL;
    }

    return sl;
}
Exemplo n.º 3
0
char *test_Request_speeds()
{
    int i = 0;
    FILE *infile = fopen("tests/request_payloads.txt", "r");
    mu_assert(infile != NULL, "Failed to open the tests/request_payloads.txt test file.");
    struct bstrList *list = bstrListCreate();
    bstrListAlloc(list, 300);

    // load up all the ones we can
    for(i = 0; i < 300; i++, list->qty++) {
        bstring sender = bgets((bNgetc)fgetc, infile, ' ');
        bstring conn_id = bgets((bNgetc)fgetc, infile, ' ');
        bstring path = bgets((bNgetc)fgetc, infile, ' ');
        list->entry[i] = bgets((bNgetc)fgetc, infile, '\n');

        // stop if we didn't read anything
        if(!(sender && conn_id && path)) break;

        bdestroy(sender);
        bdestroy(conn_id);
        bdestroy(path);
    }

    fclose(infile);


    // now rip through and parse them for speed test
    int j = 0;
    for(j = 0; j < 200; j++) {
        for(i = 0; i < list->qty; i++) {
            tns_value_t *val = tns_parse(bdata(list->entry[i]), blength(list->entry[i]), NULL);
            mu_assert(val->type == tns_tag_string || val->type == tns_tag_dict, "Got an invalid data chunk from file.");

            size_t len = 0;
            char *payload = tns_render(val, &len);
            mu_assert(len > 0, "Failed to render the payload.");

            free(payload);
            tns_value_destroy(val);
        }
    }

    bstrListDestroy(list);
    return NULL;
}
Exemplo n.º 4
0
/**
 * The caller owns the key, and this function will duplicate it
 * if needed.  This function owns the value and will destroy it
 * if there's an error.
 */
void Request_set(Request *req, bstring key, bstring val, int replace)
{
    hnode_t *n = hash_lookup(req->headers, key);
    struct bstrList *val_list = NULL;
    int rc = 0;
    int i = 0;

    if(n == NULL) {
        // make a new bstring list to use as our storage
        val_list = bstrListCreate();
        rc = bstrListAlloc(val_list, MAX_DUPE_HEADERS);
        check(rc == BSTR_OK, "Couldn't allocate space for header values.");

        val_list->entry[0] = val;
        val_list->qty = 1;
        hash_alloc_insert(req->headers, bstrcpy(key), val_list);
    } else {
        val_list = hnode_get(n);
        check(val_list != NULL, "Malformed request, missing bstrlist in node. Tell Zed: %s=%s", bdata(key), bdata(val));

        if(replace) {
            // destroy ALL old ones and put this in their place
            for(i = 0; i < val_list->qty; i++) {
                bdestroy(val_list->entry[i]);
            }

            val_list->entry[0] = val;
            val_list->qty = 1;
        } else {
            check(val_list->qty < MAX_DUPE_HEADERS, 
                    "Header %s duplicated more than %d times allowed.", 
                    bdata(key), MAX_DUPE_HEADERS);

            val_list->entry[val_list->qty++] = val;
        }
    }

    return;

error:
    bdestroy(val);
    return;
}
Exemplo n.º 5
0
static int add_to_hash(hash_t *hash, bstring key, bstring val)
{
    struct bstrList *val_list = NULL;
    int rc = 0;

    // make a new bstring list to use as our storage
    val_list = bstrListCreate();
    rc = bstrListAlloc(val_list, 1);
    check(rc == BSTR_OK, "Couldn't allocate space in hash.");

    val_list->entry[0] = val;
    val_list->qty = 1;
    hash_alloc_insert(hash, bstrcpy(key), val_list);

    return 0;

error:
    return -1;
}