static void handle_variable_integer(const char *data, size_t size) { char buf[UINT64_DEC_BUFLEN]; print_uint64(buf, sizeof buf, peek_variable_integer(data, size)); printf(": %s", buf); }
/* * print uint64_t */ void print_uint64(uint64_t u) { const char *_hex = "0123456789ABCDEF"; if (u >= 10) print_uint64(u/10); putchar(_hex[u%10]); }
LIBCOUCHBASE_API bool libcouchbase_packet_debug(libcouchbase_t instance, const void *ptr) { (void)instance; const protocol_binary_request_header *req = ptr; assert((req->request.magic == PROTOCOL_BINARY_REQ) || (req->request.magic == PROTOCOL_BINARY_RES)); print_header(); dump_bytes((void*)req, ntohl(req->request.bodylen) + sizeof(*req)); printf("\n\nHeader breakdown\n"); printf("Field (offset) (value)\n"); printf("Magic (0): 0x%02x (%s)\n", req->request.magic, req->request.magic == PROTOCOL_BINARY_REQ ? "PROTOCOL_BINARY_REQ" : "PROTOCOL_BINARY_RES"); printf("Opcode (1): 0x%02x (%s)\n", req->request.opcode, get_command_name(req->request.opcode)); printf("Key length (2-3): "); print_uint16(req->request.keylen, true, true); printf("Extra length (4): 0x%02x\n", req->request.extlen); printf("Data type (5): 0x%02x\n", req->request.datatype); if (req->request.magic == PROTOCOL_BINARY_REQ) { printf("vbucket (6-7): "); print_uint16(req->request.vbucket, true, true); } else { printf("Status (6-7): "); print_uint16(req->request.vbucket, false, false); printf(" (%s)\n", get_response_name(req->request.vbucket)); } printf("Total body (8-11): "); print_uint32(req->request.bodylen, true, true); printf("Opaque (12-15): "); print_uint32(req->request.opaque, true, true); printf("CAS (16-23): "); print_uint64(req->request.cas, true, true); if (req->request.magic == PROTOCOL_BINARY_REQ) { if (packets[req->request.opcode].req != NULL) { packets[req->request.opcode].req((void*)req); } } else { if (packets[req->request.opcode].res != NULL) { packets[req->request.opcode].res((void*)req); } } return true; }
int http_send_content_length_header(http_t *ctx) { if ((uint64_t) -1 != ctx->content_length) { static const char length_hdr[] = "Content-Length: "; char buf[UINT64_DEC_BUFLEN]; http_send_data(ctx, length_hdr, sizeof length_hdr - 1); if (ctx->content_length > (uint32_t) -1) { print_uint64(buf, sizeof buf, ctx->content_length); } else { print_uint32(buf, sizeof buf, ctx->content_length); } return http_send_line(ctx, buf); } return 0; }
char * TIGEREnd(tiger_context_t *tp, char *buf) { int i; if (buf == NULL && (buf = malloc(41)) == NULL) { return NULL; } if (tp->first_time) TIGERUpdate(tp, NULL, 0); for (i = 0; i < 3; ++i) print_uint64(buf + i * 16, tp->ctx[i]); buf[16 * i] = '\0'; return buf; }
void print_fxpt_freq(u2_fxpt_freq_t v) { if (v < 0){ v = -v; putchar('-'); } int64_t int_part = v >> 20; int32_t frac_part = v & ((1 << 20) - 1); #if 0 // would work, if we had it printf("%lld.%03d", int_part, (frac_part * 1000) >> 20); #else print_uint64(int_part); print_thousandths((frac_part * 1000) >> 20); #endif }
/********************************************************************** * Description: * Prints Formatted strings for STD out. Format specifiers * provide what type of data to be printed and the data value is taken * from the argument list. * * Input: * One or more Formatted string messages to be printed allong with * other data values to be printed. * * Output: * Number of characters actually printed. -1 if failure. *********************************************************************/ int printk(char *fmt, ...) { va_list arg; int ret = 0; uint32_t val; uint64_t val64; //Check if valid putc() is registered. if (_putc == NULL) return -1; // Variable argument processing va_start(arg, fmt); // Till the end of string while(*fmt != '\0') { // Format the data to be printed if(*fmt == '%') { fmt++; switch(*fmt) { case 'd': // Print the integer val = va_arg(arg,int); ret += print_int32((int)val); break; case 'x': // Print Hex val = va_arg(arg, uint32_t); ret += print_hex32(val, 1); break; case 'c': // Print the char val = va_arg(arg, int); _putc((char)val); ret++; break; case 'u': // Print unsigned int val = va_arg(arg, uint32_t); ret += print_uint32(val); break; case 's': // Print the string val = va_arg(arg, uint32_t); ret += print_string((char*)val); break; case 'l': // Long data switch(*(++fmt)) { case 'u': val64 = va_arg(arg, uint64_t); ret += print_uint64(val64); break; case 'd': val64 = va_arg(arg, int64_t); ret += print_int64(val64); break; case 'x': val64 = va_arg(arg, uint64_t); ret += print_hex64(val64); break; default: val64 = va_arg(arg, int64_t); ret += print_int64(val64); break; } break; default: _putc(*fmt); ret++; break; } } else {
static void debug_tap_connect_request(protocol_binary_request_header *req) { if (req->request.extlen < sizeof(uint32_t)) { printf("Unknown extras field\n"); return ; } int nextbyte = sizeof(*req); protocol_binary_request_tap_connect *t = (void*)req; printf("Flags (%02d-%02d): ", nextbyte, nextbyte + (int)sizeof(t->message.body.flags) - 1); print_uint32(t->message.body.flags, false, true); nextbyte += sizeof(t->message.body.flags); char buffer[1024]; buffer[0] = '\0'; uint32_t flags = ntohl(t->message.body.flags); if (flags & TAP_CONNECT_FLAG_BACKFILL) { strcat(buffer, ", backfill"); } if (flags & TAP_CONNECT_FLAG_DUMP) { strcat(buffer, ", dump"); } if (flags & TAP_CONNECT_FLAG_LIST_VBUCKETS) { strcat(buffer, ", list vbuckets"); } if (flags & TAP_CONNECT_FLAG_TAKEOVER_VBUCKETS) { strcat(buffer, ", takeover vbuckets"); } if (flags & TAP_CONNECT_SUPPORT_ACK) { strcat(buffer, ", support ack"); } if (flags & TAP_CONNECT_REQUEST_KEYS_ONLY) { strcat(buffer, ", request keys only"); } if (buffer[0] != '\0') { printf(" %s\n", buffer + 2); } uint8_t *ptr = (void*)(t->bytes + sizeof(t->bytes)); uint16_t keylen = ntohs(req->request.keylen); if (keylen > 0) { printf("Name (%02d-%02d): [", nextbyte, nextbyte + keylen - 1); print_string((void*)ptr, (size_t)keylen); printf("]\n"); nextbyte += keylen; ptr += keylen; } if (flags & TAP_CONNECT_FLAG_BACKFILL) { uint64_t backfill; memcpy(&backfill, ptr, sizeof(backfill)); printf("Backfill date(%02d-%02d): ", nextbyte, nextbyte + (int)sizeof(backfill) - 1); print_uint64(backfill, true, true); nextbyte += sizeof(backfill); ptr += sizeof(backfill); } if (flags & TAP_CONNECT_FLAG_LIST_VBUCKETS) { uint16_t num; uint16_t val; memcpy(&val, ptr, sizeof(val)); num = ntohs(val); printf("VBucket list (%02d-%02d): \n", nextbyte, nextbyte + (2 * num) + 1); printf(" # listed (%02d-%02d): ", nextbyte, nextbyte + (int)sizeof(num) - 1); print_uint16(val, true, true); nextbyte += sizeof(num); ptr += sizeof(num); for (uint16_t ii = 0; ii < num; ++ii) { memcpy(&val, ptr, sizeof(num)); if (ii < 5 || num < 10) { printf(" vbucket (%02d-%02d): ", nextbyte, nextbyte + (int)sizeof(val) - 1); print_uint16(val, true, true); } else if (ii == num - 1) { printf(" (skipped %d)\n", num - 5); } nextbyte += sizeof(val); ptr += sizeof(val); } } fflush(stdout); }