void ARRAY_TEXT::convertToUTF8(const CUTF16String* fromString, CUTF8String* toString)
{
#ifdef _WIN32
int len = WideCharToMultiByte(CP_UTF8, 0, (LPCWSTR)fromString->c_str(), fromString->length(), NULL, 0, NULL, NULL);
if(len){
std::vector<uint8_t> buf(len + 1);
if(WideCharToMultiByte(CP_UTF8, 0, (LPCWSTR)fromString->c_str(), fromString->length(), (LPSTR)&buf[0], len, NULL, NULL)){
*toString = CUTF8String((const uint8_t *)&buf[0]);
}
}else{
*toString = CUTF8String((const uint8_t *)"");
}
#else
CFStringRef str = CFStringCreateWithCharacters(kCFAllocatorDefault, (const UniChar *)fromString->c_str(), fromString->length());
if(str){
size_t size = CFStringGetMaximumSizeForEncoding(CFStringGetLength(str), kCFStringEncodingUTF8) + sizeof(uint8_t);
std::vector<uint8_t> buf(size);
CFIndex len = 0;
CFStringGetBytes(str, CFRangeMake(0, CFStringGetLength(str)), kCFStringEncodingUTF8, 0, true, (UInt8 *)&buf[0], size, &len);
*toString = CUTF8String((const uint8_t *)&buf[0], len);
CFRelease(str);
}
#endif
}
static void traverseRelation(opcContainer *c,
opcPart source,
ARRAY_TEXT &srcs,
ARRAY_TEXT &dsts,
ARRAY_TEXT &names,
ARRAY_TEXT &types) {
for(opcRelation rel = opcRelationFirst(c, source);OPC_RELATION_INVALID != rel;rel=opcRelationNext(c, source, rel)) {
const xmlChar *target = opcRelationGetExternalTarget(c, source, rel);
if (!target) {
//is internal
opcPart part = opcRelationGetInternalTarget(c, source, rel);
if (OPC_PART_INVALID != part) {
CUTF8String n, s, t, p;
t = CUTF8String((const uint8_t *)getRelationPrefixSource(c, source, rel, n, s));
p = CUTF8String((const uint8_t *)part);
srcs.appendUTF8String(&s);
dsts.appendUTF8String(&p);
names.appendUTF8String(&n);
types.appendUTF8String(&t);
}
traverseRelation(c, part, srcs, dsts, names, types);
}else{
//is external
CUTF8String n, s, t, p;
t = CUTF8String((const uint8_t *)getRelationPrefixSource(c, source, rel, n, s));
p = CUTF8String((const uint8_t *)target);
srcs.appendUTF8String(&s);
dsts.appendUTF8String(&p);
names.appendUTF8String(&n);
types.appendUTF8String(&t);
}
}
}
void PEM_From_P12(PA_PluginParameters params)
{
sLONG_PTR *pResult = (sLONG_PTR *)params->fResult;
PackagePtr pParams = (PackagePtr)params->fParameters;
C_BLOB Param1;
C_BLOB Param2;
C_TEXT Param3;
C_TEXT returnValue;
Param1.fromParamAtIndex(pParams, 1);
Param3.fromParamAtIndex(pParams, 3);
BIO *bio = BIO_new_mem_buf((void *)Param1.getBytesPtr(), Param1.getBytesLength());
if(bio){
PKCS12 *p12 = d2i_PKCS12_bio(bio, NULL);
if(p12){
EVP_PKEY *key = NULL;
X509 *cert = NULL;
STACK_OF(X509) *ca = NULL;
CUTF8String pass;
Param3.copyUTF8String(&pass);
if(PKCS12_parse(p12, (const char *)pass.c_str(), &key, &cert, &ca)){
BIO *pem = BIO_new(BIO_s_mem());
if(pem){
PEM_write_bio_PrivateKey(pem, key, NULL, NULL, NULL, NULL, (void *)pass.c_str());
char *buf = NULL;
int len = BIO_get_mem_data(pem, &buf);
if(len){
Param2.setBytes((const uint8_t *)buf, len);
Param2.toParamAtIndex(pParams, 2);
CUTF8String pemStr = CUTF8String((const uint8_t *)buf, len);
returnValue.setUTF8String(&pemStr);
}
BIO_free(pem);
}
}
}
BIO_free(bio);
}
Param2.toParamAtIndex(pParams, 2);
returnValue.setReturn(pResult);
}
void FreeXL_Get_worksheet_name(sLONG_PTR *pResult, PackagePtr pParams)
{
C_LONGINT Param1;
C_LONGINT Param2;
C_TEXT Param3;
C_LONGINT returnValue;
Param1.fromParamAtIndex(pParams, 1);
Param2.fromParamAtIndex(pParams, 2);
int error = FREEXL_NULL_HANDLE;
xls_handle h = __handleGet(Param1.getIntValue());
if(h){
const char *name;
error = freexl_get_worksheet_name(h, Param2.getIntValue() -1, &name);
if(FREEXL_OK == error){
CUTF8String n = CUTF8String((const uint8_t *)name);
Param3.setUTF8String(&n);
}
}
Param3.toParamAtIndex(pParams, 3);
returnValue.setIntValue(error);
returnValue.setReturn(pResult);
}
void ARRAY_TEXT::appendUTF8String(const uint8_t* pString, uint32_t len){
CUTF8String u8 = CUTF8String(pString, len);
CUTF16String u16;
convertFromUTF8(&u8, &u16);
this->_CUTF16StringArray->push_back(u16);
}
bool getPictureDataForType(PackagePtr pParams, int index, std::vector<unsigned char> &buf, std::string &type)
{
PA_ErrorCode err = eER_NoErr;
unsigned i = 0;
PA_Unistring t;
std::map<CUTF8String, uint32_t> types;
PA_Picture picture = *(PA_Picture *)(pParams[index - 1]);
while (err == eER_NoErr)
{
t = PA_GetPictureData(picture, ++i, NULL);
err = PA_GetLastError();
if(err == eER_NoErr)
{
uint32_t len = (uint32_t)(t.fLength * 4) + sizeof(uint8_t);
std::vector<uint8_t> u(len);
PA_ConvertCharsetToCharset(
(char *)t.fString,
t.fLength * sizeof(PA_Unichar),
eVTC_UTF_16,
(char *)&u[0],
len,
eVTC_UTF_8
);
CUTF8String uti;
uti = CUTF8String((const uint8_t *)&u[0]);
CUTF8String typestring;
size_t pos, found;
found = 0;
for(pos = uti.find(';'); pos != CUTF8String::npos; pos = uti.find(';', found))
{
typestring = uti.substr(found, pos-found);
found = pos + 1;
types.insert(std::map<CUTF8String, uint32_t>::value_type(typestring, i));
}
typestring = uti.substr(found, uti.length()-found);
types.insert(std::map<CUTF8String, uint32_t>::value_type(typestring, i));
}
}
std::map<CUTF8String, uint32_t>::iterator itr;
itr = types.find((const uint8_t *)type.c_str());
if (itr != types.end())
{
uint32_t pos = itr->second;
PA_Handle h = PA_NewHandle(0);
err = eER_NoErr;
PA_GetPictureData(picture, pos, h);
err = PA_GetLastError();
if(err == eER_NoErr)
{
unsigned long insize = PA_GetHandleSize(h);
buf.resize(insize);
memcpy(&buf[0], (const void *)PA_LockHandle(h), insize);
PA_UnlockHandle(h);
PA_DisposeHandle(h);
return true;
}
}
return false;
}
void FreeXL_Get_cell_value(sLONG_PTR *pResult, PackagePtr pParams)
{
C_LONGINT Param1;
C_LONGINT Param2;
C_LONGINT Param3;
C_LONGINT Param4;
C_REAL Param5;
C_TEXT Param6;
C_LONGINT returnValue;
Param1.fromParamAtIndex(pParams, 1);
Param2.fromParamAtIndex(pParams, 2);
Param3.fromParamAtIndex(pParams, 3);
int error = FREEXL_NULL_HANDLE;
xls_handle h = __handleGet(Param1.getIntValue());
if(h){
FreeXL_CellValue value;
error = freexl_get_cell_value(h, Param2.getIntValue() -1, Param3.getIntValue() -1, &value);
if(FREEXL_OK == error){
CUTF8String v;
switch (value.type){
case FREEXL_CELL_INT:
Param4.setIntValue(value.value.int_value);
break;
case FREEXL_CELL_DOUBLE:
Param5.setDoubleValue(value.value.double_value);
break;
case FREEXL_CELL_TEXT:
case FREEXL_CELL_SST_TEXT:
case FREEXL_CELL_DATE:
case FREEXL_CELL_DATETIME:
case FREEXL_CELL_TIME:
v = CUTF8String((const uint8_t *)value.value.text_value);
Param6.setUTF8String(&v);
break;
case FREEXL_CELL_NULL:
break;
}
}
}
Param4.toParamAtIndex(pParams, 4);
Param5.toParamAtIndex(pParams, 5);
Param6.toParamAtIndex(pParams, 6);
returnValue.setIntValue(error);
returnValue.setReturn(pResult);
}
void OD_Set_SQL_in_cursor(sLONG_PTR *pResult, PackagePtr pParams)
{
C_LONGINT Param1;
C_TEXT Param2;
C_LONGINT Param3;
C_LONGINT returnValue;
Param1.fromParamAtIndex(pParams, 1);
Param2.fromParamAtIndex(pParams, 2);
Param3.fromParamAtIndex(pParams, 3);
uint32_t cursorId = Param1.getIntValue();
sword err = 0;
ORACLE_SQL_CURSOR *cursor = _cursorGetAndCheckInactive(cursorId);
if(cursor)
{
sessionInfo *session = _sessionGet(cursor->sessionId);
if(session)
{
_cursorClearBind(session, cursor);
//convert 4D bindings to oracle bindings
CUTF8String sql, substr;
Param2.copyUTF8String(&sql);
size_t start, end, pos;
end = 0;
pos = 0;
C_TEXT variableName;
PA_Variable variable;
CUTF8String parsedSql;
ORACLE_SQL_SUBSTITUTION_LIST substitutions;
//ORACLE_SQL_BIND_TYPE_LIST isByName;
ORACLE_SQL_BIND_NAME_LIST names;
C_TEXT temp;
CUTF16String u16;
for(start = sql.find((const uint8_t *)"<<"); start != CUTF8String::npos; start = sql.find((const uint8_t *)"<<", end))
{
end = sql.find((const uint8_t *)">>", start);
if(end != CUTF8String::npos)
{
start += 2;//length of "<<"
substr = sql.substr(start, end-start);
variableName.setUTF8String(&substr);
variable = PA_GetVariable((PA_Unichar *)variableName.getUTF16StringPtr());
parsedSql += sql.substr(pos, start - pos - 2);
parsedSql += (const uint8_t *)":";
if(substr.length()){
parsedSql += substr;
//isByName.push_back(true);
temp.setUTF8String(&substr);
temp.copyUTF16String(&u16);
}else{
char buf[10];
size_t len;
len = sprintf(buf,"%d", (int)substitutions.size() + 1);
parsedSql += CUTF8String((const uint8_t *)buf, len);
//isByName.push_back(false);
u16.clear();
}
pos = end + 2;//length of ">>"
names.push_back(u16);
substitutions.push_back(variable);
}
}
//remaining text
parsedSql += sql.substr(pos);
temp.setUTF8String(&parsedSql);
temp.copyUTF16String(&cursor->sql);
cursor->substitutions = substitutions;
// cursor->isByName = isByName;
cursor->names = names;
size_t count = substitutions.size();
_cursorResize(session, cursor, count);
unsigned int sql_type = 0;
ub4 language = OCI_NTV_SYNTAX;
switch (Param3.getIntValue())
{
case 2:
language = OCI_V7_SYNTAX;
break;
case 3:
language = OCI_V8_SYNTAX;
break;
}
err = OCIStmtPrepare(cursor->stmtp, cursor->errhp,
(CONST text *)cursor->sql.c_str(),
(ub4)cursor->sql.length() * sizeof(PA_Unichar),
language,
OCI_DEFAULT);
//in characters or in number of bytes, depending on the encoding
//http://docs.oracle.com/cd/B10500_01/appdev.920/a96584/oci16ms6.htm
if(!err)
{
err = OCIAttrGet(cursor->stmtp, OCI_HTYPE_STMT, (dvoid *)&sql_type, 0, OCI_ATTR_STMT_TYPE, cursor->errhp);
//http://docs.oracle.com/cd/B10500_01/appdev.920/a96584/oci15r20.htm#443771
if(!err)
{
cursor->sql_type = sql_type;
//http://docs.oracle.com/cd/E14072_01/appdev.112/e10646/oci04sql.htm#CIHEHCEJ
switch (sql_type)
{
case OCI_STMT_SELECT:
cursor->isTowardsSQL.assign(count, false);//SELECT is towards 4D
break;
default:
cursor->isTowardsSQL.assign(count, true);//INSERT is towards SQL
break;
}
returnValue.setIntValue(1);
}
}
if(err)
{
_errorInfoSet(0, cursor->errhp, cursor->sessionId, cursorId, false, PA_GetCurrentProcessNumber(), 0);
returnValue.setIntValue(err);
}
}
}
returnValue.setReturn(pResult);
}
//--------------------------------------------------------------------------------
CUTF8String CUTF16String::ToUTF8String( void )
{
return CUTF8String( *this );
}
