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(); }