-/*
- * $Id$
- */
#include "sysdep.h"
extern char *static_dirs[PATH_MAX]; /* Disk representation */
-HashList *WirelessTemplateCache;
-HashList *WirelessLocalTemplateCache;
HashList *TemplateCache;
HashList *LocalTemplateCache;
"Context ICAL",
"Context DavNamespace",
"Context TAB",
+ "Context VCARD",
"Context UNKNOWN"
};
}
if (TP->Tokens != NULL)
{
- lprintf(1, "%s [%s] (in '%s' line %ld); %s; [%s]\n",
+ syslog(1, "%s [%s] (in '%s' line %ld); %s; [%s]\n",
Type,
Err,
ChrPtr(TP->Tokens->FileName),
}
else
{
- lprintf(1, "%s: %s;\n",
+ syslog(1, "%s: %s;\n",
Type,
ChrPtr(Error));
}
StrBufVAppendPrintf(Error, Format, arg_ptr);
va_end(arg_ptr);
- lprintf(1, ChrPtr(Error));
+ syslog(1, ChrPtr(Error));
WCC = WC;
if (WCC->WFBuf == NULL) WCC->WFBuf = NewStrBuf();
}
-/*
- * debugging function to print array to log
- */
-void VarPrintTransition(void *vVar1, void *vVar2, int odd){}
-
-/*
- * debugging function to print array to log
- */
-void VarPrintEntry(const char *Key, void *vSubst, int odd)
-{
- wcsubst *ptr;
- lprintf(1,"Subst[%s] : ", Key);
- ptr = (wcsubst*) vSubst;
-
- switch(ptr->wcs_type) {
- case WCS_STRING:
- lprintf(1, " -> %s\n", ChrPtr(ptr->wcs_value));
- break;
- case WCS_SERVCMD:
- lprintf(1, " -> Server [%s]\n", ChrPtr(ptr->wcs_value));
- break;
- case WCS_FUNCTION:
- lprintf(1, " -> function at [%0xd]\n", ptr->wcs_function);
- break;
- default:
- lprintf(1," WARNING: invalid type: [%ld]!\n", ptr->wcs_type);
- }
-}
-
-
-
-/*
- * Clear out the list of substitution variables local to this session
- */
-void clear_substs(wcsession *wc) {
-
- if (wc->vars != NULL) {
- DeleteHash(&wc->vars);
- }
-}
-
-/*
- * Clear out the list of substitution variables local to this session
- */
-void clear_local_substs(void) {
- clear_substs (WC);
-}
-
-int NeedNewBuf(int type)
-{
- switch(type) {
- case WCS_STRING:
- case WCS_SERVCMD:
- case WCS_STRBUF:
- return 1;
- case WCS_FUNCTION:
- case WCS_STRBUF_REF:
- case WCS_LONG:
- default:
- return 0;
- }
-}
-
-void FlushPayload(wcsubst *ptr, int reusestrbuf, int type)
-{
- int NeedNew = NeedNewBuf(type);
- switch(ptr->wcs_type) {
- case WCS_STRING:
- case WCS_SERVCMD:
- case WCS_STRBUF:
- if (reusestrbuf && NeedNew) {
- FlushStrBuf(ptr->wcs_value);
- }
- else {
-
- FreeStrBuf(&ptr->wcs_value);
- ptr->wcs_value = NULL;
- }
- break;
- case WCS_FUNCTION:
- ptr->wcs_function = NULL;
- if (reusestrbuf && NeedNew)
- ptr->wcs_value = NewStrBuf();
- break;
- case WCS_STRBUF_REF:
- ptr->wcs_value = NULL;
- if (reusestrbuf && NeedNew)
- ptr->wcs_value = NewStrBuf();
- break;
- case WCS_LONG:
- ptr->lvalue = 0;
- if (reusestrbuf && NeedNew)
- ptr->wcs_value = NewStrBuf();
- break;
- default:
- if (reusestrbuf && NeedNew)
- ptr->wcs_value = NewStrBuf();
- break;
- }
-}
-
-
-/*
- * destructor; kill one entry.
- */
-void deletevar(void *data)
-{
- wcsubst *ptr = (wcsubst*)data;
- FlushPayload(ptr, 0, ptr->wcs_type);
- free(ptr);
-}
-
-
-wcsubst *NewSubstVar(const char *keyname, int keylen, int type)
-{
- wcsubst* ptr;
- wcsession *WCC = WC;
-
- ptr = (wcsubst *) malloc(sizeof(wcsubst));
- memset(ptr, 0, sizeof(wcsubst));
-
- ptr->wcs_type = type;
- safestrncpy(ptr->wcs_key, keyname, sizeof ptr->wcs_key);
- Put(WCC->vars, keyname, keylen, ptr, deletevar);
-
- switch(ptr->wcs_type) {
- case WCS_STRING:
- case WCS_SERVCMD:
- ptr->wcs_value = NewStrBuf();
- break;
- case WCS_STRBUF:
- case WCS_FUNCTION:
- case WCS_STRBUF_REF:
- case WCS_LONG:
- default:
- break;
- }
- return ptr;
-}
-
-
-/*
- * Add a substitution variable (local to this session) (strlen version...)
- * keyname the replacementstring to substitute
- * keytype the kind of the key
- * format the format string ala printf
- * ... the arguments to substitute in the formatstring
- */
-void SVPRINTF(char *keyname, int keytype, const char *format,...)
-{
- va_list arg_ptr;
- void *vPtr;
- wcsubst *ptr = NULL;
- size_t keylen;
- wcsession *WCC = WC;
-
- keylen = strlen(keyname);
- /*
- * First look if we're doing a replacement of
- * an existing key
- */
- /*PrintHash(WCC->vars, VarPrintTransition, VarPrintEntry);*/
- if (GetHash(WCC->vars, keyname, keylen, &vPtr)) {
- ptr = (wcsubst*)vPtr;
- FlushPayload(ptr, keytype, keytype);
- ptr->wcs_type = keytype;
- }
- else /** Otherwise allocate a new one */
- {
- ptr = NewSubstVar(keyname, keylen, keytype);
- }
-
- /* Format the string */
- va_start(arg_ptr, format);
- StrBufVAppendPrintf(ptr->wcs_value, format, arg_ptr);
- va_end(arg_ptr);
-}
-
-/*
- * Add a substitution variable (local to this session)
- * keyname the replacementstring to substitute
- * keytype the kind of the key
- * format the format string ala printf
- * ... the arguments to substitute in the formatstring
- */
-void svprintf(char *keyname, size_t keylen, int keytype, const char *format,...)
-{
- va_list arg_ptr;
- void *vPtr;
- wcsubst *ptr = NULL;
- wcsession *WCC = WC;
-
- /*
- * First look if we're doing a replacement of
- * an existing key
- */
- /*PrintHash(WCC->vars, VarPrintTransition, VarPrintEntry);*/
- if (GetHash(WCC->vars, keyname, keylen, &vPtr)) {
- ptr = (wcsubst*)vPtr;
- FlushPayload(ptr, 1, keytype);
- ptr->wcs_type = keytype;
- }
- else /** Otherwise allocate a new one */
- {
- ptr = NewSubstVar(keyname, keylen, keytype);
- }
-
- /** Format the string and save it */
- va_start(arg_ptr, format);
- StrBufVAppendPrintf(ptr->wcs_value, format, arg_ptr);
- va_end(arg_ptr);
-}
-
-/*
- * Add a substitution variable (local to this session)
- * keyname the replacementstring to substitute
- * keytype the kind of the key
- * format the format string ala printf
- * ... the arguments to substitute in the formatstring
- */
-void SVPut(char *keyname, size_t keylen, int keytype, char *Data)
-{
- void *vPtr;
- wcsubst *ptr = NULL;
- wcsession *WCC = WC;
-
-
- /*
- * First look if we're doing a replacement of
- * an existing key
- */
- /*PrintHash(WCC->vars, VarPrintTransition, VarPrintEntry);*/
- if (GetHash(WCC->vars, keyname, keylen, &vPtr)) {
- ptr = (wcsubst*)vPtr;
- FlushPayload(ptr, 1, keytype);
- ptr->wcs_type = keytype;
- }
- else /** Otherwise allocate a new one */
- {
- ptr = NewSubstVar(keyname, keylen, keytype);
- }
- StrBufAppendBufPlain(ptr->wcs_value, Data, -1, 0);
-}
-
-/**
- * \brief Add a substitution variable (local to this session)
- * \param keyname the replacementstring to substitute
- * \param keytype the kind of the key
- * \param format the format string ala printf
- * \param ... the arguments to substitute in the formatstring
- */
-void SVPutLong(char *keyname, size_t keylen, long Data)
-{
- void *vPtr;
- wcsubst *ptr = NULL;
- wcsession *WCC = WC;
-
-
- /**
- * First look if we're doing a replacement of
- * an existing key
- */
- /*PrintHash(WCC->vars, VarPrintTransition, VarPrintEntry);*/
- if (GetHash(WCC->vars, keyname, keylen, &vPtr)) {
- ptr = (wcsubst*)vPtr;
- FlushPayload(ptr, 1, WCS_LONG);
- ptr->wcs_type = WCS_LONG;
- }
- else /** Otherwise allocate a new one */
- {
- ptr = NewSubstVar(keyname, keylen, WCS_LONG);
- }
- ptr->lvalue = Data;
-}
-
-/**
- * \brief Add a substitution variable (local to this session) that does a callback
- * \param keyname the keystring to substitute
- * \param fcn_ptr the function callback to give the substitution string
- */
-void SVCallback(char *keyname, size_t keylen, WCHandlerFunc fcn_ptr)
-{
- wcsubst *ptr;
- void *vPtr;
- wcsession *WCC = WC;
-
- /**
- * First look if we're doing a replacement of
- * an existing key
- */
- /*PrintHash(WCC->vars, VarPrintTransition, VarPrintEntry);*/
- if (GetHash(WCC->vars, keyname, keylen, &vPtr)) {
- ptr = (wcsubst*)vPtr;
- FlushPayload(ptr, 1, WCS_FUNCTION);
- ptr->wcs_type = WCS_FUNCTION;
- }
- else /** Otherwise allocate a new one */
- {
- ptr = NewSubstVar(keyname, keylen, WCS_FUNCTION);
- }
-
- ptr->wcs_function = fcn_ptr;
-}
-inline void SVCALLBACK(char *keyname, WCHandlerFunc fcn_ptr)
-{
- SVCallback(keyname, strlen(keyname), fcn_ptr);
-}
-
-
-
-void SVPUTBuf(const char *keyname, int keylen, const StrBuf *Buf, int ref)
-{
- wcsubst *ptr;
- void *vPtr;
- wcsession *WCC = WC;
-
- /**
- * First look if we're doing a replacement of
- * an existing key
- */
- /*PrintHash(WCC->vars, VarPrintTransition, VarPrintEntry);*/
- if (GetHash(WCC->vars, keyname, keylen, &vPtr)) {
- ptr = (wcsubst*)vPtr;
- FlushPayload(ptr, 0, (ref)?WCS_STRBUF_REF:WCS_STRBUF);
- ptr->wcs_type = (ref)?WCS_STRBUF_REF:WCS_STRBUF;
- }
- else /** Otherwise allocate a new one */
- {
- ptr = NewSubstVar(keyname, keylen, (ref)?WCS_STRBUF_REF:WCS_STRBUF);
- }
- ptr->wcs_value = (StrBuf*)Buf;
-}
/**
* \brief back end for print_value_of() ... does a server command
*Value = ChrPtr(Buf);
*len = StrLength(Buf);
/* we can't free it here, so we put it into the subst so its discarded later on. */
- SVPUTBuf(TKEY(N), Buf, 0);
+ PutRequestLocalMem(Buf, HFreeStrBuf);
break;
default:
}
-
-/**
- * \brief Print the value of a variable
- * \param keyname get a key to print
- */
-void print_value_of(StrBuf *Target, WCTemplputParams *TP)
-
-{
- wcsession *WCC = WC;
- wcsubst *ptr;
- void *vVar;
-
- /*if (WCC->vars != NULL) PrintHash(WCC->vars, VarPrintTransition, VarPrintEntry);*/
- /* TODO: depricated! */
- if (TP->Tokens->pName[0] == '=') {
- DoTemplate(TP->Tokens->pName+1, TP->Tokens->NameEnd - 1, NULL, &NoCtx);
- }
-/*/////TODO: if param[1] == "U" -> urlescape
-/// X -> escputs */
- /** Page-local variables */
- if ((WCC->vars!= NULL) && GetHash(WCC->vars, TP->Tokens->pName, TP->Tokens->NameEnd, &vVar)) {
- ptr = (wcsubst*) vVar;
- switch(ptr->wcs_type) {
- case WCS_STRING:
- StrBufAppendBuf(Target, ptr->wcs_value, 0);
- break;
- case WCS_SERVCMD:
- pvo_do_cmd(Target, ptr->wcs_value);
- break;
- case WCS_FUNCTION:
- (*ptr->wcs_function) (Target, TP);
- break;
- case WCS_STRBUF:
- case WCS_STRBUF_REF:
- StrBufAppendBuf(Target, ptr->wcs_value, 0);
- break;
- case WCS_LONG:
- StrBufAppendPrintf(Target, "%ld", ptr->lvalue);
- break;
- default:
- LogTemplateError(
- Target, "Subst", ERR_NAME, TP,
- "WARNING: invalid value in SV-Hash at %s!", TP->Tokens->pName);
- }
- }
- else {
- LogTemplateError(
- Target, "Token", ERR_NAME, TP,
- "didn't find Handler \"%s\"", TP->Tokens->pName);
- wc_backtrace();
- }
-}
-
-int CompareSubstToToken(TemplateParam *ParamToCompare, TemplateParam *ParamToLookup)
-{
- wcsession *WCC = WC;
- wcsubst *ptr;
- void *vVar;
-
- if ((WCC->vars!= NULL) && GetHash(WCC->vars, ParamToLookup->Start,
- ParamToLookup->len, &vVar)) {
- ptr = (wcsubst*) vVar;
- switch(ptr->wcs_type) {
- case WCS_STRING:
- case WCS_STRBUF:
- case WCS_STRBUF_REF:
- if (ParamToCompare->Type == TYPE_STR)
- return ((ParamToCompare->len == StrLength(ptr->wcs_value)) &&
- (strcmp(ParamToCompare->Start, ChrPtr(ptr->wcs_value)) == 0));
- else
- return ParamToCompare->lvalue == StrTol(ptr->wcs_value);
- break;
- case WCS_SERVCMD:
- return 1;
- break;
- case WCS_FUNCTION:
- return 1;
- case WCS_LONG:
- if (ParamToCompare->Type == TYPE_STR)
- return 0;
- else
- return ParamToCompare->lvalue == ptr->lvalue;
- break;
- default:
- lprintf(1,"WARNING: invalid value in SV-Hash at %s!\n",
- ParamToLookup->Start);
- }
- }
- return 0;
-}
-
-int CompareSubstToStrBuf(StrBuf *Compare, TemplateParam *ParamToLookup)
-{
- wcsession *WCC = WC;
- wcsubst *ptr;
- void *vVar;
-
- if ((WCC->vars!= NULL) && GetHash(WCC->vars, ParamToLookup->Start,
- ParamToLookup->len, &vVar)) {
- ptr = (wcsubst*) vVar;
- switch(ptr->wcs_type) {
- case WCS_STRING:
- case WCS_STRBUF:
- case WCS_STRBUF_REF:
- return ((StrLength(Compare) == StrLength(ptr->wcs_value)) &&
- (strcmp(ChrPtr(Compare), ChrPtr(ptr->wcs_value)) == 0));
- case WCS_SERVCMD:
- return 1;
- break;
- case WCS_FUNCTION:
- return 1;
- case WCS_LONG:
- return StrTol(Compare) == ptr->lvalue;
- default:
- lprintf(1,"WARNING: invalid value in SV-Hash at %s!\n",
- ParamToLookup->Start);
- }
- }
- return 0;
-}
-
-
-
/**
* \brief puts string into the template and computes which escape methon we should use
* \param Source the string we should put into the template
}
pche = pch;
if (*pch != quote) {
- lprintf(1, "Error (in '%s' line %ld); "
+ syslog(1, "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) {
- lprintf(1, "DBG: got param [%s] %ld %ld\n",
+ syslog(1, "DBG: got param [%s] %ld %ld\n",
pchs, pche - pchs, strlen(pchs));
}
Parm->Start = pchs;
else {
Parm->lvalue = 0;
/* TODO whUT?
- lprintf(1, "Error (in '%s' line %ld); "
+ syslog(1, "Error (in '%s' line %ld); "
"evaluating long template param [%s] in Token [%s]\n",
ChrPtr(pTmpl->FileName),
Tokens->Line,
}
}
}
+ FreeStrBuf(&pToken);
+ FreeStrBuf(&Match);
}
else if (strchr(Parm->Start, '&') != NULL)
{
}
}
}
+ FreeStrBuf(&Match);
+ FreeStrBuf(&pToken);
}
else {
fd = open(ChrPtr(NewTemplate->FileName), O_RDONLY);
if (fd <= 0) {
- lprintf(1, "ERROR: could not open template '%s' - %s\n",
+ syslog(1, "ERROR: could not open template '%s' - %s\n",
ChrPtr(NewTemplate->FileName), strerror(errno));
return NULL;
}
if (fstat(fd, &statbuf) == -1) {
- lprintf(1, "ERROR: could not stat template '%s' - %s\n",
+ syslog(1, "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);
- lprintf(1, "ERROR: reading template '%s' - %s<br />\n",
+ syslog(1, "ERROR: reading template '%s' - %s<br>\n",
ChrPtr(NewTemplate->FileName), strerror(errno));
//FreeWCTemplate(NewTemplate);/////tODO
return NULL;
const char *pts, *pte;
int InQuotes = 0;
int InDoubleQuotes = 0;
+ void *pv;
/** Find one <? > */
pos = (-1);
if (pch + 1 > pE)
continue;
pte = pch;
- PutNewToken(NewTemplate,
- NewTemplateSubstitute(NewTemplate->Data, pS, pts, pte, Line, NewTemplate));
- pch ++;
+ pv = NewTemplateSubstitute(NewTemplate->Data, pS, pts, pte, Line, NewTemplate);
+ if (pv != NULL) {
+ PutNewToken(NewTemplate, pv);
+ pch ++;
+ }
}
return NewTemplate;
}
}
-int LoadTemplateDir(const StrBuf *DirName, HashList *wireless, HashList *big, const StrBuf *BaseKey)
+int LoadTemplateDir(const StrBuf *DirName, HashList *big, const StrBuf *BaseKey)
{
int Toplevel;
StrBuf *FileName;
int d_type = 0;
int d_namelen;
int d_without_ext;
- int IsMobile;
d = (struct dirent *)malloc(offsetof(struct dirent, d_name) + PATH_MAX + 1);
if (d == NULL) {
StrBufAppendBufPlain(SubDirectory, HKEY("/"), 0);
StrBufAppendBufPlain(SubDirectory, filedir_entry->d_name, d_namelen, 0);
- LoadTemplateDir(SubDirectory, wireless, big, SubKey);
+ LoadTemplateDir(SubDirectory, big, SubKey);
break;
case DT_LNK: /* TODO: check whether its a file or a directory */
(strcmp(&filedir_entry->d_name[d_without_ext], ".orig") == 0) ||
(strcmp(&filedir_entry->d_name[d_without_ext], ".swp") == 0))
continue; /* Ignore backup files... */
- /* .m.xxx is for mobile useragents! */
- IsMobile = 0;
- if (d_without_ext > 2)
- IsMobile = (filedir_entry->d_name[d_without_ext - 1] == 'm') &&
- (filedir_entry->d_name[d_without_ext - 2] == '.');
PStart = filedir_entry->d_name;
StrBufPrintf(FileName, "%s/%s", ChrPtr(DirName), filedir_entry->d_name);
MinorPtr = strchr(filedir_entry->d_name, '.');
StrBufAppendBufPlain(Key, filedir_entry->d_name, MinorPtr - filedir_entry->d_name, 0);
if (LoadTemplates >= 1)
- lprintf(1, "%s %d %s\n", ChrPtr(FileName), IsMobile, ChrPtr(Key));
- prepare_template(FileName, Key, (IsMobile)?wireless:big);
+ syslog(1, "%s %s\n", ChrPtr(FileName), ChrPtr(Key));
+ prepare_template(FileName, Key, big);
default:
break;
}
int i;
StrBuf *Key;
StrBuf *Dir;
- HashList *Templates[4];
+ HashList *Templates[2];
Dir = NewStrBuf();
Key = NewStrBuf();
/* Primary Template set... */
StrBufPrintf(Dir, "%s/t", static_dirs[0]);
LoadTemplateDir(Dir,
- WirelessTemplateCache,
TemplateCache,
Key);
/* User local Template set */
StrBufPrintf(Dir, "%s/t", static_dirs[1]);
LoadTemplateDir(Dir,
- WirelessLocalTemplateCache,
LocalTemplateCache,
Key);
StrBufPrintf(Dir, "%s/dbg", static_dirs[0]);
LoadTemplateDir(Dir,
- WirelessTemplateCache,
TemplateCache,
Key);
- Templates[0] = WirelessTemplateCache;
- Templates[1] = TemplateCache;
- Templates[2] = WirelessLocalTemplateCache;
- Templates[3] = LocalTemplateCache;
+ Templates[0] = TemplateCache;
+ Templates[1] = LocalTemplateCache;
if (LoadTemplates == 0)
- for (i=0; i < 4; i++) {
+ for (i=0; i < 2; i++) {
const char *Key;
long KLen;
HashPos *At;
void *vVar;
/* much output, since pName is not terminated...
- lprintf(1,"Doing token: %s\n",Token->pName);
+ syslog(1,"Doing token: %s\n",Token->pName);
*/
switch (TP->Tokens->Flags) {
}
}
else {
- print_value_of(Target, TP);
+ LogTemplateError(
+ Target, "Token UNKNOWN", ERR_NAME, TP,
+ "You've specified a token that isn't known to webcit.!");
}
}
return 0;
if (LoadTemplates != 0) {
if (LoadTemplates > 1)
- lprintf(1, "DBG: ----- loading: [%s] ------ \n",
+ syslog(1, "DBG: ----- loading: [%s] ------ \n",
ChrPtr(Tmpl->FileName));
pTmpl = duplicate_template(Tmpl);
if(load_template(pTmpl) == NULL) {
TP = &LocalTP;
}
- if (WC->is_mobile > 0) {
- Static = WirelessTemplateCache;
- StaticLocal = WirelessLocalTemplateCache;
- }
- else {
- Static = TemplateCache;
- StaticLocal = LocalTemplateCache;
- }
+ Static = TemplateCache;
+ StaticLocal = LocalTemplateCache;
if (len == 0)
{
- lprintf (1, "Can't to load a template with empty name!\n");
+ syslog(1, "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;
}
if (!GetHash(StaticLocal, templatename, len, &vTmpl) &&
!GetHash(Static, templatename, len, &vTmpl)) {
- lprintf (1, "didn't find Template [%s] %ld %ld\n", templatename, len , (long)strlen(templatename));
+ syslog(1, "didn't find Template [%s] %ld %ld\n", templatename, len , (long)strlen(templatename));
StrBufAppendPrintf(Target, "<pre>\ndidn't find Template [%s] %ld %ld\n</pre>",
templatename, len,
(long)strlen(templatename));
(It->XPectContextType != TP->Filter.ContextType)) {
LogTemplateError(
Target, "Iterator", ERR_PARM1, TP,
- "requires context of type %d, have %d",
- It->XPectContextType,
- TP->Filter.ContextType);
+ "requires context of type %s, have %s",
+ ContextName(It->XPectContextType),
+ ContextName(TP->Filter.ContextType));
return ;
}
if (GetHash(SortHash, SKEY(BSort), &vSortBy) &&
(vSortBy != NULL)) {
SortBy = (SortStruct*)vSortBy;
+ /* first check whether its intended for us... */
+ if ((SortBy->ContextType == It->ContextType)&&
/** Ok, its us, lets see in which direction we should sort... */
- if (havebstr("SortOrder")) {
+ (havebstr("SortOrder"))) {
int SortOrder;
SortOrder = LBSTR("SortOrder");
if (SortOrder != 0)
int EvaluateConditional(StrBuf *Target, int Neg, int state, WCTemplputParams *TP)
{
ConditionalStruct *Cond;
+ int rc = 0;
+ int res;
if ((TP->Tokens->Params[0]->len == 1) &&
(TP->Tokens->Params[0]->Start[0] == 'X'))
if (!CheckContext(Target, &Cond->Filter, TP, "Conditional")) {
return 0;
}
-
- if (Cond->CondF(Target, TP) == Neg)
- return TP->Tokens->Params[1]->lvalue;
- return 0;
-}
-
-int ConditionalVar(StrBuf *Target, WCTemplputParams *TP)
-{
- void *vsubst;
- wcsubst *subst;
-
- if (!GetHash(WC->vars, TKEY(2), &vsubst))
- return 0;
- subst = (wcsubst*) vsubst;
-
- switch(subst->wcs_type) {
- case WCS_FUNCTION:
- return (subst->wcs_function!=NULL);
- case WCS_SERVCMD:
- lprintf(1, " -> Server [%s]\n", subst->wcs_value);/* TODO */
- return 1;
- case WCS_STRING:
- case WCS_STRBUF:
- case WCS_STRBUF_REF:
- if (TP->Tokens->nParameters < 4)
- return 1;
- return (strcmp(TP->Tokens->Params[3]->Start, ChrPtr(subst->wcs_value)) == 0);
- case WCS_LONG:
- if (TP->Tokens->nParameters < 4)
- return (subst->lvalue != 0);
- return (subst->lvalue == TP->Tokens->Params[3]->lvalue);
- default:
- lprintf(1," WARNING: invalid type: [%ld]!\n", subst->wcs_type);
- return -1;
- }
- return 0;
+ res = Cond->CondF(Target, TP);
+ if (res == Neg)
+ rc = TP->Tokens->Params[1]->lvalue;
+ if (LoadTemplates > 5)
+ syslog(1, "<%s> : %d %d==%d\n",
+ ChrPtr(TP->Tokens->FlatToken),
+ rc, res, Neg);
+ return rc;
}
void RegisterConditional(const char *Name, long len,
NewSort->GroupChange = GroupChange;
NewSort->ContextType = ContextType;
if (ContextType == CTX_NONE) {
- lprintf(1, "sorting requires a context. CTX_NONE won't make it.\n");
+ syslog(1, "sorting requires a context. CTX_NONE won't make it.\n");
exit(1);
}
StrBufAppendPrintf(Buf, "%d: %ld]\n", i, LongVector[i]);
}
- lprintf(1, ChrPtr(Buf));
+ syslog(1, ChrPtr(Buf));
FreeStrBuf(&Buf);
}
RegisterNamespace("LONGVECTOR", 1, 1, tmplput_long_vector, NULL, CTX_LONGVECTOR);
- RegisterConditional(HKEY("COND:SUBST"), 3, ConditionalVar, CTX_NONE);
RegisterConditional(HKEY("COND:CONTEXTSTR"), 3, ConditionalContextStr, CTX_STRBUF);
RegisterConditional(HKEY("COND:CONTEXTSTRARR"), 4, ConditionalContextStrinArray, CTX_STRBUFARR);
RegisterConditional(HKEY("COND:LONGVECTOR"), 4, ConditionalLongVector, CTX_LONGVECTOR);
ServerStartModule_SUBST
(void)
{
- WirelessTemplateCache = NewHash(1, NULL);
- WirelessLocalTemplateCache = NewHash(1, NULL);
LocalTemplateCache = NewHash(1, NULL);
TemplateCache = NewHash(1, NULL);
ServerShutdownModule_SUBST
(void)
{
- DeleteHash(&WirelessTemplateCache);
- DeleteHash(&WirelessLocalTemplateCache);
DeleteHash(&TemplateCache);
DeleteHash(&LocalTemplateCache);
SessionAttachModule_SUBST
(wcsession *sess)
{
- sess->vars = NewHash(1,NULL);
}
void
SessionDetachModule_SUBST
(wcsession *sess)
{
- DeleteHash(&sess->vars);
FreeStrBuf(&sess->WFBuf);
}