//
// Handler
//
INT_32 FnTruncate::Handler(CDT * aArguments,
const UINT_32 iArgNum,
CDT & oCDTRetVal,
Logger & oLogger)
{
if (iArgNum == 2)
{
const UINT_32 iMaxLen = UINT_32(aArguments[0].GetInt());
const STLW::string sData = aArguments[1].GetString();
if (sData.size() > iMaxLen) { oCDTRetVal = STLW::string(sData, 0, iMaxLen); }
else { oCDTRetVal = sData; }
return 0;
}
else if (iArgNum == 3)
{
const UINT_32 iMaxLen = UINT_32(aArguments[1].GetInt());
STLW::string sData = aArguments[2].GetString();
if (sData.size() > iMaxLen)
{
sData = STLW::string(sData, 0, iMaxLen);
sData.append(aArguments[0].GetString());
}
oCDTRetVal = sData;
return 0;
}
oLogger.Emerg("Usage: TRUNCATE(x, offest[, addon])");
return -1;
}
//
// Write buffer to the file
//
void MultipartParser::WriteFile(CCHAR_P szStart,
CCHAR_P szEnd)
{
const UINT_32 iBufSize = szEnd - szStart;
if (iBufSize == 0) { return; }
//oLogger.Error("WRITE %u byte(s)", iBufSize);
if (F == NULL) { return; }
if (fwrite(szStart, 1, iBufSize, F) == iBufSize)
{
oFile.filesize += iBufSize;
return;
}
oLogger.Error("CAS: Cannot write data(%u bytes) to file \"%s\": %s", UINT_32(iBufSize), oFile.tmp_name.c_str(), strerror(errno));
}
//
// Get configuration from variant data type
//
ServiceConfig::State ServiceConfig::GetConfig(const VariantNC & oData,
ServiceConfig & oServiceConfig,
Logger & oLogger)
{
// Allow connection from specified IP's or subnets
if (ParseNetworks(oData, "AllowConnect", oServiceConfig, oServiceConfig.ipv4_allowed_networks, oLogger) != OK)
{
return CONFIG_ERROR;
}
// Deny connection from specified IP's or subnets
if (ParseNetworks(oData, "DenyConnect", oServiceConfig, oServiceConfig.ipv4_denied_networks, oLogger) != OK)
{
return CONFIG_ERROR;
}
// Order of networks check
oServiceConfig.allow_deny_order = ALLOW_DENY;
const STLW::vector<STLW::string> vDenyAllow = oData["AllowDenyOrder"];
if (!vDenyAllow.empty() && vDenyAllow[0] != "")
{
if (vDenyAllow.size() != 2)
{
oLogger.Emerg("Invalid format of parameter `Service/%s/AllowDenyOrder`: need `allow deny` or `deny allow`", oServiceConfig.name.c_str());
return CONFIG_ERROR;
}
if (Unicode::CompareIgnoreCase(vDenyAllow[0].data(), vDenyAllow[0].size(), "deny", sizeof("deny") - 1) == 0)
{
oServiceConfig.allow_deny_order = DENY_ALLOW;
}
}
// Listen to inteface
STLW::vector<STLW::string> vListen;
ConfigHelper::GetList(oData["Listen"], vListen);
STLW::vector<STLW::string>::const_iterator itvListen = vListen.begin();
while(itvListen != vListen.end())
{
ListenInterface oInterface;
ConfigHelper::State oRC = ConfigHelper::ParseAddress(*itvListen, oInterface.af, oInterface.address, oInterface.port);
if (oRC != ConfigHelper::OK)
{
oLogger.Emerg("Invalid address: `%s`", itvListen -> c_str());
return CONFIG_ERROR;
}
oServiceConfig.listen.push_back(oInterface);
++itvListen;
}
// Socket listen queue
oServiceConfig.listen_queue = oData["MaxQueueLength"];
if (oServiceConfig.listen_queue == 0)
{
oLogger.Emerg("Invalid format of parameter `Service/%s/MaxQueueLength` not set", oServiceConfig.name.c_str());
return CONFIG_ERROR;
}
// Read buffer size
oServiceConfig.recv_buffer_size = ConfigHelper::ParseSize(oData["RecvBufferSize"]);
if (oServiceConfig.recv_buffer_size == 0 || oServiceConfig.recv_buffer_size == UINT_32(-1))
{
oLogger.Emerg("Invalid format of parameter `Service/%s/RecvBufferSize` not set", oServiceConfig.name.c_str());
return CONFIG_ERROR;
}
// Maximum number of connections for this service
oServiceConfig.max_clients = oData["MaxClients"];
if (oServiceConfig.max_clients == 0) { oLogger.Warn("Parameter `Service/%s/MaxClients`: not set", oServiceConfig.name.c_str()); }
// Number of active clients
oServiceConfig.active_clients = 0;
// Read/Write timeout
oServiceConfig.io_timeout = ConfigHelper::ParseTimeout(oData["IOTimeout"]) / 1000.0;
if (oServiceConfig.io_timeout == 0)
{
oLogger.Emerg("Parameter `Service/%s/IOTimeout`: need to set positive value", oServiceConfig.name.c_str());
return CONFIG_ERROR;
}
#ifdef IRIS_TLS_SUPPORT
// TLS parameters
oServiceConfig.enable_ssl_tls = ConfigHelper::ParseBool(oData["EnableTLSSSL"]);
if (oServiceConfig.enable_ssl_tls)
{
// File with the RSA certificate in PEM format.
oServiceConfig.tls_cert_file = oData["TLSCertFile"];
// File with the RSA private key in PEM format
oServiceConfig.tls_key_file = oData["TLSKeyFile"];
// File with the DH data
oServiceConfig.dh_file.assign(oData["DHFile"]);
// SSL Ciphers
oServiceConfig.ciphers.assign(oData["SSLCiphers"]);
if (oServiceConfig.tls_cert_file.size() != oServiceConfig.tls_key_file.size())
{
oLogger.Emerg("Number of files `Service/%s/TLSCertFile` and Service/%s/TLSKeyFile` must be equal", oServiceConfig.name.c_str());
return CONFIG_ERROR;
}
// Use Transport Level Security at connection time
oServiceConfig.use_tls = ConfigHelper::ParseBool(oData["UseTLS"]);
// Allow upgrade an existing insecure connection to a secure connection using SSL/TLS
oServiceConfig.start_tls = ConfigHelper::ParseBool(oData["StartTLS"]);
// Prefer to user server ciphers
oServiceConfig.prefer_server_ciphers = ConfigHelper::ParseBool(oData["PreferServerCiphers"], true);
}
#endif // IRIS_TLS_SUPPORT
// Handler name
oServiceConfig.handler_name.assign(oData["Handler"]);
// Handler object
oServiceConfig.handler = NULL;
return OK;
}
//
// Handler
//
INT_32 FnMBTruncate::Handler(CDT * aArguments,
const UINT_32 iArgNum,
CDT & oCDTRetVal,
Logger & oLogger)
{
if (iArgNum == 2)
{
const UINT_32 iMaxLen = UINT_32(aArguments[0].GetInt());
const STLW::string sData = aArguments[1].GetString();
CCHAR_P szStart = sData.data();
CCHAR_P szEnd = sData.data() + sData.size();
INT_32 iPos = 0;
UINT_32 iCharPos = 0;
for(;;)
{
INT_32 iCharLen = utf_charlen(szStart + iPos, szEnd);
if (iCharLen == -3) { break; }
// Check character length
if (iCharLen < 0) { iCharLen = 1; }
// Skip errors
else { ++iCharPos; }
iPos += iCharLen;
if (iCharPos >= iMaxLen) { break; }
}
if (iCharPos == iMaxLen) { oCDTRetVal = STLW::string(sData, 0, iPos); }
else { oCDTRetVal = sData; }
return 0;
}
else if (iArgNum == 3)
{
const UINT_32 iMaxLen = UINT_32(aArguments[1].GetInt());
STLW::string sData = aArguments[2].GetString();
CCHAR_P szStart = sData.data();
CCHAR_P szEnd = sData.data() + sData.size();
INT_32 iPos = 0;
UINT_32 iCharPos = 0;
for(;;)
{
INT_32 iCharLen = utf_charlen(szStart + iPos, szEnd);
if (iCharLen == -3) { break; }
// Check character length
if (iCharLen < 0) { iCharLen = 1; }
// Skip errors
else { ++iCharPos; }
iPos += iCharLen;
if (iCharPos >= iMaxLen) { break; }
}
if (iCharPos >= iMaxLen)
{
sData = STLW::string(sData, 0, iPos);
sData.append(aArguments[0].GetString());
}
oCDTRetVal = sData;
return 0;
}
oLogger.Emerg("Usage: MB_TRUNCATE(data, offset) or MB_TRUNCATE(data, offset, add_on)");
return -1;
}
//
// Handler
//
INT_32 FnMBSubstring::Handler(CDT * aArguments,
const UINT_32 iArgNum,
CDT & oCDTRetVal,
Logger & oLogger)
{
// Check number of parameters
if (iArgNum == 0) { oCDTRetVal = ""; return 0; }
// substr('foobar', 2) -> 'obar'
if (iArgNum == 2)
{
const UINT_32 iOffset = UINT_32(aArguments[0].GetInt());
const STLW::string sResult = aArguments[1].GetString();
CCHAR_P szStart = sResult.data();
CCHAR_P szEnd = sResult.data() + sResult.size();
INT_32 iPos = 0;
UINT_32 iCharPos = 0;
for(;;)
{
INT_32 iCharLen = utf_charlen(szStart + iPos, szEnd);
if (iCharLen == -3) { break; }
// Check character length
if (iCharLen < 0) { iCharLen = 1; }
// Skip errors
else { ++iCharPos; }
iPos += iCharLen;
if (iCharPos >= iOffset) { break; }
}
if (iCharPos < iOffset) { oCDTRetVal = ""; }
else { oCDTRetVal = sResult.substr(iPos); }
return 0;
}
// substr('foobar', 2, 3) -> 'oba'
if (iArgNum == 3)
{
const UINT_32 iBytes = UINT_32(aArguments[0].GetInt());
const UINT_32 iOffset = UINT_32(aArguments[1].GetInt());
const STLW::string sResult = aArguments[2].GetString();
CCHAR_P szStart = sResult.data();
CCHAR_P szEnd = sResult.data() + sResult.size();
INT_32 iPos = 0;
UINT_32 iCharOffset = 0;
UINT_32 iCharPos = 0;
for(;;)
{
INT_32 iCharLen = utf_charlen(szStart + iPos, szEnd);
if (iCharLen == -3) { break; }
// Check character length
if (iCharLen < 0) { iCharLen = 1; }
// Skip errors
else { ++iCharPos; }
iPos += iCharLen;
if (iCharPos == iOffset) { iCharOffset = iPos; }
if (iCharPos == iOffset + iBytes) { break; }
}
if (sResult.size() < iCharOffset) { oCDTRetVal = ""; }
else { oCDTRetVal = sResult.substr(iCharOffset, iPos - iCharOffset); }
return 0;
}
// substr('foobar', 2, 3, '1234567') -> 'fo1234567r'
if (iArgNum == 4)
{
STLW::string sReplacement = aArguments[0].GetString();
const UINT_32 iBytes = UINT_32(aArguments[1].GetInt());
const UINT_32 iOffset = UINT_32(aArguments[2].GetInt());
const STLW::string sTMP = aArguments[3].GetString();
CCHAR_P szStart = sTMP.data();
CCHAR_P szEnd = sTMP.data() + sTMP.size();
UINT_32 iPos = 0;
UINT_32 iCharOffset = 0;
UINT_32 iCharPos = 0;
for(;;)
{
INT_32 iCharLen = utf_charlen(szStart + iPos, szEnd);
if (iCharLen == -3) { break; }
// Check character length
if (iCharLen < 0) { iCharLen = 1; }
// Skip errors
else { ++iCharPos; }
iPos += iCharLen;
if (iCharPos == iOffset) { iCharOffset = iPos; }
if (iCharPos == iOffset + iBytes) { break; }
}
if (sTMP.size() < iCharOffset) { oCDTRetVal = ""; return 0; }
STLW::string sResult(sTMP, 0, iCharOffset);
sResult.append(sReplacement);
if (iPos == sTMP.size()) { oCDTRetVal = sResult; return 0; }
sResult.append(sTMP, iPos, STLW::string::npos);
oCDTRetVal = sResult;
return 0;
}
oLogger.Emerg("Usage: MB_SUBSTR(x, offset[, bytes[, y]]])");
return -1;
}
