string StringConverter::GetTypeName (const type_info &typeInfo)
{
try
{
#ifdef _MSC_VER
// type_info::name() leaks memory as of MS VC++ 8.0
string rawName (typeInfo.raw_name());
size_t cut1 = (rawName.find (".?A") != string::npos) ? 4 : string::npos;
size_t cut2 = rawName.find ("@");
size_t cut3 = rawName.find ("@@");
if (cut1 == string::npos || cut2 == string::npos || cut3 == string::npos)
return typeInfo.name();
return rawName.substr (cut2 + 1, cut3 - cut2 - 1) + "::" + rawName.substr (cut1, cut2 - cut1);
#elif defined (__GNUC__)
int status;
char *name = abi::__cxa_demangle (typeInfo.name(), nullptr, nullptr, &status);
if (name)
{
string s (name);
free (name);
return s;
}
#endif
}
catch (...) { }
return typeInfo.name();
}
void Storage::getElement(uint32_t enterprise, uint16_t id, struct ipfix_element& element)
{
element = elements[enterprise][id];
if (element.type == UNKNOWN && element.name.empty()) {
element.name = rawName(enterprise, id);
elements[enterprise][id] = element;
}
}
bool Foam::fileFormats::TRIsurfaceFormatCore::read
(
const fileName& filename
)
{
this->clear();
sorted_ = true;
IFstream is(filename);
if (!is.good())
{
FatalErrorIn
(
"fileFormats::TRIsurfaceFormatCore::read(const fileName&)"
)
<< "Cannot read file " << filename
<< exit(FatalError);
}
// uses similar structure as STL, just some points
// the rest of the reader resembles the STL binary reader
DynamicList<point> dynPoints;
DynamicList<label> dynZones;
DynamicList<label> dynSizes;
HashTable<label> lookup;
// place faces without a group in zone0
label zoneI = 0;
dynSizes.append(zoneI);
lookup.insert("zoneI", zoneI);
while (is.good())
{
string line = this->getLineNoComment(is);
// handle continuations ?
// if (line[line.size()-1] == '\\')
// {
// line.substr(0, line.size()-1);
// line += this->getLineNoComment(is);
// }
IStringStream lineStream(line);
point p
(
readScalar(lineStream),
readScalar(lineStream),
readScalar(lineStream)
);
if (!lineStream) break;
dynPoints.append(p);
dynPoints.append
(
point
(
readScalar(lineStream),
readScalar(lineStream),
readScalar(lineStream)
)
);
dynPoints.append
(
point
(
readScalar(lineStream),
readScalar(lineStream),
readScalar(lineStream)
)
);
// zone/colour in .tri file starts with 0x. Skip.
// ie, instead of having 0xFF, skip 0 and leave xFF to
// get read as a word and name it "zoneFF"
char zero;
lineStream >> zero;
word rawName(lineStream);
word name("zone" + rawName(1, rawName.size()-1));
HashTable<label>::const_iterator fnd = lookup.find(name);
if (fnd != lookup.end())
{
if (zoneI != fnd())
{
// group appeared out of order
sorted_ = false;
}
zoneI = fnd();
}
else
{
zoneI = dynSizes.size();
lookup.insert(name, zoneI);
dynSizes.append(0);
}
dynZones.append(zoneI);
dynSizes[zoneI]++;
}
// skip empty groups
label nZone = 0;
forAll(dynSizes, zoneI)
{
if (dynSizes[zoneI])
{
if (nZone != zoneI)
{
dynSizes[nZone] = dynSizes[zoneI];
}
nZone++;
}
}
// truncate addressed size
dynSizes.setCapacity(nZone);
// transfer to normal lists
points_.transfer(dynPoints);
zoneIds_.transfer(dynZones);
sizes_.transfer(dynSizes);
return true;
}
/**
* \brief Store data record
*/
void Storage::storeDataRecord(struct metadata *mdata, struct json_conf * config)
{
const char *element_name = NULL;
ELEMENT_TYPE element_type;
offset = 0;
uint16_t trans_len = 0;
const char *trans_str = NULL;
record.clear();
STR_APPEND(record, "{\"@type\": \"ipfix.entry\", ");
struct ipfix_template *templ = mdata->record.templ;
uint8_t *data_record = (uint8_t*) mdata->record.record;
/* get all fields */
uint16_t added = 0;
for (uint16_t count = 0, index = 0; count < templ->field_count; ++count, ++index) {
/* Get Enterprise number and ID */
id = templ->fields[index].ie.id;
length = templ->fields[index].ie.length;
enterprise = 0;
if (id & 0x8000) {
id &= 0x7fff;
enterprise = templ->fields[++index].enterprise_number;
}
/* Get element informations */
const ipfix_element_t * element = get_element_by_id(id, enterprise);
if (element != NULL) {
element_name = element->name;
element_type = element->type;
} else {
// Element not found
if (config->ignoreUnknown) {
offset += realLength(length, data_record, offset);
continue;
}
element_name = rawName(enterprise, id);
element_type = ET_UNASSIGNED;
MSG_DEBUG(msg_module, "Unknown element (%s)", element_name);
}
if (added > 0) {
STR_APPEND(record, ", ");
}
STR_APPEND(record, "\"");
record += config->prefix;
record += element_name;
STR_APPEND(record, "\": ");
switch (element_type) {
case ET_UNSIGNED_8:
case ET_UNSIGNED_16:
case ET_UNSIGNED_32:
case ET_UNSIGNED_64:{
trans_str = translator.toUnsigned(length, &trans_len, data_record, offset,
element, config);
record.append(trans_str, trans_len);
}
break;
case ET_SIGNED_8:
case ET_SIGNED_16:
case ET_SIGNED_32:
case ET_SIGNED_64:
trans_str = translator.toSigned(length, &trans_len, data_record, offset);
record.append(trans_str, trans_len);
break;
case ET_FLOAT_32:
case ET_FLOAT_64:
trans_str = translator.toFloat(length, &trans_len, data_record, offset);
record.append(trans_str, trans_len);
break;
case ET_IPV4_ADDRESS:
record += '"';
trans_str = translator.formatIPv4(read32(data_record + offset), &trans_len);
record.append(trans_str, trans_len);
record += '"';
break;
case ET_IPV6_ADDRESS:
READ_BYTE_ARR(addr6, data_record + offset, IPV6_LEN);
record += '"';
record += translator.formatIPv6(addr6);
record += '"';
break;
case ET_MAC_ADDRESS:
READ_BYTE_ARR(addrMac, data_record + offset, MAC_LEN);
record += '"';
record += translator.formatMac(addrMac);
record += '"';
break;
case ET_DATE_TIME_SECONDS:
record += translator.formatTimestamp(read32(data_record + offset),
t_units::SEC, config);
break;
case ET_DATE_TIME_MILLISECONDS:
record += translator.formatTimestamp(read64(data_record + offset),
t_units::MILLISEC, config);
break;
case ET_DATE_TIME_MICROSECONDS:
record += translator.formatTimestamp(read64(data_record + offset),
t_units::MICROSEC, config);
break;
case ET_DATE_TIME_NANOSECONDS:
record += translator.formatTimestamp(read64(data_record + offset),
t_units::NANOSEC, config);
break;
case ET_STRING:
length = realLength(length, data_record, offset);
record += translator.escapeString(length, data_record + offset,
config);
break;
case ET_BOOLEAN:
case ET_UNASSIGNED:
default:
readRawData(length, data_record, offset);
break;
}
offset += length;
added++;
}
/* Store metadata */
if (processMetadata) {
STR_APPEND(record, ", \"ipfix.metadata\": {");
storeMetadata(mdata);
STR_APPEND(record, "}");
}
STR_APPEND(record, "}\n");
sendData();
}
// incoming transfer flow
void CToxProto::OnFriendFile(Tox*, uint32_t friendNumber, uint32_t fileNumber, uint32_t kind, uint64_t fileSize, const uint8_t *fileName, size_t filenameLength, void *arg)
{
CToxProto *proto = (CToxProto*)arg;
MCONTACT hContact = proto->GetContact(friendNumber);
if (hContact)
{
switch (kind)
{
case TOX_FILE_KIND_AVATAR:
{
proto->logger->Log(__FUNCTION__": incoming avatar (%d) from (%d)", fileNumber, friendNumber);
ptrT address(proto->getTStringA(hContact, TOX_SETTINGS_ID));
TCHAR avatarName[MAX_PATH];
mir_sntprintf(avatarName, MAX_PATH, _T("%s.png"), address);
AvatarTransferParam *transfer = new AvatarTransferParam(friendNumber, fileNumber, avatarName, fileSize);
transfer->pfts.flags |= PFTS_RECEIVING;
transfer->pfts.hContact = hContact;
proto->transfers.Add(transfer);
TOX_ERR_FILE_GET error;
tox_file_get_file_id(proto->toxThread->tox, friendNumber, fileNumber, transfer->hash, &error);
if (error != TOX_ERR_FILE_GET_OK)
{
proto->logger->Log(__FUNCTION__": unable to get avatar hash (%d) from (%d) cause (%d)", fileNumber, friendNumber, error);
memset(transfer->hash, 0, TOX_HASH_LENGTH);
}
proto->OnGotFriendAvatarInfo(transfer);
}
break;
case TOX_FILE_KIND_DATA:
{
proto->logger->Log(__FUNCTION__": incoming file (%d) from (%d)", fileNumber, friendNumber);
ptrA rawName((char*)mir_alloc(filenameLength + 1));
memcpy(rawName, fileName, filenameLength);
rawName[filenameLength] = 0;
TCHAR *name = mir_utf8decodeT(rawName);
FileTransferParam *transfer = new FileTransferParam(friendNumber, fileNumber, name, fileSize);
transfer->pfts.flags |= PFTS_RECEIVING;
transfer->pfts.hContact = hContact;
proto->transfers.Add(transfer);
PROTORECVFILET pre = { 0 };
pre.dwFlags = PRFF_TCHAR;
pre.fileCount = 1;
pre.timestamp = time(NULL);
pre.descr.t = _T("");
pre.files.t = &name;
pre.lParam = (LPARAM)transfer;
ProtoChainRecvFile(hContact, &pre);
}
break;
default:
proto->logger->Log(__FUNCTION__": unsupported transfer (%d) from (%d) with type (%d)", fileNumber, friendNumber, kind);
return;
}
}
}
/**
* \brief Store data record
*/
void Storage::storeDataRecord(struct metadata *mdata)
{
offset = 0;
record.clear();
record += "{\"@type\": \"ipfix.entry\", \"ipfix\": {";
struct ipfix_template *templ = mdata->record.templ;
uint8_t *data_record = (uint8_t*) mdata->record.record;
/* get all fields */
for (uint16_t count = 0, index = 0; count < templ->field_count; ++count, ++index) {
/* Get Enterprise number and ID */
id = templ->fields[index].ie.id;
length = templ->fields[index].ie.length;
enterprise = 0;
if (id & 0x8000) {
id &= 0x7fff;
enterprise = templ->fields[++index].enterprise_number;
}
/* Get element informations */
struct ipfix_element& element = elements[enterprise][id];
if (element.type == UNKNOWN && element.name.empty()) {
element.name = rawName(enterprise, id);
elements[enterprise][id] = element;
MSG_DEBUG(msg_module, "Unknown element (%s)", element.name.c_str());
}
if (count > 0) {
record += ", ";
}
record += "\"";
record += element.name;
record += "\": \"";
switch (element.type) {
case PROTOCOL:
record += translator.formatProtocol(read8(data_record + offset));
break;
case FLAGS:
record += translator.formatFlags(read16(data_record + offset));
break;
case IPV4:
record += translator.formatIPv4(read32(data_record + offset));
break;
case IPV6:{
READ_BYTE_ARR(addr6, data_record + offset, IPV6_LEN);
record += translator.formatIPv6(addr6);
break;}
case MAC: {
READ_BYTE_ARR(addrMac, data_record + offset, MAC_LEN);
record += translator.formatMac(addrMac);
break;}
case TSTAMP_SEC:
record += translator.formatTimestamp(read64(data_record + offset), t_units::SEC);
break;
case TSTAMP_MILLI:
record += translator.formatTimestamp(read64(data_record + offset), t_units::MILLISEC);
break;
case TSTAMP_MICRO:
record += translator.formatTimestamp(read64(data_record + offset), t_units::MICROSEC);
break;
case TSTAMP_NANO:
record += translator.formatTimestamp(read64(data_record + offset), t_units::NANOSEC);
break;
case STRING:
readString(length, data_record, offset);
break;
case RAW:
readRawData(length, data_record, offset);
break;
default:
readRawData(length, data_record, offset);
break;
}
record += "\"";
offset += length;
}
/* Store metadata */
if (processMetadata) {
record += "}, \"metadata\": {";
storeMetadata(mdata);
}
record += "}}\n";
sendData();
}
