static int _event(uint32_t devid, uint16_t id, uint16_t param, uint32_t param2)
{
int ret = HSB_E_OK;
switch (id) {
case VS_EVT_TYPE_SENSOR_TRIGGERED:
ret = dev_sensor_triggered(devid, param);
break;
case VS_EVT_TYPE_SENSOR_RECOVERED:
ret = dev_sensor_recovered(devid, param);
break;
case VS_EVT_TYPE_KEY_PRESSED:
ret = _key(param);
break;
case VS_EVT_TYPE_IR_KEY:
ret = _ir_key(devid, param, param2);
break;
default:
hsb_debug("unknown event %x\n", id);
ret = HSB_E_OTHERS;
break;
}
return ret;
}
static QString convertKey(const char *key, KexiCSVExport::Mode mode)
{
QString _key(QString::fromLatin1(key));
if (mode == KexiCSVExport::Clipboard) {
_key.replace("Exporting", "Copying");
_key.replace("Export", "Copy");
_key.replace("CSVFiles", "CSVToClipboard");
}
return _key;
}
int ibsDel(const int id, const char* key, const size_t keyLength) {
IBS_CHECK_ID(id);
DataChunk _key(key, keyLength);
ibs::StatusCode status;
status = ibs->drop(std::move(_key));
if (status.ok())
return 0;
else {
return errorCodeFromStatusCode(status);
}
return 0;
}
int ibsPut(const int id, const char* key, const size_t keyLength, const char* data, const size_t dataLength) {
IBS_CHECK_ID(id);
DataChunk _key(key, keyLength);
DataChunk _data(data, dataLength);
ibs::StatusCode status;
status = ibs->put(std::move(_key), std::move(_data));
if (status.ok())
return 0;
else {
return errorCodeFromStatusCode(status);
}
}
RedisServantGroup *RedisProxy::mapToGroup(const char* key, int len)
{
if (!m_keyMapping.empty()) {
String _key(key, len, false);
StringMap<RedisServantGroup*>::iterator it = m_keyMapping.find(_key);
if (it != m_keyMapping.end()) {
return it->second;
}
}
unsigned int hash_val = m_hashFunc(key, len);
unsigned int idx = hash_val % m_maxHashValue;
return m_hashMapping[idx];
}
void TConfigFile::Read(const char *key, BString *value, const char *defaultValue) const
{
TStringEx _key(key);
_key.Trim();
config_t *item;
for(int32 i = 0; i < fList.CountItems(); i++) {
item = (config_t *)fList.ItemAt(i);
if (strncmp(_key.String(), item->key, sizeof(item->key)) == 0) {
value->SetTo(item->value);
return;
}
}
value->SetTo(defaultValue);
}
int ibsPutTransaction(const int id, const int transactionId, const char* key, const size_t keyLength, const char* data,
const size_t dataLength) {
IBS_CHECK_ID(id);
std::string transactionUuid;
bool isValid = ibs::Transaction::getUuidFromId(transactionId, transactionUuid);
if (isValid) {
DataChunk _key(key, keyLength);
DataChunk _data(data, dataLength);
bool isAlreadyPresent = ibs->put(transactionUuid, std::move(_key), std::move(_data));
return isAlreadyPresent ? IBS__KEY_ALREADY_ADDED : 0;
}
else {
return IBS__INVALID_TRANSACTION_ID;
}
}
static void encodePrivateKeyHeader(const CssmData &inBlob, CFDataRef certificate, FVPrivateKeyHeader &outHeader)
{
CssmClient::CL cl(gGuidAppleX509CL);
const CssmData cert(const_cast<UInt8 *>(CFDataGetBytePtr(certificate)), CFDataGetLength(certificate));
CSSM_KEY_PTR key;
if (CSSM_RETURN rv = CSSM_CL_CertGetKeyInfo(cl->handle(), &cert, &key))
CssmError::throwMe(rv);
Security::CssmClient::CSP fCSP(gGuidAppleCSP);
// Set it up so the cl is used to free key and key->KeyData
// CssmAutoData _keyData(cl.allocator());
// _keyData.set(CssmData::overlay(key->KeyData));
CssmAutoData _key(cl.allocator());
_key.set(reinterpret_cast<uint8 *>(key), sizeof(*key));
CssmClient::Key cKey(fCSP, *key);
/* Given a CSSM_KEY_PTR in any format, obtain the SHA-1 hash of the
* associated key blob.
* Key is specified in CSSM_CSP_CreatePassThroughContext.
* Hash is allocated by the CSP, in the App's memory, and returned
* in *outData. */
CssmClient::PassThrough passThrough(fCSP);
passThrough.key(key);
void *outData;
passThrough(CSSM_APPLECSP_KEYDIGEST, NULL, &outData);
CssmData *cssmData = reinterpret_cast<CssmData *>(outData);
assert(cssmData->Length <= sizeof(outHeader.publicKeyHash));
outHeader.publicKeyHashSize = (uint32_t)cssmData->Length;
memcpy(outHeader.publicKeyHash, cssmData->Data, cssmData->Length);
fCSP.allocator().free(cssmData->Data);
fCSP.allocator().free(cssmData);
/* Now encrypt the blob with the public key. */
CssmClient::Encrypt encrypt(fCSP, key->KeyHeader.AlgorithmId);
encrypt.key(cKey);
CssmData clearBuf(outHeader.encryptedBlob, sizeof(outHeader.encryptedBlob));
CssmAutoData remData(fCSP.allocator());
encrypt.padding(CSSM_PADDING_PKCS1);
outHeader.encryptedBlobSize = (uint32_t)encrypt.encrypt(inBlob, clearBuf, remData.get());
if (outHeader.encryptedBlobSize > sizeof(outHeader.encryptedBlob))
secinfo("FDERecovery", "encodePrivateKeyHeader: encrypted blob too big: %d", outHeader.encryptedBlobSize);
}
status_t TConfigFile::Write(const char *key, const char *value)
{
TStringEx _key(key);
_key.Trim();
config_t *item;
for(int32 i = 0; i < fList.CountItems(); i++) {
item = (config_t *)fList.ItemAt(i);
if (strncmp(_key.String(), item->key, sizeof(item->key)) == 0) {
strncpy(item->value, value, sizeof(item->value));
return B_OK;
}
}
if ((item = (config_t *)calloc(sizeof(config_t), 1)) == NULL) return ENOMEM;
if (!fList.AddItem(item)) {
free(item);
return ENOMEM;
}
strncpy(item->key, _key.String(), sizeof(item->key));
strncpy(item->value, value, sizeof(item->value));
return B_OK;
}
int ibsGet(const int id, const char* key, const size_t keyLength, char* data, const size_t dataMaxLength,
size_t* dataLength) {
// using directly JNI buffer
// should be quicker
// than creating another buffer ...
IBS_CHECK_ID(id);
uint size;
DataChunk _key(key, keyLength);
DataChunk _data(data, dataMaxLength); //Buffer from JNI
ibs::StatusCode status;
size_t expected = 0;
status = ibs->fetch(std::move(_key), std::move(_data), expected);
if (status.IsSliceTooSmall()) {
*dataLength = expected;
}
if (!status.ok()) {
return errorCodeFromStatusCode(status);
}
size = _data.getSize();
*dataLength = size;
assert(size <= dataMaxLength);
return size;
}
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
const char key[] = {
0x00, 0x09, 0x70, 0x03,
0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b,
0x0c, 0x0d, 0x0e, 0x0f,
0x10, 0x11, 0x12, 0x13,
0x14, 0x15, 0x16, 0x17,
0x18, 0x19, 0x1a, 0x1b,
0x1c, 0x1d, 0x1e, 0x3f
};
const char in[] = {
0x00, 0x11, 0x11, 0x11,
0x13, 0x12, 0x12, 0x12,
0x88, 0x99, 0xaa, 0xbb,
0xcc, 0xdd, 0xee, 0xff,
0xdb, 0xdc, 0xdd, 0xde,
0x88, 0x99, 0xaa, 0xbb,
0xcc, 0xdd, 0xee, 0xff,
0x11, 0x12, 0x12, 0x12,
0x88, 0x99, 0xaa, 0xbb,
0xcc, 0xdd, 0xee, 0xff,
0x11, 0x12, 0x12, 0x12,
0x88, 0x99, 0xaa, 0xbb,
0xcc, 0xdd, 0xee, 0xff,
};
const char iv[] = {
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x88, 0x23, 0xaa, 0xbb,
0xcc, 0xdd, 0xee, 0xfc
};
QByteArray _key(key, 32);
QByteArray _in(in, 28);
QByteArray _iv(iv, 16);
AES aes(_key, _iv);
RC4 rc4(_key, _iv);
Salsa20 salsa20(_key, _iv);
qDebug() << "\nAES encryptor - CFB \n";
QByteArray encode_in = aes.update_CFB(_in, true);
qDebug() << "AES encode " << encode_in << " :size: " << encode_in.size();
QByteArray decode_in = aes.update_CFB(encode_in, false);
qDebug() << "RC4 decode " << decode_in << " :size: " << decode_in.size();
qDebug() << "\nRC4 encryptor \n";
QByteArray _encode_in = rc4.update(_in);
qDebug() << "RC4 encode " << _encode_in << " :size: " << _encode_in.size();
QByteArray _decode_in = rc4.update(_encode_in);
qDebug() << "RC4 decode " << _decode_in << " :size: " << _decode_in.size();
qDebug() << "\nSalsa20 encryptor \n";
QByteArray __encode_in = salsa20.update(_in);
qDebug() << "RC4 encode " << __encode_in << " :size: " << __encode_in.size();
QByteArray __decode_in = salsa20.update(__encode_in);
qDebug() << "RC4 decode " << __decode_in << " :size: " << __decode_in.size();
return a.exec();
}
void Tesselate_Presentation::tesselateShape(const TopoDS_Shape& aShape)
{
// setResultTitle("Tesselate shape");
TCollection_AsciiString aText = (
"/////////////////////////////////////////////////////////////////" EOL
"// Tesselate shape." EOL
"/////////////////////////////////////////////////////////////////" EOL EOL
) ;
Standard_Real aDeflection = DATA[myIndex][0];
Standard_Integer aNumOfFace = (Standard_Integer)DATA[myIndex][1];
Standard_Integer aNumOfEdge = (Standard_Integer)DATA[myIndex][2];
aText +=
"Standard_Real aDeflection;" EOL
"// aDeflection = ... ;" EOL EOL
"// removes all the triangulations of the faces ," EOL
"//and all the polygons on the triangulations of the edges:" EOL
"BRepTools::Clean(aShape);" EOL EOL
"// adds a triangulation of the shape aShape with the deflection aDeflection:" EOL
"BRepMesh::Mesh(aShape,aDeflection);" EOL EOL
"TopExp_Explorer aExpFace,aExpEdge;" EOL
"for(aExpFace.Init(aShape,TopAbs_FACE);aExpFace.More();aExpFace.Next())" EOL
"{ " EOL
" TopoDS_Face aFace = TopoDS::Face(aExpFace.Current());" EOL
" TopLoc_Location aLocation;" EOL EOL
" // takes the triangulation of the face aFace:" EOL
" Handle_Poly_Triangulation aTr = BRep_Tool::Triangulation(aFace,aLocation);" EOL EOL
" if(!aTr.IsNull()) // if this triangulation is not NULL" EOL
" { " EOL
" // takes the array of nodes for this triangulation:" EOL
" const TColgp_Array1OfPnt& aNodes = aTr->Nodes();" EOL
" // takes the array of triangles for this triangulation:" EOL
" const Poly_Array1OfTriangle& triangles = aTr->Triangles();" EOL EOL
" // create array of node points in absolute coordinate system" EOL
" TColgp_Array1OfPnt aPoints(1, aNodes.Length());" EOL
" for( Standard_Integer i = 1; i < aNodes.Length()+1; i++)" EOL
" aPoints(i) = aNodes(i).Transformed(aLocation);" EOL EOL
" // Takes the node points of each triangle of this triangulation." EOL
" // takes a number of triangles:" EOL
" Standard_Integer nnn = aTr->NbTriangles();" EOL
" Standard_Integer nt,n1,n2,n3;" EOL
" for( nt = 1 ; nt < nnn+1 ; nt++)" EOL
" {" EOL
" // takes the node indices of each triangle in n1,n2,n3:" EOL
" triangles(nt).Get(n1,n2,n3);" EOL
" // takes the node points:" EOL
" gp_Pnt aPnt1 = aPoints(n1);" EOL
" gp_Pnt aPnt2 = aPoints(n2);" EOL
" gp_Pnt aPnt3 = aPoints(n3);" EOL
" } " EOL EOL
" // Takes the polygon associated to an edge." EOL
" aExpEdge.Init(aFace,TopAbs_EDGE);" EOL
" TopoDS_Edge aEdge;" EOL
" // for example,working with the first edge:" EOL
" if(aExpEdge.More())" EOL
" aEdge = TopoDS::Edge(aExpEdge.Current());" EOL EOL
" if(!aEdge.IsNull()) // if this edge is not NULL" EOL
" {" EOL
" // takes the polygon associated to the edge aEdge:" EOL
" Handle_Poly_PolygonOnTriangulation aPol = " EOL
" BRep_Tool::PolygonOnTriangulation(aEdge,aTr,aEdge.Location());" EOL EOL
" if(!aPol.IsNull()) // if this polygon is not NULL" EOL
" // takes the array of nodes for this polygon" EOL
" // (indexes in the array of nodes for triangulation of theFace):" EOL
" const TColStd_Array1OfInteger& aNodesOfPol = aPol->Nodes();" EOL
" }" EOL
" }" EOL
"}" EOL EOL
"//==================================================" EOL EOL
;
aText += " Result with deflection = ";
aText += TCollection_AsciiString(aDeflection);
aText += " :" EOL;
GetDocument()->PocessTextInDialog("Compute the triangulation on a shape", aText);
// setResultText(aText.ToCString());
//==========================================================================
BRepTools::Clean(aShape);
BRepMesh::Mesh(aShape,aDeflection);
BRep_Builder aBuilder,aBuild1,aBuild2;
TopoDS_Compound aCompound,aComp1,aComp2;
aBuilder.MakeCompound(aCompound);
aBuild1.MakeCompound(aComp1);
aBuild2.MakeCompound(aComp2);
TopTools_SequenceOfShape aVertices;
Standard_Integer aCount = 0;
Standard_Integer aNumOfNodes = 0;
Standard_Integer aNumOfTriangles = 0;
Handle_AIS_InteractiveObject aShowEdge,aShowFace,aShowShape;
TopExp_Explorer aExpFace,aExpEdge;
for(aExpFace.Init(aShape,TopAbs_FACE);aExpFace.More();aExpFace.Next())
{
aCount++;
TopoDS_Face aFace = TopoDS::Face(aExpFace.Current());
TopLoc_Location aLocation;
Handle_Poly_Triangulation aTr = BRep_Tool::Triangulation(aFace,aLocation);
if(!aTr.IsNull())
{
const TColgp_Array1OfPnt& aNodes = aTr->Nodes();
aNumOfNodes += aTr->NbNodes();
Standard_Integer aLower = aNodes.Lower();
Standard_Integer anUpper = aNodes.Upper();
const Poly_Array1OfTriangle& triangles = aTr->Triangles();
aNumOfTriangles += aTr->NbTriangles();
if(aCount == aNumOfFace)
{
Standard_Integer aNbOfNodesOfFace = aTr->NbNodes();
Standard_Integer aNbOfTrianglesOfFace = aTr->NbTriangles();
aExpEdge.Init(aFace,TopAbs_EDGE);
TopoDS_Edge aEdge;
for( Standard_Integer i = 0; aExpEdge.More() && i < aNumOfEdge ; aExpEdge.Next(), i++)
aEdge = TopoDS::Edge(aExpEdge.Current());
if(!aEdge.IsNull())
{
Handle_Poly_PolygonOnTriangulation aPol =
BRep_Tool::PolygonOnTriangulation(aEdge,aTr,aEdge.Location());
if(!aPol.IsNull())
{
const TColStd_Array1OfInteger& aNodesOfPol = aPol->Nodes();
Standard_Integer aNbOfNodesOfEdge = aPol->NbNodes();
aText += "Number of nodes of the edge = ";
aText += TCollection_AsciiString(aNbOfNodesOfEdge) + EOL;
aText += "Number of nodes of the face = ";
aText += TCollection_AsciiString(aNbOfNodesOfFace) + EOL;
aText += "Number of triangles of the face = ";
aText += TCollection_AsciiString(aNbOfTrianglesOfFace) + EOL;
GetDocument()->PocessTextInDialog("Compute the triangulation on a shape", aText);
// setResultText(aText.ToCString());
Standard_Integer aLower = aNodesOfPol.Lower(), anUpper = aNodesOfPol.Upper();
for( int i = aLower; i < anUpper ; i++)
{
gp_Pnt aPnt1 = aNodes(aNodesOfPol(i)).Transformed(aLocation);
gp_Pnt aPnt2 = aNodes(aNodesOfPol(i+1)).Transformed(aLocation);
TopoDS_Vertex aVertex1 = BRepBuilderAPI_MakeVertex (aPnt1);
TopoDS_Vertex aVertex2 = BRepBuilderAPI_MakeVertex (aPnt2);
if(!aVertex1.IsNull() && !aVertex2.IsNull() && // if vertices are "alive"
!BRep_Tool::Pnt(aVertex1).IsEqual(
BRep_Tool::Pnt(aVertex2),Precision::Confusion())) // if they are different
{
aEdge = BRepBuilderAPI_MakeEdge (aVertex1,aVertex2);
aBuild2.Add(aComp2,aVertex1);
if(!aEdge.IsNull())
aBuild2.Add(aComp2,aEdge);
if(i == anUpper-1)
aBuild2.Add(aComp2,aVertex2);
}
}
getAISContext()->EraseAll();
aShowShape = drawShape(aShape);
if(WAIT_A_SECOND) return;
aShowEdge = drawShape(aComp2,Quantity_NOC_GREEN);
getAISContext()->Erase(aShowShape);
if(WAIT_A_SECOND) return;
}
}
}
TopTools_DataMapOfIntegerShape aEdges;
TopTools_SequenceOfShape aVertices;
for( Standard_Integer i = 1; i < aNodes.Length()+1; i++)
{
gp_Pnt aPnt = aNodes(i).Transformed(aLocation);
TopoDS_Vertex aVertex = BRepBuilderAPI_MakeVertex(aPnt);
if(!aVertex.IsNull())
{
aBuilder.Add(aCompound,aVertex);
if(aCount == aNumOfFace )
aBuild1.Add(aComp1,aVertex);
aVertices.Append(aVertex);
}
}
Standard_Integer nnn = aTr->NbTriangles();
Standard_Integer nt,n1,n2,n3;
for( nt = 1 ; nt < nnn+1 ; nt++)
{
triangles(nt).Get(n1,n2,n3);
Standard_Integer key[3];
TopoDS_Vertex aV1,aV2;
key[0] = _key(n1, n2);
if(!aEdges.IsBound(key[0]))
{
aV1 = TopoDS::Vertex(aVertices(n1));
aV2 = TopoDS::Vertex(aVertices(n2));
if(!aV1.IsNull() && !aV2.IsNull() &&
!BRep_Tool::Pnt(aV1).IsEqual(BRep_Tool::Pnt(aV2),Precision::Confusion()))
{
TopoDS_Edge aEdge = BRepBuilderAPI_MakeEdge (aV1,aV2);
if(!aEdge.IsNull())
{
aEdges.Bind(key[0], aEdge);
aBuilder.Add(aCompound,aEdges(key[0]));
if(aCount == aNumOfFace)
aBuild1.Add(aComp1,aEdges(key[0]));
}
}
}
key[1] = _key(n2,n3);
if(!aEdges.IsBound(key[1]))
{
aV1 = TopoDS::Vertex(aVertices(n2));
aV2 = TopoDS::Vertex(aVertices(n3));
if(!aV1.IsNull() && !aV2.IsNull() &&
!BRep_Tool::Pnt(aV1).IsEqual(BRep_Tool::Pnt(aV2),Precision::Confusion()))
{
TopoDS_Edge aEdge = BRepBuilderAPI_MakeEdge (aV1,aV2);
if(!aEdge.IsNull())
{
aEdges.Bind(key[1],aEdge);
aBuilder.Add(aCompound,aEdges(key[1]));
if(aCount == aNumOfFace)
aBuild1.Add(aComp1,aEdges(key[1]));
}
}
}
key[2] = _key(n3,n1);
if(!aEdges.IsBound(key[2]))
{
aV1 = TopoDS::Vertex(aVertices(n3));
aV2 = TopoDS::Vertex(aVertices(n1));
if(!aV1.IsNull() && !aV2.IsNull() &&
!BRep_Tool::Pnt(aV1).IsEqual(BRep_Tool::Pnt(aV2),Precision::Confusion()))
{
TopoDS_Edge aEdge = BRepBuilderAPI_MakeEdge (aV1,aV2);
if(!aEdge.IsNull())
{
aEdges.Bind(key[2],aEdge);
aBuilder.Add(aCompound,aEdges(key[2]));
if(aCount == aNumOfFace)
aBuild1.Add(aComp1,aEdges(key[2]));
}
}
}
}
if(aCount == aNumOfFace)
{
aShowFace = drawShape(aComp1,Quantity_NOC_GREEN);
getAISContext()->Erase(aShowEdge);
}
}
else
{
aText += "Can't compute a triangulation on face ";
aText += TCollection_AsciiString(aCount) + EOL;
GetDocument()->PocessTextInDialog("Compute the triangulation on a shape", aText);
// setResultText(aText.ToCString());
}
}
aText += "Number of nodes of the shape = ";
aText += TCollection_AsciiString(aNumOfNodes) + EOL;
aText += "Number of triangles of the shape = ";
aText += TCollection_AsciiString(aNumOfTriangles) + EOL EOL;
GetDocument()->PocessTextInDialog("Compute the triangulation on a shape", aText);
// setResultText(aText.ToCString());
if(WAIT_A_SECOND) return;
drawShape(aCompound,Quantity_NOC_GREEN);
getAISContext()->Erase(aShowFace);
}
