Exemple #1
0
/* read an array */
static amf0_data * amf0_array_read(read_proc_t read_proc, void * user_data) {
    size_t i;
    amf0_data * element;
    amf0_data * data = amf0_array_new();
    if (data != NULL) {
        uint32_t array_size;
        if (read_proc(&array_size, sizeof(uint32_t), user_data) == sizeof(uint32_t)) {
            array_size = swap_uint32(array_size);
            
            for (i = 0; i < array_size; ++i) {
                element = amf0_data_read(read_proc, user_data);

                if (element != NULL) {
                    if (amf0_array_push(data, element) == NULL) {
                        amf0_data_free(element);
                        amf0_data_free(data);
                        return NULL;
                    }
                }
                else {
                    amf0_data_free(data);
                    return NULL;
                }
            }
        }
        else {
            amf0_data_free(data);
            return NULL;
        }
    }
    return data;
}
Exemple #2
0
/* read an object */
static amf0_data * amf0_object_read(read_proc_t read_proc, void * user_data) {
    amf0_data * data = amf0_object_new();
    if (data != NULL) {
        amf0_data * name;
        amf0_data * element;
        while (1) {
            name = amf0_string_read(read_proc, user_data);
            if (name != NULL) {
                element = amf0_data_read(read_proc, user_data);
                if (element != NULL) {
                    if (amf0_object_add(data, (char *)amf0_string_get_uint8_ts(name), element) == NULL) {
                        amf0_data_free(name);
                        amf0_data_free(element);
                        amf0_data_free(data);
                        return NULL;
                    }
                }
                else {
                    amf0_data_free(name);
                    break;
                }
            }
            else {
                /* invalid name: error */
                amf0_data_free(data);
                return NULL;
            }
        }
    }
    return data;
}
Exemple #3
0
/* read an associative array */
static amf0_data * amf0_associative_array_read(read_proc_t read_proc, void * user_data) {
    amf0_data * name;
    amf0_data * element;
    uint32_t size;
    uint8_t error_code;
    amf0_data * data;

    data = amf0_associative_array_new();
    if (data == NULL) {
        return NULL;
    }

    /* we ignore the 32 bits array size marker */
    if (read_proc(&size, sizeof(uint32_t), user_data) < sizeof(uint32_t)) {
        amf0_data_free(data);
        return amf0_data_error(AMF0_ERROR_EOF);
    }

    while(1) {
        name = amf0_string_read(read_proc, user_data);
        error_code = amf0_data_get_error(name);
        if (error_code != AMF0_ERROR_OK) {
            /* invalid name: error */
            amf0_data_free(name);
            amf0_data_free(data);
            return amf0_data_error(error_code);
        }

        element = amf0_data_read(read_proc, user_data);
        error_code = amf0_data_get_error(element);

        if (amf0_string_get_size(name) == 0 || error_code == AMF0_ERROR_END_TAG || error_code == AMF0_ERROR_UNKNOWN_TYPE) {
            /* end tag or unknown element: end of data, exit loop */
            amf0_data_free(name);
            amf0_data_free(element);
            break;
        }
        else if (error_code != AMF0_ERROR_OK) {
            amf0_data_free(name);
            amf0_data_free(data);
            amf0_data_free(element);
            return amf0_data_error(error_code);
        }

        if (amf0_associative_array_add(data, (char *)amf0_string_get_bytes(name), element) == NULL) {
            amf0_data_free(name);
            amf0_data_free(element);
            amf0_data_free(data);
            return NULL;
        }
        else {
            amf0_data_free(name);
        }
    }

    return data;
}
Exemple #4
0
/* read an object */
static amf0_data * amf0_object_read(read_proc_t read_proc, void * user_data) {
    amf0_data * name;
    amf0_data * element;
    uint8_t error_code;
    amf0_data * data;

    data = amf0_object_new();
    if (data == NULL) {
        return NULL;
    }

    while (1) {
        name = amf0_string_read(read_proc, user_data);
        error_code = amf0_data_get_error(name);
        if (error_code != AMF0_ERROR_OK) {
            /* invalid name: error */
            amf0_data_free(name);
            amf0_data_free(data);
            return amf0_data_error(error_code);
        }

        element = amf0_data_read(read_proc, user_data);
        error_code = amf0_data_get_error(element);
        if (error_code == AMF0_ERROR_END_TAG || error_code == AMF0_ERROR_UNKNOWN_TYPE) {
            /* end tag or unknown element: end of data, exit loop */
            amf0_data_free(name);
            amf0_data_free(element);
            break;
        }
        else if (error_code != AMF0_ERROR_OK) {
            amf0_data_free(name);
            amf0_data_free(data);
            amf0_data_free(element);
            return amf0_data_error(error_code);
        }

        if (amf0_object_add(data, (char *)amf0_string_get_bytes(name), element) == NULL) {
            amf0_data_free(name);
            amf0_data_free(element);
            amf0_data_free(data);
            return NULL;
        }
        else {
            amf0_data_free(name);
        }
    }

    return data;
}
Exemple #5
0
/* read an associative array */
static amf0_data * amf0_associative_array_read(read_proc_t read_proc, void * user_data) {
    amf0_data * data = amf0_associative_array_new();
    if (data != NULL) {
        amf0_data * name;
        amf0_data * element;
        uint32_t size;
        if (read_proc(&size, sizeof(uint32_t), user_data) == sizeof(uint32_t)) {
            /* we ignore the 32 bits array size marker */
            while(1) {
                name = amf0_string_read(read_proc, user_data);
                if (name != NULL) {
                    element = amf0_data_read(read_proc, user_data);
                    if (element != NULL) {
                        if (amf0_associative_array_add(data, (char *)amf0_string_get_uint8_ts(name), element) == NULL) {
                            amf0_data_free(name);
                            amf0_data_free(element);
                            amf0_data_free(data);
                            return NULL;
                        }
                    }
                    else {
                        amf0_data_free(name);
                        break;
                    }
                }
                else {
                    /* invalid name: error */
                    amf0_data_free(data);
                    return NULL;
                }
            }
        }
        else {
            amf0_data_free(data);
            return NULL;
        }
    }
    return data;
}
Exemple #6
0
/* read an array */
static amf0_data * amf0_array_read(read_proc_t read_proc, void * user_data) {
    size_t i;
    amf0_data * element;
    uint8_t error_code;
    amf0_data * data;
    uint32_t array_size;

    data = amf0_array_new();
    if (data == NULL) {
        return NULL;
    }

    if (read_proc(&array_size, sizeof(uint32_t), user_data) < sizeof(uint32_t)) {
        amf0_data_free(data);
        return amf0_data_error(AMF0_ERROR_EOF);
    }

    array_size = swap_uint32(array_size);

    for (i = 0; i < array_size; ++i) {
        element = amf0_data_read(read_proc, user_data);
        error_code = amf0_data_get_error(element);
        if (error_code != AMF0_ERROR_OK) {
            amf0_data_free(element);
            amf0_data_free(data);
            return amf0_data_error(error_code);
        }

        if (amf0_array_push(data, element) == NULL) {
            amf0_data_free(element);
            amf0_data_free(data);
            return NULL;
        }
    }

    return data;
}
Exemple #7
0
/* load AMF data from a file stream */
amf0_data * amf0_data_file_read(FILE * stream) {
    return amf0_data_read(file_read, stream);
}
Exemple #8
0
/* read AMF data from buffer */
amf0_data * amf0_data_buffer_read(uint8_t * buffer, size_t maxbytes) {
    buffer_context ctxt;
    ctxt.start_address = ctxt.current_address = buffer;
    ctxt.buffer_size = maxbytes;
    return amf0_data_read(buffer_read, &ctxt);
}