-#include "sysdep.h"
-
+// This is a template substitution engine, which began with good intentions, but ended up becoming
+// more complex and unmaintainable than what it replaced. We are barely hanging on with this until
+// webcit-ng replaces webcit classic.
+#include "sysdep.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <errno.h>
-
#include <unistd.h>
#include <stdio.h>
#include <stdarg.h>
#define SHOW_ME_VAPPEND_PRINTF
#include "webcit.h"
-#include "webserver.h"
+
extern char *static_dirs[PATH_MAX]; /* Disk representation */
#define SV_PREEVALUATED 6
+
/*
* Dynamic content for variable substitution in templates
*/
WCHandlerFunc HandlerFunc;
}HashHandler;
+typedef enum _estate {
+ eNext,
+ eSkipTilEnd
+} TemplState;
+
void *load_template(StrBuf *Target, WCTemplate *NewTemplate);
-int EvaluateConditional(StrBuf *Target, int Neg, int state, WCTemplputParams *TP);
+int EvaluateConditional(StrBuf *Target, int Neg, int state, WCTemplputParams **TPP);
CompareFunc Reverse;
CompareFunc GroupChange;
- long ContextType;
+ CtxType ContextType;
}SortStruct;
-const char *CtxNames[] = {
- "Context NONE",
- "Context SITECFG",
- "Context SESSION",
- "Context INETCFG",
- "Context VNOTE",
- "Context WHO",
- "Context PREF",
- "Context NODECONF",
- "Context USERLIST",
- "Context MAILSUM",
- "Context MIME_ATACH",
- "Context FILELIST",
- "Context STRBUF",
- "Context STRBUFARR",
- "Context LONGVECTOR",
- "Context ROOMS",
- "Context FLOORS",
- "Context ITERATE",
- "Context ICAL",
- "Context DavNamespace",
- "Context TAB",
- "Context VCARD",
- "Context SIEVE List",
- "Context SIEVE Script",
- "Context MailQ-Item",
- "Context MailQ-Recipient",
- "Context ServLogStatus",
- "Context UNKNOWN"
-};
+HashList *CtxList = NULL;
+
+static CtxType CtxCounter = CTX_NONE;
+
+CtxType CTX_STRBUF = CTX_NONE;
+CtxType CTX_STRBUFARR = CTX_NONE;
+CtxType CTX_LONGVECTOR = CTX_NONE;
+
+CtxType CTX_ITERATE = CTX_NONE;
+CtxType CTX_TAB = CTX_NONE;
+
+void HFreeContextType(void *pCtx)
+{
+ CtxTypeStruct *FreeStruct = (CtxTypeStruct *) pCtx;
+ FreeStrBuf(&FreeStruct->Name);
+ free(FreeStruct);
+}
+void PutContextType(const char *name, long len, CtxType TheCtx)
+{
+ CtxTypeStruct *NewStruct;
+
+ NewStruct = (CtxTypeStruct*) malloc(sizeof(CtxTypeStruct));
+ NewStruct->Name = NewStrBufPlain(name, len);
+ NewStruct->Type = TheCtx;
+
+ Put(CtxList, IKEY(NewStruct->Type), NewStruct, HFreeContextType);
+}
+void RegisterContextType(const char *name, long len, CtxType *TheCtx)
+{
+ if (*TheCtx != CTX_NONE)
+ return;
+
+ *TheCtx = ++CtxCounter;
+ PutContextType(name, len, *TheCtx);
+}
+
+CtxTypeStruct *GetContextType(CtxType Type)
+{
+ void *pv = NULL;
+ GetHash(CtxList, IKEY(Type), &pv);
+ return pv;
+}
+
+const char *UnknownContext = "CTX_UNKNOWN";
+
+const char *ContextName(CtxType ContextType)
+{
+ CtxTypeStruct *pCtx;
-void StackContext(WCTemplputParams *Super,
- WCTemplputParams *Sub,
- void *Context,
- int ContextType,
- int nArgs,
- WCTemplateToken *Tokens)
+ pCtx = GetContextType(ContextType);
+
+ if (pCtx != NULL)
+ return ChrPtr(pCtx->Name);
+ else
+ return UnknownContext;
+}
+
+void StackDynamicContext(WCTemplputParams *Super,
+ WCTemplputParams *Sub,
+ void *Context,
+ CtxType ContextType,
+ int nArgs,
+ WCTemplateToken *Tokens,
+ WCConditionalFunc ExitCtx,
+ long ExitCTXID)
{
memset(Sub, 0, sizeof(WCTemplputParams));
Sub->Sub = Super->Sub;
Super->Sub = Sub;
}
+ if (Sub->Sub != NULL)
+ Sub->Sub->Super = Sub;
Sub->Super = Super;
Sub->Context = Context;
Sub->Filter.ContextType = ContextType;
Sub->nArgs = nArgs;
Sub->Tokens = Tokens;
+ Sub->ExitCtx = ExitCtx;
+ Sub->ExitCTXID = ExitCTXID;
}
void UnStackContext(WCTemplputParams *Sub)
{
Sub->Super->Sub = Sub->Sub;
}
+ if (Sub->Sub != NULL)
+ {
+ Sub->Sub->Super = Sub->Super;
+ }
+}
+void UnStackDynamicContext(StrBuf *Target, WCTemplputParams **TPP)
+{
+ WCTemplputParams *TP = *TPP;
+ WCTemplputParams *Super = TP->Super;
+ TP->ExitCtx(Target, TP);
+ *TPP = Super;
}
-void *GetContextPayload(WCTemplputParams *TP, int ContextType)
+void *GetContextPayload(WCTemplputParams *TP, CtxType ContextType)
{
WCTemplputParams *whichTP = TP;
free (Sort);
}
-const char *ContextName(int ContextType)
-{
- if (ContextType < CTX_UNKNOWN)
- return CtxNames[ContextType];
- else
- return CtxNames[CTX_UNKNOWN];
-}
void LogTemplateError (StrBuf *Target, const char *Type, int ErrorPos, WCTemplputParams *TP, const char *Format, ...)
{
- wcsession *WCC;
StrBuf *Error;
StrBuf *Info;
va_list arg_ptr;
}
if (TP->Tokens != NULL)
{
- syslog(1, "%s [%s] (in '%s' line %ld); %s; [%s]\n",
+ syslog(LOG_WARNING, "%s [%s] (in '%s' line %ld); %s; [%s]\n",
Type,
Err,
ChrPtr(TP->Tokens->FileName),
}
else
{
- syslog(1, "%s: %s;\n",
+ syslog(LOG_WARNING, "%s: %s;\n",
Type,
ChrPtr(Error));
}
- WCC = WC;
- if (WCC == NULL) {
+ if (WC == NULL) {
FreeStrBuf(&Info);
FreeStrBuf(&Error);
return;
}
- if (WCC->WFBuf == NULL) WCC->WFBuf = NewStrBuf();
+ if (WC->WFBuf == NULL) WC->WFBuf = NewStrBuf();
if (TP->Tokens != NULL)
{
/* deprecated:
ChrPtr(TP->Tokens->FlatToken));
- SerializeJson(WCC->WFBuf, WildFireException(SKEY(TP->Tokens->FileName),
+ SerializeJson(WC->WFBuf, WildFireException(SKEY(TP->Tokens->FileName),
TP->Tokens->Line,
Info,
1), 1);
-/*
- SerializeJson(Header, WildFireMessage(SKEY(TP->Tokens->FileName),
- TP->Tokens->Line,
- Error,
- eERROR), 1);
-*/
-
}
- else
- {
- /* deprecated.
- StrBufAppendPrintf(
- Target,
- "<pre>\n%s: %s\n</pre>\n",
- Type,
- ChrPtr(Error));
- */
+ else {
StrBufPrintf(Info, "%s [%s] %s; [%s]",
Type,
Err,
ChrPtr(Error),
ChrPtr(TP->Tokens->FlatToken));
- SerializeJson(WCC->WFBuf, WildFireException(HKEY(__FILE__), __LINE__, Info, 1), 1);
+ SerializeJson(WC->WFBuf, WildFireException(HKEY(__FILE__), __LINE__, Info, 1), 1);
}
FreeStrBuf(&Info);
FreeStrBuf(&Error);
-/*
- if (dbg_backtrace_template_errors)
- wc_backtrace();
-*/
}
-
-
-void LogError (StrBuf *Target, const char *Type, const char *Format, ...)
-{
- wcsession *WCC;
+void LogError (StrBuf *Target, const char *Type, const char *Format, ...) {
StrBuf *Error;
StrBuf *Info;
va_list arg_ptr;
StrBufVAppendPrintf(Error, Format, arg_ptr);
va_end(arg_ptr);
- syslog(1, "%s", ChrPtr(Error));
+ syslog(LOG_WARNING, "%s", ChrPtr(Error));
- WCC = WC;
- if (WCC->WFBuf == NULL) WCC->WFBuf = NewStrBuf();
+ if (WC->WFBuf == NULL) WC->WFBuf = NewStrBuf();
- SerializeJson(WCC->WFBuf, WildFireException(Type, strlen(Type),
+ SerializeJson(WC->WFBuf, WildFireException(Type, strlen(Type),
0,
Info,
1), 1);
FreeStrBuf(&Info);
FreeStrBuf(&Error);
-/*
- if (dbg_backtrace_template_errors)
- wc_backtrace();
-*/
}
int nMaxArgs,
WCHandlerFunc HandlerFunc,
WCPreevalFunc PreevalFunc,
- int ContextRequired)
+ CtxType ContextRequired)
{
HashHandler *NewHandler;
return 1;
LogTemplateError(
- Target, ErrType, ERR_PARM1, TP,
+ Target, ErrType, ERR_NAME, TP,
" WARNING: requires Context: [%s], have [%s]!",
ContextName(Need->ContextType),
ContextName(TP->Filter.ContextType));
return 0;
}
-/*
- if (TP->Tokens->nParameters < Need->nMinArgs) {
- LogTemplateError(Target, ErrType, ERR_NAME, TP,
- "needs at least %ld params, have %ld",
- Need->nMinArgs,
- TP->Tokens->nParameters);
- return 0;
-
- }
- else if (TP->Tokens->nParameters > Need->nMaxArgs) {
- LogTemplateError(Target, ErrType, ERR_NAME, TP,
- "just needs %ld params, you gave %ld",
- Need->nMaxArgs,
- TP->Tokens->nParameters);
- return 0;
-
- }
-*/
return 1;
}
-void FreeToken(WCTemplateToken **Token)
-{
+void FreeToken(WCTemplateToken **Token) {
int i;
FreeStrBuf(&(*Token)->FlatToken);
if ((*Token)->HaveParameters)
}
-
-void FreeWCTemplate(void *vFreeMe)
-{
+void FreeWCTemplate(void *vFreeMe) {
int i;
WCTemplate *FreeMe = (WCTemplate*)vFreeMe;
case TYPE_STR:
case TYPE_BSTR:
case TYPE_PREFSTR:
+ case TYPE_ROOMPREFSTR:
case TYPE_GETTEXT:
case TYPE_SUBTEMPLATE:
return 1;
}
}
-void GetTemplateTokenString(StrBuf *Target,
- WCTemplputParams *TP,
- int N,
- const char **Value,
- long *len)
-{
+void GetTemplateTokenString(StrBuf *Target, WCTemplputParams *TP, int N, const char **Value, long *len) {
StrBuf *Buf;
-/// WCTemplputParams SubTP;
if (N >= TP->Tokens->nParameters) {
LogTemplateError(Target,
*Value = ChrPtr(Buf);
*len = StrLength(Buf);
break;
+ case TYPE_ROOMPREFSTR:
+ if (TP->Tokens->Params[N]->len == 0) {
+ LogTemplateError(Target,
+ "TokenParameter", N, TP,
+ "Requesting parameter %d; of type PREFSTR, empty lookup string not admitted.", N);
+ *len = 0;
+ *Value = EmptyStr;
+ break;
+ }
+ Buf = get_ROOM_PREFS(TKEY(N));
+ *Value = ChrPtr(Buf);
+ *len = StrLength(Buf);
+ break;
case TYPE_LONG:
LogTemplateError(Target,
"TokenParameter", N, TP,
}
}
-long GetTemplateTokenNumber(StrBuf *Target, WCTemplputParams *TP, int N, long dflt)
-{
+long GetTemplateTokenNumber(StrBuf *Target, WCTemplputParams *TP, int N, long dflt) {
long Ret;
if (N >= TP->Tokens->nParameters) {
LogTemplateError(Target,
"TokenParameter", N, TP,
"invalid token %d. this shouldn't have come till here.\n", N);
- wc_backtrace();
+ wc_backtrace(LOG_DEBUG);
return 0;
}
if (get_PREF_LONG(TKEY(N), &Ret, dflt))
return Ret;
return 0;
+ case TYPE_ROOMPREFSTR:
+ LogTemplateError(Target,
+ "TokenParameter", N, TP,
+ "requesting a prefstring in param %d want a number", N);
+ if (TP->Tokens->Params[N]->len == 0) {
+ LogTemplateError(Target,
+ "TokenParameter", N, TP,
+ "Requesting parameter %d; of type PREFSTR, empty lookup string not admitted.", N);
+ return 0;
+ }
+ if (get_ROOM_PREFS_LONG(TKEY(N), &Ret, dflt))
+ return Ret;
+ return 0;
case TYPE_INTDEFINE:
case TYPE_LONG:
return TP->Tokens->Params[N]->lvalue;
char EscapeAs = ' ';
if ((FormatTypeIndex < TP->Tokens->nParameters) &&
+ (TP->Tokens->Params[FormatTypeIndex] != NULL) &&
(TP->Tokens->Params[FormatTypeIndex]->Type == TYPE_STR) &&
(TP->Tokens->Params[FormatTypeIndex]->len >= 1)) {
pFmt = TP->Tokens->Params[FormatTypeIndex]->Start;
StrEscAppend(Target, Source, NULL, 0, 2);
break;
case 'X':
- StrEscAppend(Target, Source, NULL, 0, 0);
+ if (!IsEmptyStr(ChrPtr(Source))) {
+ StrEscAppend(Target, Source, NULL, 0, 0);
+ if (pFmt[1]) {
+ StrBufAppendBufPlain(Target, pFmt, -1, 1);
+ }
+ }
break;
case 'J':
StrECMAEscAppend(Target, Source, NULL);
- break;
+ break;
case 'K':
StrHtmlEcmaEscAppend(Target, Source, NULL, 0, 0);
- break;
+ break;
case 'U':
StrBufUrlescAppend(Target, Source, NULL);
break;
}
}
+/*
+ * puts string into the template and computes which escape methon we should use
+ * Source = the string we should put into the template
+ * FormatTypeIndex = where should we look for escape types if?
+ */
+void StrBufAppendTemplateStr(StrBuf *Target,
+ WCTemplputParams *TP,
+ const char *Source, int FormatTypeIndex)
+{
+ const char *pFmt = NULL;
+ char EscapeAs = ' ';
+
+ if ((FormatTypeIndex < TP->Tokens->nParameters) &&
+ (TP->Tokens->Params[FormatTypeIndex]->Type == TYPE_STR) &&
+ (TP->Tokens->Params[FormatTypeIndex]->len >= 1)) {
+ pFmt = TP->Tokens->Params[FormatTypeIndex]->Start;
+ EscapeAs = *pFmt;
+ }
+
+ switch(EscapeAs)
+ {
+ case 'H':
+ StrEscAppend(Target, NULL, Source, 0, 2);
+ break;
+ case 'X':
+ StrEscAppend(Target, NULL, Source, 0, 0);
+ break;
+ case 'J':
+ StrECMAEscAppend(Target, NULL, Source);
+ break;
+ case 'K':
+ StrHtmlEcmaEscAppend(Target, NULL, Source, 0, 0);
+ break;
+ case 'U':
+ StrBufUrlescAppend(Target, NULL, Source);
+ break;
+/*
+ case 'F':
+ if (pFmt != NULL) pFmt++;
+ else pFmt = "JUSTIFY";
+ if (*pFmt == '\0') pFmt = "JUSTIFY";
+ FmOut(Target, pFmt, Source);
+ break;
+*/
+ default:
+ StrBufAppendBufPlain(Target, Source, -1, 0);
+ }
+}
+
void PutNewToken(WCTemplate *Template, WCTemplateToken *NewToken)
{
ParamBrace = 1;
}
}
+ else if (*pch == '.') {
+ Parm->Type = TYPE_ROOMPREFSTR;
+ pch ++;
+ if (*pch == '(') {
+ pch ++;
+ ParamBrace = 1;
+ }
+ }
else if (*pch == ';') {
Parm->Type = TYPE_PREFINT;
pch ++;
}
pche = pch;
if (*pch != quote) {
- syslog(1, "Error (in '%s' line %ld); "
+ syslog(LOG_WARNING, "Error (in '%s' line %ld); "
"evaluating template param [%s] in Token [%s]\n",
ChrPtr(pTmpl->FileName),
Tokens->Line,
else {
StrBufPeek(Buf, pch, -1, '\0');
if (LoadTemplates > 1) {
- syslog(1,
- "DBG: got param [%s] %d %d\n",
+ syslog(LOG_DEBUG,
+ "DBG: got param [%s] "SIZE_T_FMT" "SIZE_T_FMT"\n",
pchs, pche - pchs, strlen(pchs)
);
}
else {
Parm->lvalue = 0;
/* TODO whUT?
- syslog(1, "Error (in '%s' line %ld); "
+ syslog(LOG_DEBUG, "Error (in '%s' line %ld); "
"evaluating long template param [%s] in Token [%s]\n",
ChrPtr(pTmpl->FileName),
Tokens->Line,
} else {
LogTemplateError(
NULL, "Token ", ERR_NAME, &TP,
- " isn't known to us.",
- NULL);
+ " isn't known to us.");
}
break;
case SV_GETTEXT:
- if (NewToken->nParameters !=1) {
+ if ((NewToken->nParameters < 1) || (NewToken->nParameters > 2)) {
LogTemplateError(
NULL, "Gettext", ERR_NAME, &TP,
- "requires exactly 1 parameter, you gave %d params",
+ "requires 1 or 2 parameter, you gave %d params",
NewToken->nParameters);
NewToken->Flags = 0;
break;
-/**
- * \brief Display a variable-substituted template
- * \param templatename template file to load
+/*
+ * Display a variable-substituted template
+ * templatename template file to load
*/
-void *prepare_template(StrBuf *filename, StrBuf *Key, HashList *PutThere)
-{
+void *prepare_template(StrBuf *filename, StrBuf *Key, HashList *PutThere) {
WCTemplate *NewTemplate;
NewTemplate = (WCTemplate *) malloc(sizeof(WCTemplate));
return NewTemplate;
}
-/**
- * \brief Display a variable-substituted template
- * \param templatename template file to load
+/*
+ * Display a variable-substituted template
+ * templatename template file to load
*/
-void *duplicate_template(WCTemplate *OldTemplate)
-{
+void *duplicate_template(WCTemplate *OldTemplate) {
WCTemplate *NewTemplate;
NewTemplate = (WCTemplate *) malloc(sizeof(WCTemplate));
}
-void SanityCheckTemplate(StrBuf *Target, WCTemplate *CheckMe)
-{
+void SanityCheckTemplate(StrBuf *Target, WCTemplate *CheckMe) {
int i = 0;
int j;
int FoundConditionalEnd;
- for (i = 0; i < CheckMe->nTokensUsed; i++)
- {
- switch(CheckMe->Tokens[i]->Flags)
- {
+ for (i = 0; i < CheckMe->nTokensUsed; i++) {
+ switch(CheckMe->Tokens[i]->Flags) {
case SV_CONDITIONAL:
case SV_NEG_CONDITIONAL:
FoundConditionalEnd = 0;
}
}
-/**
- * \brief Display a variable-substituted template
- * \param templatename template file to load
+/*
+ * Display a variable-substituted template
+ * templatename template file to load
*/
void *load_template(StrBuf *Target, WCTemplate *NewTemplate)
{
fd = open(ChrPtr(NewTemplate->FileName), O_RDONLY);
if (fd <= 0) {
- syslog(1, "ERROR: could not open template '%s' - %s\n",
+ syslog(LOG_WARNING, "ERROR: could not open template '%s' - %s\n",
ChrPtr(NewTemplate->FileName), strerror(errno));
return NULL;
}
if (fstat(fd, &statbuf) == -1) {
- syslog(1, "ERROR: could not stat template '%s' - %s\n",
+ syslog(LOG_WARNING, "ERROR: could not stat template '%s' - %s\n",
ChrPtr(NewTemplate->FileName), strerror(errno));
return NULL;
}
NewTemplate->Data = NewStrBufPlain(NULL, statbuf.st_size + 1);
if (StrBufReadBLOB(NewTemplate->Data, &fd, 1, statbuf.st_size, &Err) < 0) {
close(fd);
- syslog(1, "ERROR: reading template '%s' - %s<br>\n",
+ syslog(LOG_WARNING, "ERROR: reading template '%s' - %s<br>\n",
ChrPtr(NewTemplate->FileName), strerror(errno));
return NULL;
}
{
char *MinorPtr;
-#ifdef _DIRENT_HAVE_D_NAMELEN
- d_namelen = filedir_entry->d_namelen;
+#ifdef _DIRENT_HAVE_D_NAMLEN
+ d_namelen = filedir_entry->d_namlen;
+#else
+ d_namelen = strlen(filedir_entry->d_name);
+#endif
+
+#ifdef _DIRENT_HAVE_D_TYPE
d_type = filedir_entry->d_type;
#else
#define IFTODT(mode) (((mode) & 0170000) >> 12)
#define DTTOIF(dirtype) ((dirtype) << 12)
#endif
- d_namelen = strlen(filedir_entry->d_name);
d_type = DT_UNKNOWN;
#endif
d_without_ext = d_namelen;
char path[PATH_MAX];
snprintf(path, PATH_MAX, "%s/%s",
ChrPtr(DirName), filedir_entry->d_name);
- if (stat(path, &s) == 0) {
+ if (lstat(path, &s) == 0) {
d_type = IFTODT(s.st_mode);
}
}
LoadTemplateDir(SubDirectory, big, SubKey);
break;
- case DT_LNK: /* TODO: check whether its a file or a directory */
+ case DT_LNK:
case DT_REG:
StrBufAppendBufPlain(Key, filedir_entry->d_name, MinorPtr - filedir_entry->d_name, 0);
if (LoadTemplates >= 1)
- syslog(1, "%s %s\n", ChrPtr(FileName), ChrPtr(Key));
+ syslog(LOG_DEBUG, "%s %s\n", ChrPtr(FileName), ChrPtr(Key));
prepare_template(FileName, Key, big);
default:
break;
/* Primary Template set... */
StrBufPrintf(Dir, "%s/t", static_dirs[0]);
- LoadTemplateDir(Dir,
- TemplateCache,
- Key);
+ LoadTemplateDir(Dir, TemplateCache, Key);
/* User local Template set */
StrBufPrintf(Dir, "%s/t", static_dirs[1]);
- LoadTemplateDir(Dir,
- LocalTemplateCache,
- Key);
+ LoadTemplateDir(Dir, LocalTemplateCache, Key);
/* Debug Templates, just to be loaded while debugging. */
StrBufPrintf(Dir, "%s/dbg", static_dirs[0]);
- LoadTemplateDir(Dir,
- TemplateCache,
- Key);
+ LoadTemplateDir(Dir, TemplateCache, Key);
Templates[0] = TemplateCache;
Templates[1] = LocalTemplateCache;
void *vTemplate;
At = GetNewHashPos(Templates[i], 0);
- while (GetNextHashPos(Templates[i],
- At,
- &KLen,
- &Key,
- &vTemplate) &&
- (vTemplate != NULL))
- {
+ while (GetNextHashPos(Templates[i], At, &KLen, &Key, &vTemplate) && (vTemplate != NULL)) {
load_template(NULL, (WCTemplate *)vTemplate);
}
DeleteHashPos(&At);
* \param state are we in conditional state?
* \param ContextType what type of information does context giv us?
*/
-int EvaluateToken(StrBuf *Target, int state, WCTemplputParams *TP)
+int EvaluateToken(StrBuf *Target, int state, WCTemplputParams **TPP)
{
const char *AppendMe;
long AppendMeLen;
HashHandler *Handler;
void *vVar;
+ WCTemplputParams *TP = *TPP;
/* much output, since pName is not terminated...
- syslog(1,"Doing token: %s\n",Token->pName);
+ syslog(LOG_DEBUG,"Doing token: %s\n",Token->pName);
*/
switch (TP->Tokens->Flags) {
case SV_CONDITIONAL: /** Forward conditional evaluation */
Handler = (HashHandler*) TP->Tokens->PreEval;
if (!CheckContext(Target, &Handler->Filter, TP, "Conditional")) {
- return -1;
+ return 0;
}
- return EvaluateConditional(Target, 1, state, TP);
+ return EvaluateConditional(Target, 1, state, TPP);
break;
case SV_NEG_CONDITIONAL: /** Reverse conditional evaluation */
Handler = (HashHandler*) TP->Tokens->PreEval;
if (!CheckContext(Target, &Handler->Filter, TP, "Conditional")) {
- return -1;
+ return 0;
}
- return EvaluateConditional(Target, 0, state, TP);
+ return EvaluateConditional(Target, 0, state, TPP);
break;
case SV_CUST_STR_CONDITIONAL: /** Conditional put custom strings from params */
Handler = (HashHandler*) TP->Tokens->PreEval;
if (!CheckContext(Target, &Handler->Filter, TP, "Conditional")) {
- return -1;
+ return 0;
}
if (TP->Tokens->nParameters >= 6) {
- if (EvaluateConditional(Target, 0, state, TP)) {
+ if (EvaluateConditional(Target, 0, state, TPP)) {
GetTemplateTokenString(Target, TP, 5, &AppendMe, &AppendMeLen);
- StrBufAppendBufPlain(Target,
- AppendMe,
- AppendMeLen,
- 0);
+ StrBufAppendBufPlain(Target, AppendMe, AppendMeLen, 0);
}
else{
GetTemplateTokenString(Target, TP, 4, &AppendMe, &AppendMeLen);
- StrBufAppendBufPlain(Target,
- AppendMe,
- AppendMeLen,
- 0);
+ StrBufAppendBufPlain(Target, AppendMe, AppendMeLen, 0);
+ }
+ if (*TPP != TP)
+ {
+ UnStackDynamicContext(Target, TPP);
}
}
else {
- LogTemplateError(
- Target, "Conditional", ERR_NAME, TP,
- "needs at least 6 Params!");
+ LogTemplateError( Target, "Conditional", ERR_NAME, TP, "needs at least 6 Params!");
}
break;
case SV_SUBTEMPL:
case SV_PREEVALUATED:
Handler = (HashHandler*) TP->Tokens->PreEval;
if (!CheckContext(Target, &Handler->Filter, TP, "Token")) {
- return -1;
+ return 0;
}
Handler->HandlerFunc(Target, TP);
break;
if (GetHash(GlobalNS, TP->Tokens->pName, TP->Tokens->NameEnd, &vVar)) {
Handler = (HashHandler*) vVar;
if (!CheckContext(Target, &Handler->Filter, TP, "Token")) {
- return -1;
+ return 0;
}
else {
Handler->HandlerFunc(Target, TP);
{
WCTemplate *pTmpl = Tmpl;
int done = 0;
- int i, state;
+ int i;
+ TemplState state;
const char *pData, *pS;
long len;
WCTemplputParams TP;
+ WCTemplputParams *TPtr = &TP;
+
+ memset(TPtr, 0, sizeof(WCTemplputParams));
memcpy(&TP.Filter, &CallingTP->Filter, sizeof(ContextFilter));
if (LoadTemplates != 0) {
if (LoadTemplates > 1)
- syslog(1, "DBG: ----- loading: [%s] ------ \n",
+ syslog(LOG_DEBUG, "DBG: ----- loading: [%s] ------ \n",
ChrPtr(Tmpl->FileName));
pTmpl = duplicate_template(Tmpl);
if(load_template(Target, pTmpl) == NULL) {
- StrBufAppendPrintf(
- Target,
+ StrBufAppendPrintf( Target,
"<pre>\nError loading Template [%s]\n See Logfile for details\n</pre>\n",
ChrPtr(Tmpl->FileName));
FreeWCTemplate(pTmpl);
pS = pData = ChrPtr(pTmpl->Data);
len = StrLength(pTmpl->Data);
i = 0;
- state = 0;
+ state = eNext;
while (!done) {
if (i >= pTmpl->nTokensUsed) {
- StrBufAppendBufPlain(Target,
- pData,
- len - (pData - pS), 0);
+ StrBufAppendBufPlain(Target, pData, len - (pData - pS), 0);
done = 1;
}
else {
- StrBufAppendBufPlain(
- Target, pData,
- pTmpl->Tokens[i]->pTokenStart - pData, 0);
- TP.Tokens = pTmpl->Tokens[i];
- TP.nArgs = pTmpl->Tokens[i]->nParameters;
- state = EvaluateToken(Target, state, &TP);
-
- while ((state != 0) && (i+1 < pTmpl->nTokensUsed)) {
+ int TokenRc = 0;
+
+ StrBufAppendBufPlain( Target, pData, pTmpl->Tokens[i]->pTokenStart - pData, 0);
+ TPtr->Tokens = pTmpl->Tokens[i];
+ TPtr->nArgs = pTmpl->Tokens[i]->nParameters;
+
+ TokenRc = EvaluateToken(Target, TokenRc, &TPtr);
+ if (TokenRc > 0) {
+ state = eSkipTilEnd;
+ }
+ else if (TokenRc < 0) {
+ if ((TPtr != &TP) && (TPtr->ExitCTXID == -TokenRc)) {
+ UnStackDynamicContext(Target, &TPtr);
+ }
+ TokenRc = 0;
+ }
+
+ while ((state != eNext) && (i+1 < pTmpl->nTokensUsed)) {
/* condition told us to skip till its end condition */
i++;
- TP.Tokens = pTmpl->Tokens[i];
- TP.nArgs = pTmpl->Tokens[i]->nParameters;
+ TPtr->Tokens = pTmpl->Tokens[i];
+ TPtr->nArgs = pTmpl->Tokens[i]->nParameters;
if ((pTmpl->Tokens[i]->Flags == SV_CONDITIONAL) ||
- (pTmpl->Tokens[i]->Flags == SV_NEG_CONDITIONAL)) {
- if (state == EvaluateConditional(
- Target,
- pTmpl->Tokens[i]->Flags,
- state,
- &TP))
- state = 0;
+ (pTmpl->Tokens[i]->Flags == SV_NEG_CONDITIONAL))
+ {
+ int rc;
+ rc = EvaluateConditional(
+ Target,
+ pTmpl->Tokens[i]->Flags,
+ TokenRc,
+ &TPtr);
+ if (-rc == TokenRc) {
+ TokenRc = 0;
+ state = eNext;
+ if ((TPtr != &TP) && (TPtr->ExitCTXID == - rc)) {
+ UnStackDynamicContext(Target, &TPtr);
+ }
+ }
}
}
+
pData = pTmpl->Tokens[i++]->pTokenEnd + 1;
if (i > pTmpl->nTokensUsed)
done = 1;
}
+
+StrBuf *textPlainType;
/**
* \brief Display a variable-substituted template
* \param templatename template file to load
Static = TemplateCache;
StaticLocal = LocalTemplateCache;
- if (len == 0)
- {
- syslog(1, "Can't to load a template with empty name!\n");
+ if (len == 0) {
+ syslog(LOG_WARNING, "Can't to load a template with empty name!\n");
StrBufAppendPrintf(Target, "<pre>\nCan't to load a template with empty name!\n</pre>");
- return NULL;
+ return textPlainType;
}
if (!GetHash(StaticLocal, templatename, len, &vTmpl) &&
!GetHash(Static, templatename, len, &vTmpl)) {
- syslog(1, "didn't find Template [%s] %ld %ld\n", templatename, len , (long)strlen(templatename));
+ StrBuf *escapedString = NewStrBufPlain(NULL, len);
+
+ StrHtmlEcmaEscAppend(escapedString, NULL, templatename, 1, 1);
+ syslog(LOG_WARNING, "didn't find Template [%s] %ld %ld\n", ChrPtr(escapedString), len , (long)strlen(templatename));
StrBufAppendPrintf(Target, "<pre>\ndidn't find Template [%s] %ld %ld\n</pre>",
- templatename, len,
+ ChrPtr(escapedString), len,
(long)strlen(templatename));
+ WC->isFailure = 1;
#if 0
dbg_PrintHash(Static, PrintTemplate, NULL);
PrintHash(Static, VarPrintTransition, PrintTemplate);
#endif
- return NULL;
+ FreeStrBuf(&escapedString);
+ return textPlainType;
}
if (vTmpl == NULL)
- return NULL;
+ return textPlainType;
return ProcessTemplate(vTmpl, Target, TP);
}
typedef struct _HashIterator {
HashList *StaticList;
int AdditionalParams;
- int ContextType;
- int XPectContextType;
+ CtxType ContextType;
+ CtxType XPectContextType;
int Flags;
RetrieveHashlistFunc GetHash;
HashDestructorFunc Destructor;
SubTemplFunc DoSubTemplate;
+ FilterByParamFunc Filter;
} HashIterator;
void RegisterITERATOR(const char *Name, long len,
RetrieveHashlistFunc GetHash,
SubTemplFunc DoSubTempl,
HashDestructorFunc Destructor,
- int ContextType,
- int XPectContextType,
+ FilterByParamFunc Filter,
+ CtxType ContextType,
+ CtxType XPectContextType,
int Flags)
{
HashIterator *It;
It->GetHash = GetHash;
It->DoSubTemplate = DoSubTempl;
It->Destructor = Destructor;
+ It->Filter = Filter;
It->ContextType = ContextType;
It->XPectContextType = XPectContextType;
It->Flags = Flags;
/** Ok, its us, lets see in which direction we should sort... */
(havebstr("SortOrder"))) {
int SortOrder;
- SortOrder = LBSTR("SortOrder");
+ SortOrder = lbstr("SortOrder");
if (SortOrder != 0)
DetectGroupChange = 1;
}
}
while (GetNextHashPos(List, it, &Status.KeyLen, &Status.Key, &vContext)) {
if ((Status.n >= StartAt) && (Status.n <= StopAt)) {
+
+ if ((It->Filter != NULL) &&
+ !It->Filter(Status.Key, Status.KeyLen, vContext, Target, TP))
+ {
+ continue;
+ }
+
if (DetectGroupChange && Status.n > 0) {
Status.GroupChange = SortBy->GroupChange(vContext, vLastContext);
}
StrBufAppendBufPlain(Target, Ctx->Key, Ctx->KeyLen, 0);
}
+void tmplput_ITERATE_N_DIV(StrBuf *Target, WCTemplputParams *TP)
+{
+ IterateStruct *Ctx = CTX(CTX_ITERATE);
+ long div;
+ long divisor = GetTemplateTokenNumber(Target, TP, 0, 1);
+///TODO divisor == 0 -> log error exit
+ div = Ctx->n / divisor;
+ StrBufAppendPrintf(Target, "%ld", div);
+}
-void tmplput_ITERATE_LASTN(StrBuf *Target, WCTemplputParams *TP)
+void tmplput_ITERATE_N(StrBuf *Target, WCTemplputParams *TP)
{
IterateStruct *Ctx = CTX(CTX_ITERATE);
StrBufAppendPrintf(Target, "%d", Ctx->n);
return Ctx->LastN;
}
+int conditional_ITERATE_ISMOD(StrBuf *Target, WCTemplputParams *TP)
+{
+ IterateStruct *Ctx = CTX(CTX_ITERATE);
+
+ long divisor = GetTemplateTokenNumber(Target, TP, 2, 1);
+ long expectRemainder = GetTemplateTokenNumber(Target, TP, 3, 0);
+
+ return Ctx->n % divisor == expectRemainder;
+}
+
/*-----------------------------------------------------------------------------
* Conditionals
*/
-int EvaluateConditional(StrBuf *Target, int Neg, int state, WCTemplputParams *TP)
+int EvaluateConditional(StrBuf *Target, int Neg, int state, WCTemplputParams **TPP)
{
ConditionalStruct *Cond;
int rc = 0;
int res;
+ WCTemplputParams *TP = *TPP;
if ((TP->Tokens->Params[0]->len == 1) &&
(TP->Tokens->Params[0]->Start[0] == 'X'))
- return (state != 0)?TP->Tokens->Params[1]->lvalue:0;
+ {
+ return - (TP->Tokens->Params[1]->lvalue);
+ }
Cond = (ConditionalStruct *) TP->Tokens->PreEval;
if (Cond == NULL) {
LogTemplateError(
Target, "Conditional", ERR_PARM1, TP,
"unknown!");
- return 1;
+ return 0;
}
if (!CheckContext(Target, &Cond->Filter, TP, "Conditional")) {
res = Cond->CondF(Target, TP);
if (res == Neg)
rc = TP->Tokens->Params[1]->lvalue;
+
if (LoadTemplates > 5)
- syslog(1, "<%s> : %d %d==%d\n",
+ syslog(LOG_DEBUG, "<%s> : %d %d==%d\n",
ChrPtr(TP->Tokens->FlatToken),
rc, res, Neg);
+
+ if (TP->Sub != NULL)
+ {
+ *TPP = TP->Sub;
+ }
return rc;
}
-void RegisterConditional(const char *Name, long len,
- int nParams,
- WCConditionalFunc CondF,
- int ContextRequired)
+void RegisterContextConditional(const char *Name, long len,
+ int nParams,
+ WCConditionalFunc CondF,
+ WCConditionalFunc ExitCtxCond,
+ int ContextRequired)
{
ConditionalStruct *Cond;
Cond->Filter.nMaxArgs = nParams;
Cond->Filter.nMinArgs = nParams;
Cond->CondF = CondF;
+ Cond->CondExitCtx = ExitCtxCond;
Cond->Filter.ContextType = ContextRequired;
Put(Conditionals, Name, len, Cond, NULL);
}
}
StackContext (TP, &SubTP, &TS, CTX_TAB, 0, NULL);
{
-//// TODO jetzt memcpy (&SubTP, TP, sizeof(WCTemplputParams));
-// SubTP.Filter.ControlContextType = ;
-
StrTabbedDialog(Target, nTabs, TabNames);
for (i = 0; i < ntabs; i++) {
memset(&TS, 0, sizeof(tab_struct));
CompareFunc Forward,
CompareFunc Reverse,
CompareFunc GroupChange,
- long ContextType)
+ CtxType ContextType)
{
SortStruct *NewSort;
NewSort->GroupChange = GroupChange;
NewSort->ContextType = ContextType;
if (ContextType == CTX_NONE) {
- syslog(1, "sorting requires a context. CTX_NONE won't make it.\n");
+ syslog(LOG_WARNING, "sorting requires a context. CTX_NONE won't make it.\n");
exit(1);
}
LogTemplateError(
NULL, "Sorting", ERR_PARM1, TP,
"Illegal default sort: [%s]", Default);
- wc_backtrace();
+ wc_backtrace(LOG_WARNING);
}
}
SortBy = (SortStruct*)vSortBy;
/** Ok, its us, lets see in which direction we should sort... */
if (havebstr("SortOrder")) {
- SortOrder = LBSTR("SortOrder");
+ SortOrder = lbstr("SortOrder");
}
else { /** Try to fallback to our remembered values... */
StrBuf *Buf = NULL;
/** Ok, its us, lets see in which direction we should sort... */
if (havebstr("SortOrder")) {
- *SortOrder = LBSTR("SortOrder");
+ *SortOrder = lbstr("SortOrder");
}
else { /** Try to fallback to our remembered values... */
if ((*Param)->PrefPrepend == NULL) {
StrBufAppendPrintf(Buf, "%d: %ld]\n", i, LongVector[i]);
}
- syslog(1, "%s", ChrPtr(Buf));
+ syslog(LOG_DEBUG, "%s", ChrPtr(Buf));
FreeStrBuf(&Buf);
}
InitModule_SUBST
(void)
{
+ RegisterCTX(CTX_TAB);
+ RegisterCTX(CTX_ITERATE);
+
memset(&NoCtx, 0, sizeof(WCTemplputParams));
RegisterNamespace("--", 0, 2, tmplput_Comment, NULL, CTX_NONE);
RegisterNamespace("SORT:ICON", 1, 2, tmplput_SORT_ICON, NULL, CTX_NONE);
RegisterNamespace("LONGVECTOR", 1, 1, tmplput_long_vector, NULL, CTX_LONGVECTOR);
- RegisterConditional(HKEY("COND:CONTEXTSTR"), 3, ConditionalContextStr, CTX_STRBUF);
- RegisterConditional(HKEY("COND:CONTEXTSTRARR"), 4, ConditionalContextStrinArray, CTX_STRBUFARR);
- RegisterConditional(HKEY("COND:LONGVECTOR"), 4, ConditionalLongVector, CTX_LONGVECTOR);
+ RegisterConditional("COND:CONTEXTSTR", 3, ConditionalContextStr, CTX_STRBUF);
+ RegisterConditional("COND:CONTEXTSTRARR", 4, ConditionalContextStrinArray, CTX_STRBUFARR);
+ RegisterConditional("COND:LONGVECTOR", 4, ConditionalLongVector, CTX_LONGVECTOR);
- RegisterConditional(HKEY("COND:ITERATE:ISGROUPCHANGE"), 2,
+ RegisterConditional("COND:ITERATE:ISGROUPCHANGE", 2,
conditional_ITERATE_ISGROUPCHANGE,
CTX_ITERATE);
- RegisterConditional(HKEY("COND:ITERATE:LASTN"), 2,
+ RegisterConditional("COND:ITERATE:LASTN", 2,
conditional_ITERATE_LASTN,
CTX_ITERATE);
- RegisterConditional(HKEY("COND:ITERATE:FIRSTN"), 2,
+ RegisterConditional("COND:ITERATE:FIRSTN", 2,
conditional_ITERATE_FIRSTN,
CTX_ITERATE);
+ RegisterConditional("COND:ITERATE:ISMOD", 3,
+ conditional_ITERATE_ISMOD,
+ CTX_ITERATE);
RegisterNamespace("ITERATE:ODDEVEN", 0, 0, tmplput_ITERATE_ODDEVEN, NULL, CTX_ITERATE);
RegisterNamespace("ITERATE:KEY", 0, 0, tmplput_ITERATE_KEY, NULL, CTX_ITERATE);
- RegisterNamespace("ITERATE:N", 0, 0, tmplput_ITERATE_LASTN, NULL, CTX_ITERATE);
+ RegisterNamespace("ITERATE:N", 0, 0, tmplput_ITERATE_N, NULL, CTX_ITERATE);
+ RegisterNamespace("ITERATE:N:DIV", 1, 1, tmplput_ITERATE_N_DIV, NULL, CTX_ITERATE);
RegisterNamespace("CURRENTFILE", 0, 1, tmplput_CURRENT_FILE, NULL, CTX_NONE);
RegisterNamespace("DEF:STR", 1, 1, tmplput_DefStr, NULL, CTX_NONE);
RegisterNamespace("DEF:VAL", 1, 1, tmplput_DefVal, NULL, CTX_NONE);
ServerStartModule_SUBST
(void)
{
+ textPlainType = NewStrBufPlain(HKEY("text/plain"));
LocalTemplateCache = NewHash(1, NULL);
TemplateCache = NewHash(1, NULL);
-
GlobalNS = NewHash(1, NULL);
Iterators = NewHash(1, NULL);
Conditionals = NewHash(1, NULL);
SortHash = NewHash(1, NULL);
Defines = NewHash(1, NULL);
+ CtxList = NewHash(1, NULL);
+
+ PutContextType(HKEY("CTX_NONE"), 0);
+
+ RegisterCTX(CTX_STRBUF);
+ RegisterCTX(CTX_STRBUFARR);
+ RegisterCTX(CTX_LONGVECTOR);
}
void
ServerShutdownModule_SUBST
(void)
{
+ FreeStrBuf(&textPlainType);
+
DeleteHash(&TemplateCache);
DeleteHash(&LocalTemplateCache);
-
+
DeleteHash(&GlobalNS);
DeleteHash(&Iterators);
DeleteHash(&Conditionals);
DeleteHash(&SortHash);
DeleteHash(&Defines);
+ DeleteHash(&CtxList);
}
projects / citadel.git / blobdiff