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; }
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); }
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; }
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; }
int qd_field_iterator_length(const qd_field_iterator_t *iter) { qd_field_iterator_t copy = *iter; int length = 0; qd_field_iterator_reset(©); while (!qd_field_iterator_end(©)) { qd_field_iterator_octet(©); length++; } return length; }
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--; } } }
/** 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); } }
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; } }
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; }
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; } }