inline size32_t readFile(const char* name,StringBuffer& buf)
{
size32_t sz = 0;
#ifdef _WIN32
int fd = open(name,O_RDONLY|O_BINARY);
if(fd)
{
struct _stat st;
if(!_fstat(fd,&st))
{
void * data = buf.reserve((size32_t)st.st_size);
sz = read(fd, data, st.st_size);
}
close(fd);
}
#else
int fd = open(name,O_RDONLY);
if(fd)
{
struct stat st;
if(!fstat(fd,&st))
{
void * data = buf.reserve((size32_t)st.st_size);
sz = read(fd, data, st.st_size);
}
close(fd);
}
#endif
return sz;
}
static bool
EscapeNakedForwardSlashes(StringBuffer &sb, const CharT *oldChars, size_t oldLen)
{
for (const CharT *it = oldChars; it < oldChars + oldLen; ++it) {
if (*it == '/' && (it == oldChars || it[-1] != '\\')) {
/* There's a forward slash that needs escaping. */
if (sb.empty()) {
/* This is the first one we've seen, copy everything up to this point. */
if (mozilla::IsSame<CharT, jschar>::value && !sb.ensureTwoByteChars())
return false;
if (!sb.reserve(oldLen + 1))
return false;
sb.infallibleAppend(oldChars, size_t(it - oldChars));
}
if (!sb.append('\\'))
return false;
}
if (!sb.empty() && !sb.append(*it))
return false;
}
return true;
}
int main()
{
StringBuffer *a = new StringBuffer();
a->reserve(2);
cout << "Creating a String Buffer a \n\n";
a->append('S');
cout << "Copying String Buffer a to String Buffer b using Copy Constructor\n\n";
StringBuffer *b = new StringBuffer(*a);
cout << "Length of a is: ";
cout << a->length() << endl << endl;
cout << "Length of b is: ";
cout << b->length() << endl << endl;
cout << "That clearly shows resources are owned by b now!" << endl << endl;
//CopyTest();
//CharSToStringBufferTest();
return 0;
}
static MOZ_ALWAYS_INLINE bool
SetupBuffer(StringBuffer& sb, const CharT* oldChars, size_t oldLen, const CharT* it)
{
if (mozilla::IsSame<CharT, char16_t>::value && !sb.ensureTwoByteChars())
return false;
if (!sb.reserve(oldLen + 1))
return false;
sb.infallibleAppend(oldChars, size_t(it - oldChars));
return true;
}
char* FolderData::format() {
StringBuffer out;
out.reserve(150);
out = "<Folder>\n";
if (name.length() > 0)
out += XMLProcessor::makeElement(FOLDER_NAME, name);
if (created.length() > 0)
out += XMLProcessor::makeElement(FOLDER_CREATED, created);
if (modified.length() > 0)
out += XMLProcessor::makeElement(FOLDER_MODIFIED, modified);
if (accessed.length() > 0)
out += XMLProcessor::makeElement(FOLDER_ACCESSED, accessed);
StringBuffer attributes;
if (isHiddenPresent)
attributes += XMLProcessor::makeElement(FOLDER_HIDDEN, hidden);
if (isSystemPresent)
attributes += XMLProcessor::makeElement(FOLDER_SYSTEM, system);
if (isArchivedPresent)
attributes += XMLProcessor::makeElement(FOLDER_ARCHIVED, archived);
if (isDeletedPresent)
attributes += XMLProcessor::makeElement(FOLDER_DELETE, deleted);
if (isWritablePresent)
attributes += XMLProcessor::makeElement(FOLDER_WRITABLE, writable);
if (isReadablePresent)
attributes += XMLProcessor::makeElement(FOLDER_READABLE, readable);
if (isExecutablePresent)
attributes += XMLProcessor::makeElement(FOLDER_EXECUTABLE, executable);
if (!attributes.empty())
out += XMLProcessor::makeElement(FOLDER_ATTRIBUTES, attributes);
if (role.length() > 0)
out += XMLProcessor::makeElement(FOLDER_ROLE, role);
if (!(extended.isEmpty())){
for(int i=0; i < extended.size(); i++){
const char* temp = ((FolderExt*)extended.get(i))->format();
out += temp;
delete [] temp;
}
}
out += "</Folder>\n";
return stringdup(out.c_str());
}
bool SslClientConnection::readClientConnection (StringBuffer& stringBuffer, bool& progress) {
if (_ssl == nullptr || ! _isConnected) {
return false;
}
progress = false;
do {
again:
// reserve some memory for reading
if (stringBuffer.reserve(READBUFFER_SIZE) == TRI_ERROR_OUT_OF_MEMORY) {
// out of memory
TRI_set_errno(TRI_ERROR_OUT_OF_MEMORY);
return false;
}
int lenRead = SSL_read(_ssl, stringBuffer.end(), READBUFFER_SIZE - 1);
switch (SSL_get_error(_ssl, lenRead)) {
case SSL_ERROR_NONE:
progress = true;
stringBuffer.increaseLength(lenRead);
break;
case SSL_ERROR_ZERO_RETURN:
SSL_shutdown(_ssl);
_isConnected = false;
return true;
case SSL_ERROR_WANT_READ:
goto again;
case SSL_ERROR_WANT_WRITE:
case SSL_ERROR_WANT_CONNECT:
case SSL_ERROR_SYSCALL:
default:
/* unexpected */
return false;
}
}
while (readable());
return true;
}
void slurp (string const& filename, StringBuffer& result) {
int fd = TRI_OPEN(filename.c_str(), O_RDONLY);
if (fd == -1) {
THROW_FILE_OPEN_ERROR("open", filename, "O_RDONLY", errno);
}
// reserve space in the output buffer
off_t fileSize = size(filename);
if (fileSize > 0) {
result.reserve((size_t) fileSize);
}
char buffer[10240];
while (true) {
ssize_t n = TRI_READ(fd, buffer, sizeof(buffer));
if (n == 0) {
break;
}
if (n < 0) {
TRI_CLOSE(fd);
LOG_TRACE("read failed for '%s' with %s and result %d on fd %d",
filename.c_str(),
strerror(errno),
(int) n,
fd);
THROW_FILE_FUNC_ERROR("read", "", errno);
}
result.appendText(buffer, n);
}
TRI_CLOSE(fd);
}
char *MailData::format() {
StringBuffer out;
out.reserve(150);
out = "<Email>\n";
out += XMLProcessor::makeElement(EMAIL_READ, read);
out += XMLProcessor::makeElement(EMAIL_FORW, forwarded);
out += XMLProcessor::makeElement(EMAIL_REPL, replied);
out += XMLProcessor::makeElement(EMAIL_TREC, received);
out += XMLProcessor::makeElement(EMAIL_TCRE, created);
out += XMLProcessor::makeElement(EMAIL_TMOD, modified);
out += XMLProcessor::makeElement(EMAIL_DELE, deleted);
out += XMLProcessor::makeElement(EMAIL_FLAG, flagged);
char *item = emailItem.format();
if ( item ) {
out += "<emailitem>\n<![CDATA[";
out += item;
delete [] item;
out += "]]>\n</emailitem>\n";
}
out += "</Email>\n";
return stringdup(out.c_str());
}
//-----------------------------------------------------
//
//-----------------------------------------------------
int main(int argc, char* argv[])
{
#ifdef _NO_LDAP
fprintf(stderr, "System was built with _NO_LDAP\n");
return -1;
#endif
for (int x = 1; x < argc; x++)
{
if (0==strncmp("-h", argv[x], 2))
{
usage();
exit(0);
}
else
{
fprintf(stderr, "\nERROR: Unrecognized parameter : '%s', enter 'initldap -h' for help\n", argv[x]);
exit(1);
}
}
InitModuleObjects();
//execute configgen to query the LDAP Server configuration(s)
StringBuffer cmd;
cmd.appendf("%s%cconfiggen -env %s%c%s -listldapservers", ADMIN_DIR,PATHSEPCHAR,CONFIG_DIR, PATHSEPCHAR, ENV_XML_FILE);
char * configBuffer = NULL;
//acquire LDAP configuration by executing configgen and capturing output
{
StringBuffer configBuff;
Owned<IPipeProcess> pipe = createPipeProcess();
if (pipe->run("configgen", cmd.str(), ".", false, true, true, 0))
{
Owned<ISimpleReadStream> pipeReader = pipe->getOutputStream();
const size32_t chunkSize = 8192;
for (;;)
{
size32_t sizeRead = pipeReader->read(chunkSize, configBuff.reserve(chunkSize));
if (sizeRead < chunkSize)
{
configBuff.setLength(configBuff.length() - (chunkSize - sizeRead));
break;
}
}
pipe->closeOutput();
}
int retcode = pipe->wait();
if (retcode)
{
fprintf(stderr, "\nERROR %d: unable to execute %s", retcode, cmd.str());
exit(1);
}
configBuffer = strdup(configBuff.str());
}
//Using the LDAP Server parms queried from configgen, build an
//LDAPSecurity property tree for each LDAP Server and call the LDAP
//Security Manager to create the needed entries
Owned<IPropertyTree> ldapProps;
char *saveptr;
char * pLine = strtok_r(configBuffer, "\n", &saveptr);
while (pLine)
{
if (pLine && 0==strcmp(pLine, "LDAPServerProcess"))
{
if (ldapProps)
initLDAP(ldapProps);
ldapProps.clear();
ldapProps.setown(createPTree("ldapSecurity"));
}
else
{
char * sep = strchr(pLine, ',');
if (sep)
{
*sep = (char)NULL;
ldapProps->addProp(pLine, sep+1);
}
}
pLine = strtok_r(NULL, "\n", &saveptr);
}
if (ldapProps)
initLDAP(ldapProps);
if (configBuffer)
free(configBuffer);
ldapProps.clear();
releaseAtoms();
return 0;
}
bool SslClientConnection::readClientConnection (StringBuffer& stringBuffer,
bool& connectionClosed) {
#ifdef _WIN32
char windowsErrorBuf[256];
#endif
connectionClosed = true;
if (_ssl == nullptr) {
return false;
}
if (! _isConnected) {
return true;
}
connectionClosed = false;
do {
again:
// reserve some memory for reading
if (stringBuffer.reserve(READBUFFER_SIZE) == TRI_ERROR_OUT_OF_MEMORY) {
// out of memory
TRI_set_errno(TRI_ERROR_OUT_OF_MEMORY);
return false;
}
ERR_clear_error();
int lenRead = SSL_read(_ssl, stringBuffer.end(), READBUFFER_SIZE - 1);
switch (SSL_get_error(_ssl, lenRead)) {
case SSL_ERROR_NONE:
stringBuffer.increaseLength(lenRead);
break;
case SSL_ERROR_ZERO_RETURN:
connectionClosed = true;
SSL_shutdown(_ssl);
_isConnected = false;
return true;
case SSL_ERROR_WANT_READ:
goto again;
case SSL_ERROR_WANT_WRITE:
case SSL_ERROR_WANT_CONNECT:
case SSL_ERROR_SYSCALL:
default: {
char const* pErr = STR_ERROR();
int errorDetail = ERR_get_error();
char errorBuffer[256];
ERR_error_string_n(errorDetail, errorBuffer, sizeof(errorBuffer));
_errorDetails = std::string("SSL: while reading: error '") + std::to_string(errno) +
std::string("' - ") + errorBuffer + std::string("' - ") + pErr;
/* unexpected */
connectionClosed = true;
return false;
}
}
}
while (readable());
return true;
}