int main(int argc, char *argv[]) {
MumbleClient::CryptState cs;
// cs.genKey();
cs.setKey(rawkey, encrypt_iv, decrypt_iv);
DumpBytes(cs.raw_key, AES_BLOCK_SIZE, "rawkey");
DumpBytes(cs.encrypt_iv, AES_BLOCK_SIZE, "encrypt_iv");
DumpBytes(cs.decrypt_iv, AES_BLOCK_SIZE, "decrypt_iv");
unsigned char buf[19];
cs.encrypt(msg, &buf[0], 15);
DumpBytes(buf, 19, "crypted");
DumpBytes(cs.encrypt_iv, AES_BLOCK_SIZE, "post_eiv");
}
/**
* AN495 - 5.7 - Transfer Status Response
* Report Id: 0x16
* Direction: Interrupt In
* Parameters:
* Status 0 - Offset 1 - Size 1 - 0x00 = Idle, 0x01 = Busy, 0x02 = Complete, 0x03 = Complete with error
* Status 1 - Offset 2 - Size 1 - Specific conditions based on Status 0
* Status 2 - Offset 3 - Size 2 - Number of retries before completing, being cancelled, or timing out
* Status 3 - Offset 5 - Size 2 - Number of received bytes
*/
int HidCP2112_TransferStatusResponse(HID_SMBUS_DEVICE device, BYTE *status0, BYTE *status1, ushort *status2, ushort *status3) {
BYTE data[7];
int retries = 0;
while (retries++ < 300) {
if (GetNextIdFromBuffer(HID_SMBUS_REPORT_ID_TRANSFER_STATUS_RESP, data, sizeof(data))) {
*status0 = data[1];
*status1 = data[2];
*status2 = data[3] << 8 | data[4];
*status3 = data[5] << 8 | data[6];
if (verbose) {
DumpBytes(data, 7);
printf("HID SMBus Transfer Status Response: ");
printf("Status0: " BOLDBLUE "%s" RESET " Status1: " BOLDBLUE "%s" RESET " Status2 (retries): %u Status3 (bytes): %u\n", HidCP2112_Status0_Name(*status0), HidCP2112_Status1_Name(*status0, *status1), *status2, *status3);
}
return LIBUSB_SUCCESS;
} else {
usleep(10 * 1000); // 10ms
}
}
fprintf(stderr, BOLDRED "HidCP2112_TransferStatusResponse: Error receiving interrupt report from buffer, timed out." RESET "\n");
return LIBUSB_ERROR_INVALID_PARAM;
}
/**
* AN495 - 4.4 - Set GPIO Values
* Report Id: 0x04
* Direction: Feature Request Out
* Parameters:
* Latch value - Offset 1 - Size 1 - Latch value
* Latch Mask - Offset 2 - Size 1 - Pin to set to new latch value
*/
int HidCP2112_SetGpioValues(HID_SMBUS_DEVICE device, BYTE latchValue, BYTE latchMask) {
int bytes_transferred;
BYTE data[3];
data[0] = HID_SMBUS_REPORT_ID_SET_GPIO;
data[1] = latchValue;
data[2] = latchMask;
pthread_mutex_lock(&syncRoot);
bytes_transferred = libusb_control_transfer(
device,
CONTROL_REQUEST_TYPE_OUT,
HID_SET_REPORT,
(HID_REPORT_TYPE_FEATURE << 8) | HID_SMBUS_REPORT_ID_SET_GPIO,
INTERFACE,
data,
sizeof(data),
TIMEOUT_MS);
pthread_mutex_unlock(&syncRoot);
if (bytes_transferred > 0) {
if (verbose) {
DumpBytes(data, sizeof(data));
printf("HID SMBus Set GPIO Values: ");
printf("Latch value: %02X Latch Mask: %02X\n", data[1], data[2]);
}
} else {
fprintf(stderr, BOLDRED "HidCP2112_SetGpioValues: Error setting feature report. Bytes transferred: %d" RESET "\n", bytes_transferred);
return bytes_transferred;
}
return LIBUSB_SUCCESS;
}
/**
* AN495 - 4.3 - Get GPIO Values
* Report Id: 0x03
* Direction: Feature Request In
* Parameters:
* Latch Value - Offset 1 - Size 2 - Current latch values (Note: docs say 2 bytes but evidence shows its only 1 byte)
*/
int HidCP2112_GetGpioValues(HID_SMBUS_DEVICE device, BYTE *latchValue) {
int bytes_transferred;
BYTE data[2];
*latchValue = 0;
pthread_mutex_lock(&syncRoot);
bytes_transferred = libusb_control_transfer(
device,
CONTROL_REQUEST_TYPE_IN,
HID_GET_REPORT,
(HID_REPORT_TYPE_FEATURE << 8) | HID_SMBUS_REPORT_ID_GET_GPIO,
INTERFACE,
data,
sizeof(data),
TIMEOUT_MS);
pthread_mutex_unlock(&syncRoot);
if (bytes_transferred > 0) {
//*latchValue = (data[1] << 8) | data[2]; // docs say 2 bytes, leaving this here in case it turns out to be correct
*latchValue = data[1];
if (verbose) {
DumpBytes(data, sizeof(data));
printf("HID SMBus Get GPIO Values: ");
printf("LatchValue: %02X\n", *latchValue);
}
} else {
fprintf(stderr, BOLDRED "HidCP2112_GetGpioValues: Error getting feature report. Bytes transferred: %d" RESET "\n", bytes_transferred);
return bytes_transferred;
}
return LIBUSB_SUCCESS;
}
/**
* AN495 - 5.8 - Cancel Transfer
* Report Id: 0x17
* Direction: Interrupt Out
* Parameters:
* Cancel - Offset 1 - Size 1 - Value 0x01 - Will cancel the current transfer. All other values are ignored.
*/
int HidCP2112_CancelTransfer(HID_SMBUS_DEVICE device) {
int bytes_transferred, success;
int i = 0;
BYTE data[2];
data[0] = HID_SMBUS_REPORT_ID_CANCEL_TRANSFER;
data[1] = 0x01;
pthread_mutex_lock(&syncRoot);
success = libusb_interrupt_transfer(
device,
INTERRUPT_OUT_ENDPOINT,
data,
sizeof(data),
&bytes_transferred,
TIMEOUT_MS);
pthread_mutex_unlock(&syncRoot);
if (bytes_transferred > 0) {
if (verbose) {
DumpBytes(data, sizeof(data));
printf("HID SMBus Cancel Transfer Request:\n");
}
} else {
fprintf(stderr, BOLDRED "HidCP2112_CancelTransfer: Error sending interrupt report. Bytes transferred: %d" RESET "\n", bytes_transferred);
return bytes_transferred;
}
return LIBUSB_SUCCESS;
}
void DumpApRegs (void) {
uint8_t buf[AP_REGFILESZ];
memset (buf,0,sizeof(buf));
// PUTZ_DEBUG_WAIT();
AP_ReadBuffer(0, buf, AP_REGFILESZ);
DumpBytes (buf, sizeof(buf), (const char*)"\r\nAudio Processor Registers:\r\n");
}
/**
* AN495 - 4.1 - Reset Device
* Report Id: 0x01
* Direction: Feature Request Out
* Parameters:
* Reset Type - Offset 1 - Size 1 - Value 0x01
*/
int HidCP2112_Reset(HID_SMBUS_DEVICE device) {
int bytes_transferred;
BYTE data_in[2];
data_in[0] = HID_SMBUS_REPORT_ID_RESET;
data_in[1] = 0x02;
pthread_mutex_lock(&syncRoot);
bytes_transferred = libusb_control_transfer(
device,
CONTROL_REQUEST_TYPE_OUT,
HID_SET_REPORT,
(HID_REPORT_TYPE_FEATURE << 8) | HID_SMBUS_REPORT_ID_RESET,
INTERFACE,
data_in,
sizeof(data_in),
TIMEOUT_MS);
pthread_mutex_unlock(&syncRoot);
if (bytes_transferred == -1) { // special case for reset, success is when the result is -1
if (verbose) {
DumpBytes(data_in, sizeof(data_in));
printf("HID SMBus Reset Success.\n");
}
} else {
fprintf(stderr, BOLDRED "HidCP2112_Reset: Error setting feature report. Bytes transferred: %d" RESET "\n", bytes_transferred);
return bytes_transferred;
}
return LIBUSB_SUCCESS;
}
/**
* AN495 - 5.4 - Data Read Response
* Report Id: 0x13
* Direction: Interrupt In
* Parameters:
* Status - Offset 1 - Size 1 - 0x00 = Idle, 0x01 = Busy, 0x02 = Complete, 0x03 = Complete with error
* Length - Offset 2 - Size 1 - Number of valid data bytes
* Data - Offset 3 - Size 61 - Data being returned from SMBus slave device
*/
int HidCP2112_DataReadResponse(HID_SMBUS_DEVICE device, BYTE *status, BYTE *length, BYTE *dataRead) {
int bytes_transferred, success;
int i = 0, retries = 0;
BYTE data[64];
while (retries++ < 300) {
if (GetNextIdFromBuffer(HID_SMBUS_REPORT_ID_DATA_READ_RESP, data, sizeof(data))) {
*status = data[1];
*length = data[2];
for (i = 0; i < *length; ++i)
dataRead[i] = data[3+i];
if (verbose) {
DumpBytes(data, *length+3);
printf("HID SMBus Data Read Response: ");
printf("Bytes Transferred: %u Status: " BOLDBLUE "%s" RESET " Length: %u DataRead: ", bytes_transferred, HidCP2112_Status0_Name(*status), *length);
for (i = 0; i < *length; ++i)
printf("%02X ", dataRead[i]);
printf("\n");
}
return LIBUSB_SUCCESS;
} else {
usleep(10 * 1000); // 10ms
}
}
fprintf(stderr, BOLDRED "HidCP2112_DataReadResponse: Error receiving interrupt report, timed out. Bytes transferred: %d" RESET "\n", bytes_transferred);
return bytes_transferred;
}
/**
* AN495 - 5.1 - Data Read Request
* Report Id: 0x10
* Direction: Interrupt Out
* Parameters:
* Slave Address - Offset 1 - Size 1 - Must be between 0xF7-0x02. Least significant bit is r/w bit and must be zero.
* Length - Offset 2 - Size 2 - Number of bytes (1-512 bytes) to read back.
*/
int HidCP2112_DataReadRequest(HID_SMBUS_DEVICE device, BYTE slaveAddress, ushort length) {
int bytes_transferred, success;
int i = 0;
BYTE data[4];
data[0] = HID_SMBUS_REPORT_ID_DATA_READ_REQ;
data[1] = slaveAddress;
data[2] = length >> 8;
data[3] = length & 0xFF;
pthread_mutex_lock(&syncRoot);
success = libusb_interrupt_transfer(
device,
INTERRUPT_OUT_ENDPOINT,
data,
sizeof(data),
&bytes_transferred,
TIMEOUT_MS);
pthread_mutex_unlock(&syncRoot);
if (bytes_transferred > 0) {
if (verbose) {
DumpBytes(data, sizeof(data));
printf("HID SMBus Data Read Request: ");
printf("SlaveAddress: %02X Length: %u\n", slaveAddress, length);
}
} else {
fprintf(stderr, BOLDRED "HidCP2112_DataReadRequest: Error sending interrupt report. Bytes transferred: %d" RESET "\n", bytes_transferred);
return bytes_transferred;
}
return LIBUSB_SUCCESS;
}
void DumpableSource::Inspect_(std::ostream& os) const
{
auto flags = os.flags();
os << std::hex << "bin(";
DumpBytes(os, GetFileName().generic_string());
os << ", 0x" << GetOffset() << ", 0x" << GetSize() << ")";
os.flags(flags);
}
void DumpEEPROMBytesCommand(void) {
int length = 32; // Default byte count to display
ParseDumpParameters("dump EEPROM bytes", EepromSize(), &EBaddr, &length);
u8 buf[length];
DwReadEEPROM(EBaddr, length, buf);
DumpBytes(EBaddr, length, buf);
EBaddr += length;
}
void DumpFlashBytesCommand(void) {
int length = 128; // Default byte count to display
ParseDumpParameters("dump flash bytes", FlashSize(), &FBaddr, &length);
u8 buf[length];
DwReadFlash(FBaddr, length, buf);
DumpBytes(FBaddr, length, buf);
FBaddr += length;
}
/**
* AN495 - 4.6 - Get SMBus Configuration
* Report Id: 0x06
* Direction: Feature Request In
* Parameters:
* Clock Speed - Offset 1 - Size 4 - Default Value 0x186A0 (100 KHz) - SMBus clock speed in Hz
* Device Address - Offset 5 - Size 1 - Default 0x02 - Bits 7-1 make up device address (least significant bit is masked)
* Auto Send Read - Offset 6 - Size 1 - Default 0x00 - Disabled / Enabled (0x01)
* Write Timeout - Offset 7 - Size 2 - Default 0x0000 - No timeout - 0-1000ms timeout value
* Read Timeout - Offset 9 - Size 2 - Default 0x0000 - No timeout - 0-1000ms timeout value
* SCL Low Timeout - Offset 11 - Size 1 - Default 0x00 - Disabled / Enabled (0x01)
* Retry Time - Offset 12 - Size 2 - Default 0x0000 - No limit - 0-1000 retries
*/
int HidCP2112_GetSMBusConfig(HID_SMBUS_DEVICE device, uint32_t *clockSpeed, BYTE *deviceAddress, BYTE *autoSendRead, ushort *writeTimeout, ushort *readTimeout, BYTE *sclLowTimeout, ushort *retryTime) {
int bytes_transferred;
int i = 0;
BYTE data[14];
*clockSpeed = 0;
*deviceAddress = 0;
*autoSendRead = 0;
*writeTimeout = 0;
*readTimeout = 0;
*sclLowTimeout = 0;
*retryTime = 0;
pthread_mutex_lock(&syncRoot);
bytes_transferred = libusb_control_transfer(
device,
CONTROL_REQUEST_TYPE_IN,
HID_GET_REPORT,
(HID_REPORT_TYPE_FEATURE << 8) | HID_SMBUS_REPORT_ID_SMBUS_CONFIG,
INTERFACE,
data,
sizeof(data),
TIMEOUT_MS);
pthread_mutex_unlock(&syncRoot);
if (bytes_transferred > 0) {
*clockSpeed = data[1] << 24 | data[2] << 16 | data[3] << 8 | data[4];
*deviceAddress = data[5];
*autoSendRead = data[6];
*writeTimeout = data[7] << 8 | data[8];
*readTimeout = data[9] << 8 | data[10];
*sclLowTimeout = data[11];
*retryTime = data[12] << 8 | data[13];
if (verbose) {
DumpBytes(data, sizeof(data));
printf("HID SMBus Get SMBus Config: ");
printf("ClockSpeed: %u DeviceAddress: %02X AutoSendRead: %02X WriteTimeout: %u ReadTimeout: %u SCL Low Timeout: %02X RetryTime: %u\n", *clockSpeed, *deviceAddress, *autoSendRead, *writeTimeout, *readTimeout, *sclLowTimeout, *retryTime);
}
} else {
fprintf(stderr, BOLDRED "HidCP2112_GetSMBusConfig: Error getting feature report. Bytes transferred: %d" RESET "\n", bytes_transferred);
return bytes_transferred;
}
return LIBUSB_SUCCESS;
}
/**
* AN495 - 4.2 - Get GPIO Configuration
* Report Id: 0x02
* Direction: Feature Request In
* Parameters:
* Direction - Offset 1 - Size 1 - Value 0=input 1=output
* Push-Pull - Offset 2 - Size 1 - Value 0=open-drain 1=push-pull
* Special - Offset 3 - Size 1 - Enables special functions of GPIO pins
* Clock Divider - Offset 4 - Size 1 - 0=48 MHz clock, other values output clock signal determined by equation
*/
int HidCP2112_GetGpioConfig(HID_SMBUS_DEVICE device, BYTE *direction, BYTE *pushPull, BYTE *special, BYTE *clockDivider) {
int bytes_transferred;
BYTE data_out[5];
*direction = 0;
*pushPull = 0;
*special = 0;
*clockDivider = 0;
pthread_mutex_lock(&syncRoot);
bytes_transferred = libusb_control_transfer(
device,
CONTROL_REQUEST_TYPE_IN,
HID_GET_REPORT,
(HID_REPORT_TYPE_FEATURE << 8) | HID_SMBUS_REPORT_ID_GPIO_CONFIG,
INTERFACE,
data_out,
sizeof(data_out),
TIMEOUT_MS);
pthread_mutex_unlock(&syncRoot);
if (bytes_transferred > 0) {
*direction = data_out[1];
*pushPull = data_out[2];
*special = data_out[3];
*clockDivider = data_out[4];
if (verbose) {
DumpBytes(data_out, sizeof(data_out));
printf("HID SMBus Get GPIO Config: ");
printf("Direction: %02X Push-Pull: %02X Special: %02X ClockDivider: %02X\n", data_out[1], data_out[2], data_out[3], data_out[4]);
}
} else {
fprintf(stderr, BOLDRED "HidCP2112_GetGpioConfig: Error getting feature report. Bytes transferred: %d" RESET "\n", bytes_transferred);
return bytes_transferred;
}
return LIBUSB_SUCCESS;
}
/**
* AN495 - 5.5 - Data Write
* Report Id: 0x14
* Direction: Interrupt Out
* Parameters:
* Slave Address - Offset 1 - Size 1 - Must be between 0xF7-0x02. Least significant bit is r/w bit and must be zero.
* Length - Offset 2 - Size 1 - Number of valid data bytes
* Data - Offset 3 - Size 61 - Data being returned from the SMBus slave device
*/
int HidCP2112_DataWrite(HID_SMBUS_DEVICE device, BYTE slaveAddress, BYTE length, BYTE *dataWrite) {
int bytes_transferred, success;
int i = 0;
BYTE data[64];
data[0] = HID_SMBUS_REPORT_ID_DATA_WRITE;
data[1] = slaveAddress;
data[2] = length;
// copy data
for (i = 0; i < length; ++i)
data[3+i] = dataWrite[i];
pthread_mutex_lock(&syncRoot);
success = libusb_interrupt_transfer(
device,
INTERRUPT_OUT_ENDPOINT,
data,
sizeof(data),
&bytes_transferred,
TIMEOUT_MS);
pthread_mutex_unlock(&syncRoot);
if (bytes_transferred > 0) {
if (verbose) {
DumpBytes(data, length+3);
printf("HID SMBus Data Write: ");
printf("SlaveAddress: %02X Length: %u DataWrite: ", slaveAddress, length);
for (i = 0; i < length; ++i)
printf("%02X ", dataWrite[i]);
printf("\n");
}
} else {
fprintf(stderr, BOLDRED "HidCP2112_DataWrite: Error sending interrupt report. Bytes transferred: %d" RESET "\n", bytes_transferred);
return bytes_transferred;
}
return LIBUSB_SUCCESS;
}
/**
* AN495 - 5.3 - Data Read Force Send
* Report Id: 0x12
* Direction: Interrupt Out
* Parameters:
* Length - Offset 1 - Size 2 - Number of valid data bytes
*/
int HidCP2112_DataReadForceSend(HID_SMBUS_DEVICE device, ushort length) {
int bytes_transferred, success;
int i = 0;
BYTE data[3];
data[0] = HID_SMBUS_REPORT_ID_DATA_READ_FORCE_SEND;
data[1] = length >> 8;
data[2] = length & 0xFF;
//time_t lt = time(NULL);
pthread_mutex_lock(&syncRoot);
//int ltot = time(NULL) - lt;
//printf("Took %ds to acquire lock.\n", ltot);
//time_t t1 = time(NULL);
success = libusb_interrupt_transfer(
device,
INTERRUPT_OUT_ENDPOINT,
data,
sizeof(data),
&bytes_transferred,
TIMEOUT_MS);
//int tot = time(NULL) - t1;
//printf("Took %ds to run.\n", tot);
pthread_mutex_unlock(&syncRoot);
if (bytes_transferred > 0) {
if (verbose) {
DumpBytes(data, sizeof(data));
printf("HID SMBus Data Read Force Send: ");
printf("Length: %u\n", length);
}
} else {
fprintf(stderr, BOLDRED "HidCP2112_DataReadForceSend: Error sending interrupt report. Bytes transferred: %d" RESET "\n", bytes_transferred);
return bytes_transferred;
}
return LIBUSB_SUCCESS;
}
/**
* AN495 - 4.2 - Set GPIO Configuration
* Report Id: 0x02
* Direction: Feature Request Out
* Parameters:
* Direction - Offset 1 - Size 1 - Value 0=input 1=output
* Push-Pull - Offset 2 - Size 1 - Value 0=open-drain 1=push-pull
* Special - Offset 3 - Size 1 - Enables special functions of GPIO pins
* Clock Divider - Offset 4 - Size 1 - 0=48 MHz clock, other values output clock signal determined by equation
*/
int HidCP2112_SetGpioConfig(HID_SMBUS_DEVICE device, BYTE direction, BYTE pushPull, BYTE special, BYTE clockDivider) {
int bytes_transferred;
BYTE data[5];
data[0] = HID_SMBUS_REPORT_ID_GPIO_CONFIG;
data[1] = direction;
data[2] = pushPull;
data[3] = special;
data[4] = clockDivider;
pthread_mutex_lock(&syncRoot);
bytes_transferred = libusb_control_transfer(
device,
CONTROL_REQUEST_TYPE_OUT,
HID_SET_REPORT,
(HID_REPORT_TYPE_FEATURE << 8) | HID_SMBUS_REPORT_ID_GPIO_CONFIG,
INTERFACE,
data,
sizeof(data),
TIMEOUT_MS);
pthread_mutex_unlock(&syncRoot);
if (bytes_transferred > 0) {
if (verbose) {
DumpBytes(data, sizeof(data));
printf("HID SMBus Set GPIO Config: ");
printf("Direction: %02X Push-Pull: %02X Special: %02X ClockDivider: %02X\n", data[1], data[2], data[3], data[4]);
}
} else {
fprintf(stderr, BOLDRED "HidCP2112_GetGpioConfig: Error setting feature report. Bytes transferred: %d" RESET "\n", bytes_transferred);
return bytes_transferred;
}
return LIBUSB_SUCCESS;
}
/**
* AN495 - 4.5 - Set GPIO Values
* Report Id: 0x05
* Direction: Feature Request In
* Parameters:
* Part Number - Offset 1 - Size 1 - Value 0x0C - Device Part Number
* Device Version - Offset 2 - Size 1 - Value varies
*/
int HidCP2112_GetPartNumber(HID_SMBUS_DEVICE device, BYTE *partNumber, BYTE *version) {
int bytes_transferred;
int i = 0;
BYTE data[3];
*partNumber = 0;
*version = 0;
pthread_mutex_lock(&syncRoot);
bytes_transferred = libusb_control_transfer(
device,
CONTROL_REQUEST_TYPE_IN,
HID_GET_REPORT,
(HID_REPORT_TYPE_FEATURE << 8) | HID_SMBUS_REPORT_ID_GET_VERSION,
INTERFACE,
data,
sizeof(data),
TIMEOUT_MS);
pthread_mutex_unlock(&syncRoot);
if (bytes_transferred > 0) {
*partNumber = data[1];
*version = data[2];
if (verbose) {
DumpBytes(data, sizeof(data));
printf("HID SMBus Get Part Number: ");
printf("Part Number: %02X Version: %02X\n", data[1], data[2]);
}
} else {
fprintf(stderr, BOLDRED "HidCP2112_GetPartNumber: Error getting feature report. Bytes transferred: %d" RESET "\n", bytes_transferred);
return bytes_transferred;
}
return LIBUSB_SUCCESS;
}
void Cl3::Inspect_(std::ostream& os) const
{
os << "cl3(" << field_14 << ", files[\n";
size_t i = 0;
for (auto& e : entries)
{
os << " [" << i++ << "] (";
DumpBytes(os, e.name);
os << ", " << e.field_200 << ", links[";
bool first = true;
for (auto& l : e.links)
{
if (!first) os << ", ";
first = false;
os << l;
}
os << "], ";
if (e.src)
e.src->Inspect(os);
else
os << "nil";
os << ")\n";
}
}
void DumpTree(const cn_cbor * cbor, FILE * out, const FOO *pFOO, int depth, int fField, int fValue, int fInComment)
{
int i;
int i2;
const cn_cbor * cbor2;
const FOO * pFoo2;
int group;
if (pFOO != NULL) {
switch (pFOO->type) {
case CN_CBOR_TAG:
if (cbor->type != CN_CBOR_TAG) pFOO = NULL;
break;
default:
break;
}
}
if (fField && (pFOO != NULL) && (pFOO->fieldName != NULL)) {
if (fInComment) WrapPrintF(out, "\\ %s \\ ", pFOO -> fieldName);
else WrapPrintF(out, "/ %s / ", pFOO->fieldName);
}
switch (cbor->type) {
case CN_CBOR_TAG:
WrapPrintF(out, "%u(\n", cbor->v.uint);
Indent(out, depth + 1);
DumpTree(cbor->last_child, out, pFOO != NULL ? pFOO->children : NULL, depth+1, true, true, fInComment);
WrapPrintF(out, "\n");
Indent(out, depth);
WrapPrintF(out, ")");
break;
case CN_CBOR_ARRAY:
WrapPrintF(out, "[");
cbor2 = cbor->first_child;
for (i = 0; i < cbor->length; i++, cbor2 = cbor2->next) {
if (i != 0) WrapPrintF(out, ", ");
if (pFOO == NULL) pFoo2 = NULL;
else if (pFOO->count == 1) pFoo2 = pFOO->children;
else if (i >= pFOO->count) pFoo2 = NULL;
else pFoo2 = &pFOO->children[i];
WrapPrintF(out, "\n");
Indent(out, depth + 1);
DumpTree(cbor2, out, pFoo2, depth + 1, true, true, fInComment);
}
if (i > 0) {
WrapPrintF(out, "\n");
Indent(out, depth);
}
WrapPrintF(out, "]");
break;
case CN_CBOR_MAP:
WrapPrintF(out, "{");
cbor2 = cbor->first_child;
// Determine the correct group - always assume it is at element UINT=1
group = 0;
for (i = 0; i < cbor->length; i+=2, cbor2 = cbor2->next->next) {
if ((cbor2->type == CN_CBOR_UINT) && (cbor2->v.uint == 1)) {
group = (int) cbor2->next->v.uint;
break;
}
}
cbor2 = cbor->first_child;
// Dump each element
for (i = 0; i < cbor->length; i+=2, cbor2 = cbor2->next) {
pFoo2 = NULL;
if (pFOO != NULL) {
// Locate the right entry in foo
for (i2 = 0, pFoo2 = pFOO->children; i2 < pFOO->count; pFoo2++, i2 += 1) {
if (pFoo2->type != cbor2->type) continue;
switch (cbor2->type) {
case CN_CBOR_UINT:
if ((group != 0) && (pFoo2->group != 0) && (pFoo2->group != group)) continue;
if (pFoo2->value == (int) cbor2->v.uint) i2 = pFOO->count + 1;
break;
case CN_CBOR_INT:
if ((group != 0) && (pFoo2->group != 0) && (pFoo2->group != group)) continue;
if (pFoo2->value == cbor2->v.sint) i2 = pFOO->count + 1;
break;
default:
// Should assert here?
break;
}
if (i2 == pFOO->count + 1) break;
}
if (i2 == pFOO->count) pFoo2 = NULL;
}
if (i != 0) WrapPrintF(out, ", ");
WrapPrintF(out, "\n");
Indent(out, depth + 1);
DumpTree(cbor2, out, pFoo2, depth + 1, true, false, fInComment);
WrapPrintF(out, ":");
cbor2 = cbor2->next;
DumpTree(cbor2, out, pFoo2, depth + 1, false, true, fInComment);
}
if (i > 0) {
WrapPrintF(out, "\n");
Indent(out, depth);
}
WrapPrintF(out, "}");
break;
case CN_CBOR_BYTES:
DumpBytes(out, cbor);
if ((pFOO != NULL) && (pFOO->children != NULL)) {
const cn_cbor * cbor3 = cn_cbor_decode(cbor->v.bytes, cbor->length CBOR_CONTEXT_PARAM, NULL);
if (cbor3 != NULL) {
WrapPrintF(out, fInComment ? " \\ " : " / ");
DumpTree(cbor3, out, pFOO->children, depth+1, true, true, true);
WrapPrintF(out, fInComment ? " \\ " : " / ");
}
}
break;
case CN_CBOR_INT:
WrapPrintF(out, "%d", cbor->v.sint);
if (fValue && pFOO != NULL) {
for (i = 0, pFoo2 = pFOO->children; i < pFOO->count; i++, pFoo2++) {
if ((pFoo2->type == CN_CBOR_INT) && (pFoo2->value == cbor->v.sint)) {
if (pFoo2->fieldName != NULL) {
if (fInComment) WrapPrintF(out, " \\ %s \\", pFoo2->fieldName);
else WrapPrintF(out, " / %s /", pFoo2->fieldName);
}
break;
}
}
}
break;
case CN_CBOR_UINT:
WrapPrintF(out, "%u", cbor->v.uint);
if (fValue && (pFOO != NULL)) {
for (i = 0, pFoo2 = pFOO->children; i < pFOO->count; i++, pFoo2++) {
if ((pFoo2->type == CN_CBOR_UINT) && (pFoo2->value == (int) cbor->v.uint)) {
if (pFoo2->fieldName != NULL) {
if (fInComment) WrapPrintF(out, " \\ %s \\", pFoo2->fieldName);
else WrapPrintF(out, " / %s /", pFoo2->fieldName);
}
break;
}
}
}
break;
case CN_CBOR_TEXT:
WrapPrintF(out, "\"");
for (i = 0; i < cbor->length; i++) {
if (fInComment && (cbor->v.str[i] == '/')) {
WrapPrintF(out, "%c", cbor->v.str[i]);
}
WrapPrintF(out, "%c", cbor->v.str[i]);
}
WrapPrintF(out, "\"");
break;
case CN_CBOR_TRUE:
WrapPrintF(out, "true");
break;
case CN_CBOR_FALSE:
WrapPrintF(out, "false");
break;
default:
WrapPrintF(out, "##");
break;
}
}
