Пример #1
0
int qd_field_iterator_equal(qd_field_iterator_t *iter, const unsigned char *string)
{
    qd_field_iterator_reset(iter);

    while (!qd_field_iterator_end(iter) && *string) {
        if (*string != qd_field_iterator_octet(iter))
            break;
        string++;
    }

    int match = (qd_field_iterator_end(iter) && (*string == 0));
    qd_field_iterator_reset(iter);
    return match;
}
Пример #2
0
void qd_iterator_hash_segments(qd_field_iterator_t *iter)
{
    // Reset the pointers in the iterator
    qd_field_iterator_reset(iter);
    uint32_t hash = HASH_INIT;
    char octet;
    int segment_length=0;

    while (!qd_field_iterator_end(iter)) {
        // Get the octet at which the iterator is currently pointing to.
        octet = qd_field_iterator_octet(iter);
        segment_length += 1;

        if (octet == SEPARATOR) {
            qd_insert_hash_segment(iter, &hash, segment_length-1);
        }

        hash = ((hash << 5) + hash) + octet; /* hash * 33 + c */
    }

    // Segments should never end with a separator. see view_initialize which in turn calls qd_address_iterator_check_trailing_octet
    // Insert the last segment which was not inserted in the previous while loop
    qd_insert_hash_segment(iter, &hash, segment_length);

    // Return the pointers in the iterator back to the original state before returning from this function.
    qd_field_iterator_reset(iter);
}
Пример #3
0
int qd_field_iterator_ncopy(qd_field_iterator_t *iter, unsigned char* buffer, int n) {
    qd_field_iterator_reset(iter);
    int i = 0;
    while (!qd_field_iterator_end(iter) && i < n)
        buffer[i++] = qd_field_iterator_octet(iter);
    return i;
}
Пример #4
0
uint32_t qd_iterator_hash_function(qd_field_iterator_t *iter)
{
    uint32_t hash = HASH_INIT;

    qd_field_iterator_reset(iter);
    while (!qd_field_iterator_end(iter))
        hash = ((hash << 5) + hash) + (int) qd_field_iterator_octet(iter); /* hash * 33 + c */

    return hash;
}
Пример #5
0
int qd_field_iterator_length(const qd_field_iterator_t *iter)
{
    qd_field_iterator_t copy = *iter;
    int length = 0;
    qd_field_iterator_reset(&copy);
    while (!qd_field_iterator_end(&copy)) {
        qd_field_iterator_octet(&copy);
        length++;
    }
    return length;
}
Пример #6
0
void qd_field_iterator_advance(qd_field_iterator_t *iter, uint32_t length)
{
    while (length > 0 && !qd_field_iterator_end(iter)) {
        if (iter->state == STATE_IN_ADDRESS) {
            field_iterator_move_cursor(iter, length);
            break;
        } else {
            qd_field_iterator_octet(iter);
            length--;
        }
    }
}
Пример #7
0
/** Copy a message field for use in log messages. Output in buffer. */
static void copy_field(qd_message_t *msg,  int field, int max, char *pre, char *post,
                       char **begin, char *end)
{
    qd_field_iterator_t* iter = qd_message_field_iterator(msg, field);
    if (iter) {
        aprintf(begin, end, "%s", pre);
        qd_field_iterator_reset(iter);
        for (int j = 0; !qd_field_iterator_end(iter) && j < max; ++j) {
            char byte = qd_field_iterator_octet(iter);
            quote(&byte, 1, begin, end);
        }
        aprintf(begin, end, "%s", post);
        qd_field_iterator_free(iter);
    }
}
Пример #8
0
static void qd_address_iterator_check_trailing_octet(qd_field_iterator_t *iter, char octet)
{
    // Save the iterator's pointer so we can apply it back before returning from this function.
    pointer_t save_pointer = iter->pointer;

    char current_octet = 0;
    while(!qd_field_iterator_end(iter)) {
        current_octet = qd_field_iterator_octet(iter);
    }

    // We have the last octet in current_octet
    if (current_octet == octet) {
        iter->pointer = save_pointer;
        iter->pointer.length-- ;
    }
    else {
        iter->pointer = save_pointer;
    }
}
Пример #9
0
static PyObject *parsed_to_py_string(qd_parsed_field_t *field)
{
    switch (qd_parse_tag(field)) {
      case QD_AMQP_VBIN8:
      case QD_AMQP_VBIN32:
      case QD_AMQP_STR8_UTF8:
      case QD_AMQP_STR32_UTF8:
      case QD_AMQP_SYM8:
      case QD_AMQP_SYM32:
        break;
      default:
        Py_RETURN_NONE;
    }

#define SHORT_BUF 1024
    uint8_t short_buf[SHORT_BUF];
    PyObject *result;
    qd_field_iterator_t *raw = qd_parse_raw(field);
    qd_field_iterator_reset(raw);
    uint32_t length = qd_field_iterator_remaining(raw);
    uint8_t *buffer = short_buf;
    uint8_t *ptr;
    int alloc = 0;

    if (length > SHORT_BUF) {
        alloc = 1;
        buffer = (uint8_t*) malloc(length);
    }

    ptr = buffer;
    while (!qd_field_iterator_end(raw))
        *(ptr++) = qd_field_iterator_octet(raw);
    result = PyString_FromStringAndSize((char*) buffer, ptr - buffer);
    if (alloc)
        free(buffer);

    return result;
}
Пример #10
0
static void view_initialize(qd_field_iterator_t *iter)
{
    //
    // The default behavior is for the view to *not* have a prefix.
    // We'll add one if it's needed later.
    //
    iter->state       = STATE_IN_ADDRESS;
    iter->view_prefix = false;
    iter->mode        = MODE_TO_END;

    if (iter->view == ITER_VIEW_ALL)
        return;

    //
    // Advance to the node-id.
    //
    state_t        state = STATE_START;
    unsigned int   octet;
    pointer_t      save_pointer = {0,0,0};

    while (!qd_field_iterator_end(iter) && state != STATE_AT_NODE_ID) {
        octet = qd_field_iterator_octet(iter);

        switch (state) {
        case STATE_START :
            if (octet == '/') {
                state = STATE_SLASH_LEFT;
                save_pointer = iter->pointer;
            } else
                state = STATE_SCANNING;
            break;

        case STATE_SLASH_LEFT :
            if (octet == '/')
                state = STATE_SKIPPING_TO_NEXT_SLASH;
            else {
                state = STATE_AT_NODE_ID;
                iter->pointer = save_pointer;
            }
            break;

        case STATE_SKIPPING_TO_NEXT_SLASH :
            if (octet == '/')
                state = STATE_AT_NODE_ID;
            break;

        case STATE_SCANNING :
            if (octet == ':')
                state = STATE_COLON;
            break;

        case STATE_COLON :
            if (octet == '/') {
                state = STATE_COLON_SLASH;
                save_pointer = iter->pointer;
            } else
                state = STATE_SCANNING;
            break;

        case STATE_COLON_SLASH :
            if (octet == '/')
                state = STATE_SKIPPING_TO_NEXT_SLASH;
            else {
                state = STATE_AT_NODE_ID;
                iter->pointer = save_pointer;
            }
            break;

        case STATE_AT_NODE_ID :
            break;
        }
    }

    if (state != STATE_AT_NODE_ID) {
        //
        // The address string was relative, not absolute.  The node-id
        // is at the beginning of the string.
        //
        iter->pointer = iter->start_pointer;
    }

    //
    // Cursor is now on the first octet of the node-id
    //
    if (iter->view == ITER_VIEW_NODE_ID) {
        iter->mode = MODE_TO_SLASH;
        return;
    }

    if (iter->view == ITER_VIEW_NO_HOST) {
        iter->mode = MODE_TO_END;
        return;
    }

    if (iter->view == ITER_VIEW_ADDRESS_HASH) {
        iter->mode = MODE_TO_END;
        qd_address_iterator_check_trailing_octet(iter, SEPARATOR);
        parse_address_view(iter);
        return;
    }

    if (iter->view == ITER_VIEW_NODE_HASH) {
        iter->mode = MODE_TO_END;
        parse_node_view(iter);
        return;
    }

    if (iter->view == ITER_VIEW_NODE_SPECIFIC) {
        iter->mode = MODE_TO_END;
        while (!qd_field_iterator_end(iter)) {
            octet = qd_field_iterator_octet(iter);
            if (octet == '/')
                break;
        }
        return;
    }
}