/* Verbose logging callback */
void cdb_verbose_err(const DB_ENV *dbenv, const char *errpfx, const char *msg)
{
int *FOO = NULL;
syslog(LOG_ALERT, "DB: %s", msg);
cit_backtrace();
*FOO = 1;
}
/* Verbose logging callback */
void cdb_verbose_log(const DB_ENV *dbenv, const char *msg)
{
if (!IsEmptyStr(msg)) {
syslog(LOG_DEBUG, "DB: %s", msg);
cit_backtrace();
}
}
void cdb_abort(void) {
syslog(LOG_DEBUG,
"citserver is stopping in order to prevent data loss. uid=%d gid=%d euid=%d egid=%d",
getuid(),
getgid(),
geteuid(),
getegid()
);
cit_backtrace();
exit(CTDLEXIT_DB);
}
static void
IO_recv_callback(struct ev_loop *loop, ev_io *watcher, int revents)
{
const char *errmsg;
ssize_t nbytes;
AsyncIO *IO = watcher->data;
SET_EV_TIME(IO, event_base);
switch (IO->NextState) {
case eReadFile:
nbytes = FileRecvChunked(&IO->IOB, &errmsg);
if (nbytes < 0)
StrBufPlain(IO->ErrMsg, errmsg, -1);
else
{
if (IO->IOB.ChunkSendRemain == 0)
{
IO->NextState = eSendReply;
assert(IO->ReadDone);
ev_io_stop(event_base, &IO->recv_event);
PostInbound(IO);
return;
}
else
return;
}
break;
default:
nbytes = StrBuf_read_one_chunk_callback(IO->RecvBuf.fd,
0,
&IO->RecvBuf);
break;
}
#ifdef BIGBAD_IODBG
{
long nbytes;
int rv = 0;
char fn [SIZ];
FILE *fd;
const char *pch = ChrPtr(IO->RecvBuf.Buf);
const char *pchh = IO->RecvBuf.ReadWritePointer;
if (pchh == NULL)
pchh = pch;
nbytes = StrLength(IO->RecvBuf.Buf) - (pchh - pch);
snprintf(fn, SIZ, "/tmp/foolog_ev_%s.%d",
((CitContext*)(IO->CitContext))->ServiceName,
IO->SendBuf.fd);
fd = fopen(fn, "a+");
if (fd == NULL) {
syslog(LOG_EMERG, "failed to open file %s: %s", fn, strerror(errno));
cit_backtrace();
exit(1);
}
fprintf(fd, "Read: BufSize: %ld BufContent: [",
nbytes);
rv = fwrite(pchh, nbytes, 1, fd);
if (!rv) printf("failed to write debug to %s!\n", fn);
fprintf(fd, "]\n");
fclose(fd);
}
#endif
if (nbytes > 0) {
HandleInbound(IO);
} else if (nbytes == 0) {
StopClientWatchers(IO, 1);
SetNextTimeout(IO, 0.01);
return;
} else if (nbytes == -1) {
if (errno != EAGAIN) {
// FD is gone. kick it.
StopClientWatchers(IO, 1);
EV_syslog(LOG_DEBUG,
"IO_recv_callback(): Socket Invalid! [%d] [%s] [%d]\n",
errno, strerror(errno), IO->SendBuf.fd);
StrBufPrintf(IO->ErrMsg,
"Socket Invalid! [%s]",
strerror(errno));
SetNextTimeout(IO, 0.01);
}
return;
}
}
static void
IO_send_callback(struct ev_loop *loop, ev_io *watcher, int revents)
{
int rc;
AsyncIO *IO = watcher->data;
const char *errmsg = NULL;
SET_EV_TIME(IO, event_base);
become_session(IO->CitContext);
#ifdef BIGBAD_IODBG
{
int rv = 0;
char fn [SIZ];
FILE *fd;
const char *pch = ChrPtr(IO->SendBuf.Buf);
const char *pchh = IO->SendBuf.ReadWritePointer;
long nbytes;
if (pchh == NULL)
pchh = pch;
nbytes = StrLength(IO->SendBuf.Buf) - (pchh - pch);
snprintf(fn, SIZ, "/tmp/foolog_ev_%s.%d",
((CitContext*)(IO->CitContext))->ServiceName,
IO->SendBuf.fd);
fd = fopen(fn, "a+");
if (fd == NULL) {
syslog(LOG_EMERG, "failed to open file %s: %s", fn, strerror(errno));
cit_backtrace();
exit(1);
}
fprintf(fd, "Send: BufSize: %ld BufContent: [",
nbytes);
rv = fwrite(pchh, nbytes, 1, fd);
if (!rv) printf("failed to write debug to %s!\n", fn);
fprintf(fd, "]\n");
#endif
switch (IO->NextState) {
case eSendFile:
rc = FileSendChunked(&IO->IOB, &errmsg);
if (rc < 0)
StrBufPlain(IO->ErrMsg, errmsg, -1);
break;
default:
rc = StrBuf_write_one_chunk_callback(IO->SendBuf.fd,
0,
&IO->SendBuf);
}
#ifdef BIGBAD_IODBG
fprintf(fd, "Sent: BufSize: %d bytes.\n", rc);
fclose(fd);
}
#endif
if (rc == 0)
{
ev_io_stop(event_base, &IO->send_event);
switch (IO->NextState) {
case eSendMore:
assert(IO->SendDone);
IO->NextState = IO->SendDone(IO);
if ((IO->NextState == eTerminateConnection) ||
(IO->NextState == eAbort) )
ShutDownCLient(IO);
else {
ev_io_start(event_base, &IO->send_event);
}
break;
case eSendFile:
if (IO->IOB.ChunkSendRemain > 0) {
ev_io_start(event_base, &IO->recv_event);
SetNextTimeout(IO, 100.0);
} else {
assert(IO->ReadDone);
IO->NextState = IO->ReadDone(IO);
switch(IO->NextState) {
case eSendDNSQuery:
case eReadDNSReply:
case eDBQuery:
case eConnect:
break;
case eSendReply:
case eSendMore:
case eSendFile:
ev_io_start(event_base,
&IO->send_event);
break;
case eReadMessage:
case eReadMore:
case eReadPayload:
case eReadFile:
break;
case eTerminateConnection:
case eAbort:
break;
}
}
break;
case eSendReply:
if (StrBufCheckBuffer(&IO->SendBuf) != eReadSuccess)
break;
IO->NextState = eReadMore;
case eReadMore:
case eReadMessage:
case eReadPayload:
case eReadFile:
if (StrBufCheckBuffer(&IO->RecvBuf) == eBufferNotEmpty)
{
HandleInbound(IO);
}
else {
ev_io_start(event_base, &IO->recv_event);
}
break;
case eDBQuery:
/*
* we now live in another queue,
* so we have to unregister.
*/
ev_cleanup_stop(loop, &IO->abort_by_shutdown);
break;
case eSendDNSQuery:
case eReadDNSReply:
case eConnect:
case eTerminateConnection:
case eAbort:
break;
}
}
else if (rc < 0) {
if (errno != EAGAIN) {
StopClientWatchers(IO, 1);
EV_syslog(LOG_DEBUG,
"IO_send_callback(): Socket Invalid! [%d] [%s] [%d]\n",
errno, strerror(errno), IO->SendBuf.fd);
StrBufPrintf(IO->ErrMsg,
"Socket Invalid! [%s]",
strerror(errno));
SetNextTimeout(IO, 0.01);
}
}
/* else : must write more. */
}
static void dbpanic(DB_ENV * env, int errval)
{
syslog(LOG_EMERG, "bdb(): PANIC: %s", db_strerror(errval));
cit_backtrace();
}
char *qp_encode_email_addrs(char *source)
{
struct CitContext *CCC = CC;
char *user, *node, *name;
const char headerStr[] = "=?UTF-8?Q?";
char *Encoded;
char *EncodedName;
char *nPtr;
int need_to_encode = 0;
long SourceLen;
long EncodedMaxLen;
long nColons = 0;
long *AddrPtr;
long *AddrUtf8;
long nAddrPtrMax = 50;
long nmax;
int InQuotes = 0;
int i, n;
if (source == NULL) return source;
if (IsEmptyStr(source)) return source;
if (MessageDebugEnabled != 0) cit_backtrace();
MSG_syslog(LOG_DEBUG, "qp_encode_email_addrs: [%s]\n", source);
AddrPtr = malloc (sizeof (long) * nAddrPtrMax);
AddrUtf8 = malloc (sizeof (long) * nAddrPtrMax);
memset(AddrUtf8, 0, sizeof (long) * nAddrPtrMax);
*AddrPtr = 0;
i = 0;
while (!IsEmptyStr (&source[i])) {
if (nColons >= nAddrPtrMax){
long *ptr;
ptr = (long *) malloc(sizeof (long) * nAddrPtrMax * 2);
memcpy (ptr, AddrPtr, sizeof (long) * nAddrPtrMax);
free (AddrPtr), AddrPtr = ptr;
ptr = (long *) malloc(sizeof (long) * nAddrPtrMax * 2);
memset(&ptr[nAddrPtrMax], 0,
sizeof (long) * nAddrPtrMax);
memcpy (ptr, AddrUtf8, sizeof (long) * nAddrPtrMax);
free (AddrUtf8), AddrUtf8 = ptr;
nAddrPtrMax *= 2;
}
if (((unsigned char) source[i] < 32) ||
((unsigned char) source[i] > 126)) {
need_to_encode = 1;
AddrUtf8[nColons] = 1;
}
if (source[i] == '"')
InQuotes = !InQuotes;
if (!InQuotes && source[i] == ',') {
AddrPtr[nColons] = i;
nColons++;
}
i++;
}
if (need_to_encode == 0) {
free(AddrPtr);
free(AddrUtf8);
return source;
}
SourceLen = i;
EncodedMaxLen = nColons * (sizeof(headerStr) + 3) + SourceLen * 3;
Encoded = (char*) malloc (EncodedMaxLen);
for (i = 0; i < nColons; i++)
source[AddrPtr[i]++] = '\0';
/* TODO: if libidn, this might get larger*/
user = malloc(SourceLen + 1);
node = malloc(SourceLen + 1);
name = malloc(SourceLen + 1);
nPtr = Encoded;
*nPtr = '\0';
for (i = 0; i < nColons && nPtr != NULL; i++) {
nmax = EncodedMaxLen - (nPtr - Encoded);
if (AddrUtf8[i]) {
process_rfc822_addr(&source[AddrPtr[i]],
user,
node,
name);
/* TODO: libIDN here ! */
if (IsEmptyStr(name)) {
n = snprintf(nPtr, nmax,
(i==0)?"%s@%s" : ",%s@%s",
user, node);
}
else {
EncodedName = rfc2047encode(name, strlen(name));
n = snprintf(nPtr, nmax,
(i==0)?"%s <%s@%s>" : ",%s <%s@%s>",
EncodedName, user, node);
free(EncodedName);
}
}
else {
n = snprintf(nPtr, nmax,
(i==0)?"%s" : ",%s",
&source[AddrPtr[i]]);
}
if (n > 0 )
nPtr += n;
else {
char *ptr, *nnPtr;
ptr = (char*) malloc(EncodedMaxLen * 2);
memcpy(ptr, Encoded, EncodedMaxLen);
nnPtr = ptr + (nPtr - Encoded), nPtr = nnPtr;
free(Encoded), Encoded = ptr;
EncodedMaxLen *= 2;
i--; /* do it once more with properly lengthened buffer */
}
}
for (i = 0; i < nColons; i++)
source[--AddrPtr[i]] = ',';
free(user);
free(node);
free(name);
free(AddrUtf8);
free(AddrPtr);
return Encoded;
}
