/*
- * Copyright (c) 1987-2011 by the citadel.org team
+ * Copyright (c) 1987-2013 by the citadel.org team
*
* This program is open source software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
#include <execinfo.h>
#endif
-#ifdef LINUX_SENDFILE
-#include <sys/sendfile.h>
+#ifdef UNDEF_MEMCPY
+#undef memcpy
#endif
#ifdef HAVE_ZLIB
const Bytef * source, uLong sourceLen, int level);
#endif
int BaseStrBufSize = 64;
+int EnableSplice = 0;
const char *StrBufNOTNULL = ((char*) NULL) - 1;
if (Force ||
(Buf->BufUsed + (Buf->BufUsed / 3) > Buf->BufSize))
{
- char *TmpBuf = (char*) malloc(Buf->BufUsed + 1);
+ char *TmpBuf;
+
+ TmpBuf = (char*) malloc(Buf->BufUsed + 1);
+ if (TmpBuf == NULL)
+ return -1;
+
memcpy (TmpBuf, Buf->buf, Buf->BufUsed + 1);
Buf->BufSize = Buf->BufUsed + 1;
free(Buf->buf);
StrBuf *NewBuf;
NewBuf = (StrBuf*) malloc(sizeof(StrBuf));
+ if (NewBuf == NULL)
+ return NULL;
+
NewBuf->buf = (char*) malloc(BaseStrBufSize);
+ if (NewBuf->buf == NULL)
+ {
+ free(NewBuf);
+ return NULL;
+ }
NewBuf->buf[0] = '\0';
NewBuf->BufSize = BaseStrBufSize;
NewBuf->BufUsed = 0;
return NewStrBuf();
NewBuf = (StrBuf*) malloc(sizeof(StrBuf));
+ if (NewBuf == NULL)
+ return NULL;
+
NewBuf->buf = (char*) malloc(CopyMe->BufSize);
+ if (NewBuf->buf == NULL)
+ {
+ free(NewBuf);
+ return NULL;
+ }
+
memcpy(NewBuf->buf, CopyMe->buf, CopyMe->BufUsed + 1);
NewBuf->BufUsed = CopyMe->BufUsed;
NewBuf->BufSize = CopyMe->BufSize;
size_t CopySize;
NewBuf = (StrBuf*) malloc(sizeof(StrBuf));
+ if (NewBuf == NULL)
+ return NULL;
+
if (nChars < 0)
CopySize = strlen((ptr != NULL)?ptr:"");
else
if (Siz == 0)
{
+ free(NewBuf);
return NULL;
}
StrBuf *NewBuf;
NewBuf = (StrBuf*) malloc(sizeof(StrBuf));
+ if (NewBuf == NULL)
+ return NULL;
NewBuf->buf = (char*) StringConstant;
NewBuf->BufSize = SizeOfStrConstant;
NewBuf->BufUsed = SizeOfStrConstant;
*/
int FlushStrBuf(StrBuf *buf)
{
- if (buf == NULL)
+ if ((buf == NULL) || (buf->buf == NULL))
return -1;
if (buf->ConstBuf)
return -1;
*/
void StrBufAppendBuf(StrBuf *Buf, const StrBuf *AppendBuf, unsigned long Offset)
{
- if ((AppendBuf == NULL) || (Buf == NULL) || (AppendBuf->buf == NULL))
+ if ((AppendBuf == NULL) || (AppendBuf->buf == NULL) ||
+ (Buf == NULL) || (Buf->buf == NULL))
return;
if (Buf->BufSize - Offset < AppendBuf->BufUsed + Buf->BufUsed + 1)
}
if (Offset + nChars < Source->BufUsed)
{
- if (nChars >= dest->BufSize)
- IncreaseBuf(dest, 0, nChars + 1);
+ if ((nChars >= dest->BufSize) &&
+ (IncreaseBuf(dest, 0, nChars + 1) == -1))
+ return 0;
memcpy(dest->buf, Source->buf + Offset, nChars);
dest->BufUsed = nChars;
dest->buf[dest->BufUsed] = '\0';
return nChars;
}
NCharsRemain = Source->BufUsed - Offset;
- if (NCharsRemain >= dest->BufSize)
- IncreaseBuf(dest, 0, NCharsRemain + 1);
+ if ((NCharsRemain >= dest->BufSize) &&
+ (IncreaseBuf(dest, 0, NCharsRemain + 1) == -1))
+ return 0;
memcpy(dest->buf, Source->buf + Offset, NCharsRemain);
dest->BufUsed = NCharsRemain;
dest->buf[dest->BufUsed] = '\0';
*/
void StrBufCutRight(StrBuf *Buf, int nChars)
{
- if ((Buf == NULL) || (Buf->BufUsed == 0)) return;
+ if ((Buf == NULL) || (Buf->BufUsed == 0) || (Buf->buf == NULL))
+ return;
+
if (nChars >= Buf->BufUsed) {
FlushStrBuf(Buf);
return;
void StrBufStripAllBut(StrBuf *Buf, char leftboundary, char rightboundary)
{
- const char *pBuff;
const char *pLeft;
const char *pRight;
- if (Buf == NULL)
+ if ((Buf == NULL) || (Buf->buf == NULL)) {
return;
- pLeft = pBuff = Buf->buf;
- while (pBuff != NULL) {
- pLeft = pBuff;
- pBuff = strchr(pBuff, leftboundary);
- if (pBuff != NULL)
- pBuff++;
}
-
- if (pLeft != NULL)
- pBuff = pLeft;
- else
- pBuff = Buf->buf;
- pRight = strchr(pBuff, rightboundary);
- if (pRight != NULL)
+
+ pRight = strchr(Buf->buf, rightboundary);
+ if (pRight != NULL) {
StrBufCutAt(Buf, 0, pRight);
- if (pLeft != NULL)
- StrBufCutLeft(Buf, pLeft - Buf->buf);
+ }
+ else {
+ StrBufCutAt(Buf, 0, Buf->buf);
+ return;
+ }
+
+ pLeft = strrchr(ChrPtr(Buf), leftboundary);
+ if (pLeft != NULL) {
+ StrBufCutLeft(Buf, pLeft - Buf->buf + 1);
+ }
+ else {
+ StrBufCutAt(Buf, 0, Buf->buf);
+ return;
+ }
}
return ReducedBy;
}
+int StrBufExtract_tokenFromStr(StrBuf *dest, const char *Source, long SourceLen, int parmnum, char separator)
+{
+ const StrBuf Temp = {
+ (char*)Source,
+ SourceLen,
+ SourceLen,
+ 1
+#ifdef SIZE_DEBUG
+ ,
+ 0,
+ "",
+ ""
+#endif
+ };
+
+ return StrBufExtract_token(dest, &Temp, parmnum, separator);
+}
/**
* @ingroup StrBuf_Tokenizer
*pt = '\0';
}
+void StrBufBase64Append(StrBuf *OutBuf, const StrBuf *In, const char *PlainIn, long PlainInLen, int linebreaks)
+{
+ const char *pch;
+ char *pt;
+ int len;
+ long ExpectLen;
+
+ if (((In == NULL) && (PlainIn == NULL)) || (OutBuf == NULL) )
+ return;
+ if (PlainIn != NULL) {
+ if (PlainInLen < 0)
+ len = strlen(PlainIn);
+ else
+ len = PlainInLen;
+ pch = PlainIn;
+ }
+ else {
+ pch = In->buf;
+ len = In->BufUsed;
+ }
+
+ if (len == 0)
+ return;
+
+ ExpectLen = ((len * 134) / 100) + OutBuf->BufUsed;
+
+ if (ExpectLen > OutBuf->BufSize)
+ if (IncreaseBuf(OutBuf, 1, ExpectLen) < ExpectLen)
+ return;
+
+ pt = OutBuf->buf + OutBuf->BufUsed;
+
+ len = CtdlEncodeBase64(pt, pch, len, linebreaks);
+
+ pt += len;
+ OutBuf->BufUsed += len;
+ *pt = '\0';
+}
+
/**
* @ingroup StrBuf_DeEnCoder
* @brief append a string in hex encoding to the buffer
return Target->BufUsed;
}
+
+/**
+ * @ingroup StrBuf_DeEnCoder
+ * @brief replace all non-Ascii characters by another
+ * @param Buf buffer to inspect
+ * @param repl charater to stamp over non ascii chars
+ */
+void StrBufAsciify(StrBuf *Buf, const char repl)
+{
+ long offset;
+
+ for (offset = 0; offset < Buf->BufUsed; offset ++)
+ if (!isascii(Buf->buf[offset]))
+ Buf->buf[offset] = repl;
+
+}
+
/**
* @ingroup StrBuf_DeEnCoder
* @brief unhide special chars hidden to the HTML escaper
int a, b, len;
char hex[3];
- if (target != NULL)
- FlushStrBuf(target);
-
- if (source == NULL ||target == NULL)
+ if ((source == NULL) || (target == NULL) || (target->buf == NULL))
{
return;
}
+ if (target != NULL)
+ FlushStrBuf(target);
+
len = source->BufUsed;
for (a = 0; a < len; ++a) {
if (target->BufUsed >= target->BufSize)
if (target != NULL)
FlushStrBuf(target);
- if (source == NULL ||target == NULL)
+ if ((source == NULL) || (target == NULL) || (target->buf == NULL))
{
return;
}
{
char *xferbuf;
size_t siz;
- if (Buf == NULL) return -1;
+
+ if (Buf == NULL)
+ return -1;
xferbuf = (char*) malloc(Buf->BufSize);
+ if (xferbuf == NULL)
+ return -1;
+
*xferbuf = '\0';
siz = CtdlDecodeBase64(xferbuf,
Buf->buf,
FlushStrBuf(*target);
StrBufAppendBuf(*target, source, 0);
}
- return (*target)->BufUsed;
+ if (*target != 0)
+ return (*target)->BufUsed;
+ else
+ return 0;
}
if (*target == NULL)
*target = NewStrBufPlain(NULL, sizeof(headerStr) + source->BufUsed * 2);
while ((pch != NULL) && (pch < pche))
{
while (isspace(*pch)) pch++;
- UserStart = UserEnd = EmailStart = EmailEnd = NULL;
+ UserEnd = EmailStart = EmailEnd = NULL;
if ((*pch == '"') || (*pch == '\'')) {
UserStart = pch + 1;
EmailStart ++;
if (UserStart >= UserEnd)
UserStart = UserEnd = NULL;
- At = strchr(EmailStart, '@');
}
else { /* this is a local recipient... no domain, just a realname */
EmailStart = UserStart;
size_t obuflen; /**< Length of output buffer */
+ if ((ConvertBuf == NULL) || (TmpBuf == NULL))
+ return;
+
/* since we're converting to utf-8, one glyph may take up to 6 bytes */
if (ConvertBuf->BufUsed * 6 >= TmpBuf->BufSize)
IncreaseBuf(TmpBuf, 0, ConvertBuf->BufUsed * 6);
#endif
const char *eptr;
int passes = 0;
- int i, len;
+ int i;
int illegal_non_rfc2047_encoding = 0;
+
+ if (DecodeMe == NULL)
+ return;
/* Sometimes, badly formed messages contain strings which were simply
* written out directly in some foreign character set instead of
* using RFC2047 encoding. This is illegal but we will attempt to
* charset to UTF-8 if we see any nonprintable characters.
*/
- len = StrLength(DecodeMe);
for (i=0; i<DecodeMe->BufUsed; ++i) {
if ((DecodeMe->buf[i] < 32) || (DecodeMe->buf[i] > 126)) {
illegal_non_rfc2047_encoding = 1;
}
/* pre evaluate the first pair */
- nextend = end = NULL;
- len = StrLength(DecodeMee);
+ end = NULL;
start = strstr(DecodeMee->buf, "=?");
eptr = DecodeMee->buf + DecodeMee->BufUsed;
if (start != NULL)
nFront = start - DecodeMee->buf;
StrBufAppendBufPlain(Target, DecodeMee->buf, nFront, 0);
- len -= nFront;
}
/*
* Since spammers will go to all sorts of absurd lengths to get their
const char *aptr, *ptr, *eptr;
char *optr, *xptr;
+ if ((FB == NULL) || (LineBuf == NULL) || (LineBuf->buf == NULL))
+ return eReadFail;
+
+
if ((FB->Buf == NULL) || (FB->ReadWritePointer == StrBufNOTNULL)) {
FB->ReadWritePointer = StrBufNOTNULL;
return eReadFail;
long IOBufferStrLength(IOBuffer *FB)
{
+ if ((FB == NULL) || (FB->Buf == NULL))
+ return 0;
if (FB->ReadWritePointer == NULL)
return StrLength(FB->Buf);
return StrLength(FB->Buf) - (FB->ReadWritePointer - FB->Buf->buf);
}
-void FDIOBufferInit(FDIOBuffer *FDB, IOBuffer *IO, int FD, long TotalSendSize)
+inline static void FDIOBufferFlush(FDIOBuffer *FDB)
{
memset(FDB, 0, sizeof(FDIOBuffer));
+ FDB->OtherFD = -1;
+ FDB->SplicePipe[0] = -1;
+ FDB->SplicePipe[1] = -1;
+}
+
+void FDIOBufferInit(FDIOBuffer *FDB, IOBuffer *IO, int FD, long TotalSendSize)
+{
+ FDIOBufferFlush(FDB);
FDB->ChunkSize =
FDB->TotalSendSize = TotalSendSize;
FDB->IOB = IO;
-#ifndef LINUX_SENDFILE
- FDB->ChunkBuffer = NewStrBufPlain(NULL, TotalSendSize + 1);
-#else
- pipe(FDB->SplicePipe);
+#ifdef LINUX_SPLICE
+ if (EnableSplice)
+ pipe(FDB->SplicePipe);
+ else
#endif
+ FDB->ChunkBuffer = NewStrBufPlain(NULL, TotalSendSize + 1);
+
FDB->OtherFD = FD;
}
void FDIOBufferDelete(FDIOBuffer *FDB)
{
-#ifndef LINUX_SENDFILE
- FreeStrBuf(&FDB->ChunkBuffer);
-#else
- close(FDB->SplicePipe[0]);
- close(FDB->SplicePipe[1]);
-
+#ifdef LINUX_SPLICE
+ if (EnableSplice)
+ {
+ if (FDB->SplicePipe[0] > 0)
+ close(FDB->SplicePipe[0]);
+ if (FDB->SplicePipe[1] > 0)
+ close(FDB->SplicePipe[1]);
+ }
+ else
#endif
- close(FDB->OtherFD);
- memset(FDB, 0, sizeof(FDIOBuffer));
+ FreeStrBuf(&FDB->ChunkBuffer);
+
+ if (FDB->OtherFD > 0)
+ close(FDB->OtherFD);
+ FDIOBufferFlush(FDB);
}
int FileSendChunked(FDIOBuffer *FDB, const char **Err)
{
- char *pRead;
- long nRead = 0;
-
-#ifdef LINUX_SENDFILE
- ssize_t sent;
- sent = sendfile(FDB->IOB->fd, FDB->OtherFD, &FDB->TotalSentAlready, FDB->ChunkSendRemain);
- if (sent == -1)
+ ssize_t sent, pipesize;
+#ifdef LINUX_SPLICE
+ if (EnableSplice)
{
- *Err = strerror(errno);
+ if (FDB->PipeSize == 0)
+ {
+ pipesize = splice(FDB->OtherFD,
+ &FDB->TotalSentAlready,
+ FDB->SplicePipe[1],
+ NULL,
+ FDB->ChunkSendRemain,
+ SPLICE_F_MOVE);
+
+ if (pipesize == -1)
+ {
+ *Err = strerror(errno);
+ return pipesize;
+ }
+ FDB->PipeSize = pipesize;
+ }
+ sent = splice(FDB->SplicePipe[0],
+ NULL,
+ FDB->IOB->fd,
+ NULL,
+ FDB->PipeSize,
+ SPLICE_F_MORE | SPLICE_F_MOVE | SPLICE_F_NONBLOCK);
+ if (sent == -1)
+ {
+ *Err = strerror(errno);
+ return sent;
+ }
+ FDB->PipeSize -= sent;
+ FDB->ChunkSendRemain -= sent;
return sent;
}
- FDB->ChunkSendRemain -= sent;
- FDB->TotalSentAlready += sent;
- return FDB->ChunkSendRemain;
-#else
- pRead = FDB->ChunkBuffer->buf;
- while ((FDB->ChunkBuffer->BufUsed < FDB->TotalSendSize) && (nRead >= 0))
+ else
+#endif
{
- nRead = read(FDB->OtherFD, pRead, FDB->TotalSendSize - FDB->ChunkBuffer->BufUsed);
- if (nRead > 0) {
- FDB->ChunkBuffer->BufUsed += nRead;
- FDB->ChunkBuffer->buf[FDB->ChunkBuffer->BufUsed] = '\0';
- }
- else if (nRead == 0) {}
- else return nRead;
+ char *pRead;
+ long nRead = 0;
+
+ pRead = FDB->ChunkBuffer->buf;
+ while ((FDB->ChunkBuffer->BufUsed < FDB->TotalSendSize) && (nRead >= 0))
+ {
+ nRead = read(FDB->OtherFD, pRead, FDB->TotalSendSize - FDB->ChunkBuffer->BufUsed);
+ if (nRead > 0) {
+ FDB->ChunkBuffer->BufUsed += nRead;
+ FDB->ChunkBuffer->buf[FDB->ChunkBuffer->BufUsed] = '\0';
+ }
+ else if (nRead == 0) {}
+ else return nRead;
- }
+ }
- nRead = write(FDB->IOB->fd, FDB->ChunkBuffer->buf + FDB->TotalSentAlready, FDB->ChunkSendRemain);
+ nRead = write(FDB->IOB->fd, FDB->ChunkBuffer->buf + FDB->TotalSentAlready, FDB->ChunkSendRemain);
- if (nRead >= 0) {
- FDB->TotalSentAlready += nRead;
- FDB->ChunkSendRemain -= nRead;
- return FDB->ChunkSendRemain;
- }
- else {
- return nRead;
+ if (nRead >= 0) {
+ FDB->TotalSentAlready += nRead;
+ FDB->ChunkSendRemain -= nRead;
+ return FDB->ChunkSendRemain;
+ }
+ else {
+ return nRead;
+ }
}
-#endif
}
int FileRecvChunked(FDIOBuffer *FDB, const char **Err)
{
ssize_t sent, pipesize;
-#ifdef LINUX_SENDFILE
-
- pipesize = splice(FDB->IOB->fd, NULL,
- FDB->SplicePipe[1], NULL,
- FDB->ChunkSendRemain,
- SPLICE_F_MORE | SPLICE_F_MOVE|SPLICE_F_NONBLOCK);
- if (pipesize == -1)
+#ifdef LINUX_SPLICE
+ if (EnableSplice)
{
- *Err = strerror(errno);
- return pipesize;
- }
+ if (FDB->PipeSize == 0)
+ {
+ pipesize = splice(FDB->IOB->fd,
+ NULL,
+ FDB->SplicePipe[1],
+ NULL,
+ FDB->ChunkSendRemain,
+ SPLICE_F_MORE | SPLICE_F_MOVE|SPLICE_F_NONBLOCK);
+
+ if (pipesize == -1)
+ {
+ *Err = strerror(errno);
+ return pipesize;
+ }
+ FDB->PipeSize = pipesize;
+ }
- sent = splice(FDB->SplicePipe[0], NULL,
- FDB->OtherFD, &FDB->TotalSentAlready,
- pipesize, SPLICE_F_MORE | SPLICE_F_MOVE);
- if (sent == -1)
- {
- *Err = strerror(errno);
+ sent = splice(FDB->SplicePipe[0],
+ NULL,
+ FDB->OtherFD,
+ &FDB->TotalSentAlready,
+ FDB->PipeSize,
+ SPLICE_F_MORE | SPLICE_F_MOVE);
+
+ if (sent == -1)
+ {
+ *Err = strerror(errno);
+ return sent;
+ }
+ FDB->PipeSize -= sent;
+ FDB->ChunkSendRemain -= sent;
return sent;
}
- FDB->ChunkSendRemain -= sent;
- return sent;
-#else
-
- sent = read(FDB->IOB->fd, FDB->ChunkBuffer->buf, FDB->ChunkSendRemain);
- if (sent > 0) {
- int nWritten = 0;
- int rc;
+ else
+#endif
+ {
+ sent = read(FDB->IOB->fd, FDB->ChunkBuffer->buf, FDB->ChunkSendRemain);
+ if (sent > 0) {
+ int nWritten = 0;
+ int rc;
- FDB->ChunkBuffer->BufUsed = sent;
+ FDB->ChunkBuffer->BufUsed = sent;
+
+ while (nWritten < FDB->ChunkBuffer->BufUsed) {
+ rc = write(FDB->OtherFD, FDB->ChunkBuffer->buf + nWritten, FDB->ChunkBuffer->BufUsed - nWritten);
+ if (rc < 0) {
+ *Err = strerror(errno);
+ return rc;
+ }
+ nWritten += rc;
- while (nWritten < FDB->ChunkBuffer->BufUsed) {
- rc = write(FDB->OtherFD, FDB->ChunkBuffer->buf + nWritten, FDB->ChunkBuffer->BufUsed - nWritten);
- if (rc < 0) {
- *Err = strerror(errno);
- return rc;
}
- nWritten += rc;
+ FDB->ChunkBuffer->BufUsed = 0;
+ FDB->TotalSentAlready += sent;
+ FDB->ChunkSendRemain -= sent;
+ return FDB->ChunkSendRemain;
+ }
+ else if (sent < 0) {
+ *Err = strerror(errno);
+ return sent;
+ }
+ return 0;
+ }
+}
+int FileMoveChunked(FDIOBuffer *FDB, const char **Err)
+{
+ ssize_t sent, pipesize;
+
+#ifdef LINUX_SPLICE
+ if (EnableSplice)
+ {
+ if (FDB->PipeSize == 0)
+ {
+ pipesize = splice(FDB->IOB->fd,
+ &FDB->TotalReadAlready,
+ FDB->SplicePipe[1],
+ NULL,
+ FDB->ChunkSendRemain,
+ SPLICE_F_MORE | SPLICE_F_MOVE|SPLICE_F_NONBLOCK);
+
+ if (pipesize == -1)
+ {
+ *Err = strerror(errno);
+ return pipesize;
+ }
+ FDB->PipeSize = pipesize;
+ }
+
+ sent = splice(FDB->SplicePipe[0],
+ NULL,
+ FDB->OtherFD,
+ &FDB->TotalSentAlready,
+ FDB->PipeSize,
+ SPLICE_F_MORE | SPLICE_F_MOVE);
+
+ if (sent == -1)
+ {
+ *Err = strerror(errno);
+ return sent;
}
- FDB->ChunkBuffer->BufUsed = 0;
- FDB->TotalSentAlready += sent;
+ FDB->PipeSize -= sent;
FDB->ChunkSendRemain -= sent;
- return FDB->ChunkSendRemain;
- }
- else if (sent < 0) {
- *Err = strerror(errno);
return sent;
}
+ else
+#endif
+ {
+ sent = read(FDB->IOB->fd, FDB->ChunkBuffer->buf, FDB->ChunkSendRemain);
+ if (sent > 0) {
+ int nWritten = 0;
+ int rc;
+
+ FDB->ChunkBuffer->BufUsed = sent;
-#endif
- return 0;
+ while (nWritten < FDB->ChunkBuffer->BufUsed) {
+ rc = write(FDB->OtherFD, FDB->ChunkBuffer->buf + nWritten, FDB->ChunkBuffer->BufUsed - nWritten);
+ if (rc < 0) {
+ *Err = strerror(errno);
+ return rc;
+ }
+ nWritten += rc;
+
+ }
+ FDB->ChunkBuffer->BufUsed = 0;
+ FDB->TotalSentAlready += sent;
+ FDB->ChunkSendRemain -= sent;
+ return FDB->ChunkSendRemain;
+ }
+ else if (sent < 0) {
+ *Err = strerror(errno);
+ return sent;
+ }
+ return 0;
+ }
}
eReadState WriteIOBAlreadyRead(FDIOBuffer *FDB, const char **Error)
{
int len, rlen, slen;
+ if ((buf == NULL) || (buf->buf == NULL)) {
+ *Error = strerror(EINVAL);
+ return -1;
+ }
+
if (!append)
FlushStrBuf(buf);
nSuccessLess = 0;
buf->BufUsed += rlen;
buf->buf[buf->BufUsed] = '\0';
- if (buf->BufUsed + 10 > buf->BufSize) {
- IncreaseBuf(buf, 1, -1);
- }
pch = strchr(buf->buf, '\n');
+ if ((pch == NULL) &&
+ (buf->BufUsed + 10 > buf->BufSize) &&
+ (IncreaseBuf(buf, 1, -1) == -1))
+ return -1;
continue;
}
continue;
}
+ else
+ {
+ nSuccessLess++;
+ }
}
*Pos = NULL;
if (pLF != NULL) {
struct timeval tv;
fd_set rfds;
- if ((Buf == NULL) || (*fd == -1))
+ if ((Buf == NULL) || (Buf->buf == NULL) || (*fd == -1))
{
*Error = ErrRBLF_BLOBPreConditionFailed;
return -1;
{
const char *pos;
int fdflags;
- int len = 0;
- int rlen;
+ int rlen = 0;
int nRead = 0;
int nAlreadyRead = 0;
int IsNonBlock;
int nSuccessLess = 0;
int MaxTries;
- if ((Blob == NULL) || (*fd == -1) || (IOBuf == NULL) || (Pos == NULL))
+ if ((Blob == NULL) ||
+ (*fd == -1) ||
+ (IOBuf == NULL) ||
+ (Pos == NULL))
{
- if (*Pos != NULL)
+ if (Pos != NULL)
*Pos = NULL;
*Error = ErrRBB_BLOBFPreConditionFailed;
return -1;
pos = *Pos;
if (pos != NULL)
- len = pos - IOBuf->buf;
- rlen = IOBuf->BufUsed - len;
+ rlen = pos - IOBuf->buf;
+ rlen = IOBuf->BufUsed - rlen;
if ((IOBuf->BufUsed > 0) &&
IncreaseBuf(IOBuf, 0, nBytes - nRead);
ptr = IOBuf->buf;
- len = Blob->BufUsed;
-
fdflags = fcntl(*fd, F_GETFL);
IsNonBlock = (fdflags & O_NONBLOCK) == O_NONBLOCK;
if (IsNonBlock)
const char *aptr, *ptr, *eptr;
char *optr, *xptr;
- if ((Buf == NULL) || (*Ptr == StrBufNOTNULL)) {
+ if ((Buf == NULL) ||
+ (*Ptr == StrBufNOTNULL) ||
+ (LineBuf == NULL)||
+ (LineBuf->buf == NULL))
+ {
*Ptr = StrBufNOTNULL;
return 0;
}