void RelLink(DPS_AGENT *Indexer, DPS_URL *curURL, DPS_URL *newURL, char **str, int ReverseAliasFlag) {
const char *schema = newURL->schema ? newURL->schema : curURL->schema;
const char *hostname = newURL->hostname ? newURL->hostname : curURL->hostname;
const char *auth = newURL->auth ? newURL->auth : curURL->auth;
const char *path = (newURL->path && newURL->path[0]) ? newURL->path : curURL->path;
const char *fname = ((newURL->filename && newURL->filename[0]) || (newURL->path && newURL->path[0])) ?
newURL->filename : curURL->filename;
const char *query_string = newURL->query_string;
char *pathfile = (char*)DpsMalloc(dps_strlen(DPS_NULL2EMPTY(path)) + dps_strlen(DPS_NULL2EMPTY(fname)) +
dps_strlen(DPS_NULL2EMPTY(query_string)) + 5);
int cascade;
DPS_MATCH *Alias;
char *alias = NULL;
size_t aliassize, nparts = 10;
DPS_MATCH_PART Parts[10];
if (newURL->hostinfo == NULL) newURL->charset_id = curURL->charset_id;
if (pathfile == NULL) return;
/* sprintf(pathfile, "/%s%s%s", DPS_NULL2EMPTY(path), DPS_NULL2EMPTY(fname), DPS_NULL2EMPTY(query_string));*/
pathfile[0] = '/';
dps_strcpy(pathfile + 1, DPS_NULL2EMPTY(path)); dps_strcat(pathfile, DPS_NULL2EMPTY(fname)); dps_strcat(pathfile, DPS_NULL2EMPTY(query_string));
DpsURLNormalizePath(pathfile);
if (!strcasecmp(DPS_NULL2EMPTY(schema), "mailto")
|| !strcasecmp(DPS_NULL2EMPTY(schema), "javascript")
|| !strcasecmp(DPS_NULL2EMPTY(schema), "feed")
) {
*str = (char*)DpsMalloc(dps_strlen(DPS_NULL2EMPTY(schema)) + dps_strlen(DPS_NULL2EMPTY(newURL->specific)) + 4);
if (*str == NULL) return;
/* sprintf(*str, "%s:%s", DPS_NULL2EMPTY(schema), DPS_NULL2EMPTY(newURL->specific));*/
dps_strcpy(*str, DPS_NULL2EMPTY(schema)); dps_strcat(*str, ":"); dps_strcat(*str, DPS_NULL2EMPTY(newURL->specific));
} else if(/*!strcasecmp(DPS_NULL2EMPTY(schema), "file") ||*/ !strcasecmp(DPS_NULL2EMPTY(schema), "htdb")) {
*str = (char*)DpsMalloc(dps_strlen(DPS_NULL2EMPTY(schema)) + dps_strlen(pathfile) + 4);
if (*str == NULL) return;
/* sprintf(*str, "%s:%s", DPS_NULL2EMPTY(schema), pathfile);*/
dps_strcpy(*str, DPS_NULL2EMPTY(schema)); dps_strcat(*str, ":"); dps_strcat(*str, pathfile);
}else{
*str = (char*)DpsMalloc(dps_strlen(DPS_NULL2EMPTY(schema)) + dps_strlen(pathfile) + dps_strlen(DPS_NULL2EMPTY(hostname)) + dps_strlen(DPS_NULL2EMPTY(auth)) + 8);
if (*str == NULL) return;
/* sprintf(*str, "%s://%s%s", DPS_NULL2EMPTY(schema), DPS_NULL2EMPTY(hostinfo), pathfile);*/
dps_strcpy(*str, DPS_NULL2EMPTY(schema)); dps_strcat(*str, "://");
if (auth) {
dps_strcat(*str, auth); dps_strcat(*str,"@");
}
dps_strcat(*str, DPS_NULL2EMPTY(hostname)); dps_strcat(*str, pathfile);
}
if(!strncmp(*str, "ftp://", 6) && (strstr(*str, ";type=")))
*(strstr(*str, ";type")) = '\0';
DPS_FREE(pathfile);
if (ReverseAliasFlag) {
const char *alias_prog = DpsVarListFindStr(&Indexer->Vars, "ReverseAliasProg", NULL);
if (alias_prog) {
int result;
aliassize = 256 + 2 * dps_strlen(*str);
alias = (char*)DpsRealloc(alias, aliassize);
if (alias == NULL) {
DpsLog(Indexer, DPS_LOG_ERROR, "No memory (%d bytes). %s line %d", aliassize, __FILE__, __LINE__);
goto ret;
}
alias[0] = '\0';
result = DpsAliasProg(Indexer, alias_prog, *str, alias, aliassize - 1);
DpsLog(Indexer, DPS_LOG_EXTRA, "ReverseAliasProg result: '%s'", alias);
if(result != DPS_OK) goto ret;
DPS_FREE(*str);
*str = (char*)DpsStrdup(alias);
}
for(cascade = 0; ((Alias=DpsMatchListFind(&Indexer->Conf->ReverseAliases,*str,nparts,Parts))) && (cascade < 1024); cascade++) {
aliassize = dps_strlen(Alias->arg) + dps_strlen(Alias->pattern) + dps_strlen(*str) + 128;
alias = (char*)DpsRealloc(alias, aliassize);
if (alias == NULL) {
DpsLog(Indexer, DPS_LOG_ERROR, "No memory (%d bytes). %s line %d", aliassize, __FILE__, __LINE__);
goto ret;
}
DpsMatchApply(alias,aliassize,*str,Alias->arg,Alias,nparts,Parts);
if(alias[0]){
DpsLog(Indexer,DPS_LOG_DEBUG,"ReverseAlias%d: pattern:%s, arg:%s -> '%s'", cascade, Alias->pattern, Alias->arg, alias);
DPS_FREE(*str);
*str = (char*)DpsStrdup(alias);
} else break;
if (Alias->last) break;
}
}
ret:
DPS_FREE(alias);
}
int _DpsURLParse(DPS_URL *url, const char *str, const char *filename, int line) {
#else
int DpsURLParse(DPS_URL *url, const char *str) {
#endif
char *schema,*anchor,*file,*query;
char *s;
/* size_t len = dps_strlen(str);*/
#ifdef WITH_PARANOIA
void * paran = DpsViolationEnter(paran);
#endif
#ifdef DEBUG_URL
fprintf(stderr, " -- %s:%d Parser url: %s\n", filename, line, str);
#endif
DPS_FREE(url->schema);
DPS_FREE(url->specific);
DPS_FREE(url->hostinfo);
DPS_FREE(url->hostname);
DPS_FREE(url->anchor);
DPS_FREE(url->auth);
url->port=0;
url->default_port=0;
DPS_FREE(url->path);
DPS_FREE(url->directory);
DPS_FREE(url->filename);
DPS_FREE(url->query_string);
/* if(len >= DPS_URLSIZE)return(DPS_URL_LONG); FIXME: Chage this cheking for configured parameter, not DPS_URLSIZE */
s = (char*)DpsStrdup(str);
if (s == NULL) {
#ifdef WITH_PARANOIA
DpsViolationExit(-1, paran);
#endif
return DPS_ERROR;
}
url->len = dps_strlen(str);
/* Find possible schema end than */
/* Check that it is really schema */
/* It must consist of alphas only */
/* We will take in account digits */
/* also for oracle8:// for example */
/* We must check it because */
/* It might be anchor also */
/* For example: */
/* "mod/index.html#a:1" */
if((schema=strchr(s,':'))){
const char * ch;
for(ch=s;ch<schema;ch++){
if(!isalnum(*ch)){
/* Bad character */
/* so it is not schema */
schema=0;break;
}
}
}
if(schema){
/* Have scheme - absolute path */
*schema=0;
url->schema = (char*)DpsStrdup(s);
url->specific = (char*)DpsStrdup(schema + 1);
*schema=':';
if(!strcasecmp(url->schema,"http"))url->default_port=80;
else
if(!strcasecmp(url->schema,"https"))url->default_port=443;
else
if(!strcasecmp(url->schema,"nntp"))url->default_port=119;
else
if(!strcasecmp(url->schema,"news"))url->default_port=119;
else
if(!strcasecmp(url->schema,"ftp"))url->default_port=21;
if(!strncmp(url->specific,"//",2)){
char *ss,*hostname;
/* Have hostinfo */
if((ss=strchr(url->specific+2,'/'))){
/* Have hostname with path */
*ss=0;
url->hostinfo = (char*)DpsStrdup(url->specific + 2);
*ss='/';
url->path = (char*)DpsStrdup(ss);
}else{
/* Hostname without path */
if ((ss = strchr(url->specific + 2, '?'))) {
/* Have hostname with parameters */
*ss = 0;
url->hostinfo = (char*)DpsStrdup(url->specific + 2);
*ss='?';
url->path = (char*)DpsStrdup("/");
}else {
url->hostinfo = (char*)DpsStrdup(url->specific + 2);
url->path = (char*)DpsStrdup("/");
}
}
if((hostname=strchr(url->hostinfo,'@'))){
/* Username and password is given */
/* Store auth string user:password */
*hostname=0;
url->auth = (char*)DpsStrdup(url->hostinfo);
*hostname='@';
hostname++;
}else{
hostname = url->hostinfo;
}
/*
FIXME:
for(h=hostname;*h;h++){
if( *h>='A' && *h<='Z')
*h=(*h)-'A'+'a';
}
*/
if((ss=strchr(hostname,':'))){
*ss=0;
url->hostname = (char*)DpsStrdup(hostname);
*ss=':';
url->port=atoi(ss+1);
}else{
url->hostname = (char*)DpsStrdup(hostname);
url->port=0;
}
}else{
/* Have not host but have schema */
/* This is possible for: */
/* file: mailto: htdb: news: */
/* As far as we do not need mailto: just ignore it */
if(!strcasecmp(url->schema,"mailto")
|| !strcasecmp(url->schema,"javascript")
|| !strcasecmp(url->schema,"feed")
) {
DPS_FREE(s);
#ifdef WITH_PARANOIA
DpsViolationExit(-1, paran);
#endif
return(DPS_URL_BAD);
} else
if(!strcasecmp(url->schema,"file"))
url->path = (char*)DpsStrdup(url->specific);
else
if(!strcasecmp(url->schema,"exec"))
url->path = (char*)DpsStrdup(url->specific);
else
if(!strcasecmp(url->schema,"cgi"))
url->path = (char*)DpsStrdup(url->specific);
else
if(!strcasecmp(url->schema,"htdb"))
url->path = (char*)DpsStrdup(url->specific);
else
if(!strcasecmp(url->schema,"news")){
/* Now we will use localhost as NNTP */
/* server as it is not indicated in URL */
url->hostname = (char*)DpsStrdup("localhost");
url->path = (char*)DpsMalloc(dps_strlen(url->specific) + 2);
if (url->path == NULL) {
DPS_FREE(s);
#ifdef WITH_PARANOIA
DpsViolationExit(-1, paran);
#endif
return DPS_ERROR;
}
sprintf(url->path,"/%s",url->specific);
url->default_port=119;
}else{
/* Unknown strange schema */
DPS_FREE(s);
#ifdef WITH_PARANOIA
DpsViolationExit(-1, paran);
#endif
return(DPS_URL_BAD);
}
}
}else{
url->path = (char*)DpsStrdup(s);
}
/* Cat an anchor if exist */
if((anchor=strstr(url->path,"#")))*anchor=0;
/* If path is not full just copy it to filename */
/* i.e. neither /usr/local/ nor c:/windows/temp/ */
if((url->path != NULL) && (url->path[0]!='/') && (url->path[0]!='?') && (url->path[1]!=':')) {
/* Relative path */
if(!strncmp(url->path,"./",2))
url->filename = (char*)DpsStrdup(url->path + 2);
else
url->filename = (char*)DpsStrdup(url->path);
url->path[0] = 0;
}
/* truncate path to query_string */
/* and store query_string */
if((query=strrchr(url->path,'?'))){
url->query_string = (char*)DpsStrdup(query);
*(query) = 0;
}
DpsURLNormalizePath(url->path);
/* Now find right '/' sign and copy the rest to filename */
if((file=strrchr(url->path,'/'))&&(strcmp(file,"/"))){
url->filename = (char*)DpsStrdup(file + 1);
*(file+1)=0;
}
/* Now find right '/' sign and copy the rest to directory */
if ((file = strrchr(url->path,'/'))) {
char *p_save = file;
for(file--; (file > url->path) && (*file != '/'); file--);
file++;
if (*file) {
*p_save = '\0';
url->directory = (char*)DpsStrdup(file);
*p_save = '/';
}
}
DPS_FREE(s);
if (url->hostname != NULL) {
DpsRTrim(url->hostname, ".");
url->domain_level = 1;
for (s = url->hostname; *s; s++) {
*s = dps_tolower(*s);
if (*s == '.') url->domain_level++;
if (strchr(",'\";", (int)*s)) {
#ifdef WITH_PARANOIA
DpsViolationExit(-1, paran);
#endif
return DPS_URL_BAD;
}
}
}
if (url->hostinfo != NULL) {
DpsRTrim(url->hostinfo, ".");
s = strchr(url->hostinfo, '@');
for (s = (s == NULL) ? url->hostinfo : s + 1; *s; s++) *s = dps_tolower(*s);
}
if (url->schema != NULL) for (s = url->schema; *s; s++) *s = dps_tolower(*s);
/* fprintf(stderr, "url: .path: %s port:%d\n", url->path, url->port);*/
#ifdef WITH_PARANOIA
DpsViolationExit(-1, paran);
#endif
return DPS_OK;
}
int main(int argc, char ** argv, char **envp) {
const char *env, *bcharset, *lcharset, *conf_dir;
char template_name[PATH_MAX+6]="";
char *template_filename = NULL;
char *query_string = NULL;
char self[1024]="";
char *url = NULL;
const char *ResultContentType;
int res,httpd=0;
size_t catcolumns = 0;
int page_size,page_number;
DPS_ENV *Env;
DPS_AGENT *Agent;
DPS_VARLIST query_vars;
/* Output Content-type if under HTTPD */
/* Some servers do not pass QUERY_STRING */
/* if the query was empty, so check */
/* REQUEST_METHOD too to be safe */
httpd=(getenv("QUERY_STRING")||getenv("REQUEST_METHOD"));
if (!(conf_dir=getenv("DPS_ETC_DIR")))
conf_dir=DPS_CONF_DIR;
DpsInit(argc, argv, envp);
Env=DpsEnvInit(NULL);
if (Env == NULL) {
if(httpd){
printf("Content-Type: text/plain\r\n\r\n");
}
printf("Can't alloc Env\n");
exit(0);
}
DpsVarListInit(&query_vars);
Agent = DpsAgentInit(NULL, Env, 0);
if (Agent == NULL) {
if(httpd){
printf("Content-Type: text/plain\r\n\r\n");
}
printf("Can't alloc Agent\n");
exit(0);
}
DpsVarListAddEnviron(&Env->Vars,"ENV");
/* Detect self and template name */
if((env = getenv("DPSEARCH_TEMPLATE")))
dps_strncpy(template_name, env, sizeof(template_name) - 1);
else if((env = getenv("PATH_INFO")) && env[0])
dps_strncpy(template_name, env + 1, sizeof(template_name) - 1);
if((env=getenv("DPSEARCH_SELF")))
dps_strncpy(self,env,sizeof(self)-1);
if((env=getenv("QUERY_STRING"))){
query_string = (char*)DpsRealloc(query_string, dps_strlen(env) + 2);
if (query_string == NULL) {
if(httpd){
printf("Content-Type: text/plain\r\n\r\n");
}
printf("Can't alloc query_string\n");
exit(0);
}
dps_strncpy(query_string, env, dps_strlen(env) + 1);
/* Hack for Russian Apache from apache.lexa.ru */
/* QUERY_STRING is already converted to server */
/* character set. We must print original query */
/* string instead however. Under usual apache */
/* we'll use QUERY_STRING. Note that query_vars */
/* list will contain not unescaped values, so */
/* we don't have to escape them when displaying */
env = getenv("CHARSET_SAVED_QUERY_STRING");
DpsParseQStringUnescaped(&query_vars,env?env:query_string);
/* Unescape and save variables from QUERY_STRING */
/* Env->Vars will have unescaped values however */
DpsParseQueryString(Agent,&Env->Vars,query_string);
template_filename = (char*)DpsStrdup(DpsVarListFindStr(&Env->Vars, "tmplt", ""));
if((env=getenv("REDIRECT_STATUS"))){
/* Check Apache internal redirect */
/* via "AddHandler" and "Action" */
if(!self[0]){
dps_strncpy(self,(env=getenv("REDIRECT_URL"))?env:"filler.cgi",sizeof(self)-1);
}
if(!template_name[0]){
dps_strncpy(template_name,(env=getenv("PATH_TRANSLATED"))?env:"",sizeof(template_name)-1);
}
if (*template_filename == '\0') {
DPS_FREE(template_filename);
template_filename = (char*)DpsStrdup("filler.htm");
}
}else{
/* CGI executed without Apache internal redirect */
/* Detect $Self variable with OS independant SLASHES */
if(!self[0]){
dps_strncpy(self,(env=getenv("SCRIPT_NAME"))?env:"filler.cgi",sizeof(self)-1);
}
if(!template_name[0]){
char *s,*e;
/*This is with OS specific SLASHES */
env=((env=getenv("SCRIPT_FILENAME"))?env:"filler.cgi");
if(strcmp(conf_dir,".")){
/* Take from the config directory */
dps_snprintf(template_name, sizeof(template_name)-1, "%s/%s",
conf_dir,(s=strrchr(env,DPSSLASH))?(s+1):(self));
}else{
/* Take from the current directory */
dps_strncpy(template_name,env,sizeof(template_name)-1);
}
/* Find right slash if it presents */
s=((s=strrchr(template_name,DPSSLASH))?s:template_name);
if (*template_filename == '\0') {
/* Find .cgi substring */
if ((e = strstr(s, ".cgi")) != NULL) {
/* Replace ".cgi" with ".htm" */
e[1]='h';e[2]='t';e[3]='m';
} else {
dps_strcat(s, ".htm");
}
e = strrchr(s, '/');
DPS_FREE(template_filename);
template_filename = (char*)DpsStrdup(e + 1);
} else {
dps_strncpy(s + 1, template_filename, sizeof(template_name) - (s - template_name) - 2);
}
}
}
}else{
/* Executed from command line */
/* or under server which does not */
/* pass an empty QUERY_STRING var */
if(argv[1]) {
query_string = (char*)DpsRealloc(query_string, dps_strlen(argv[1]) + 10);
if (query_string == NULL) {
if(httpd){
printf("Content-Type: text/plain\r\n\r\n");
}
printf("Can't realloc query_string\n");
exit(0);
}
sprintf(query_string, "q=%s", argv[1]);
} else {
query_string = (char*)DpsRealloc(query_string, 1024);
if (query_string == NULL) {
if(httpd){
printf("Content-Type: text/plain\r\n\r\n");
}
printf("Can't realloc query_string\n");
exit(0);
}
sprintf(query_string, "q=");
}
/* Hack for Russian Apache from apache.lexa.ru */
/* QUERY_STRING is already converted to server */
/* character set. We must print original query */
/* string instead however. Under usual apache */
/* we'll use QUERY_STRING. Note that query_vars */
/* list will contain not unescaped values, so */
/* we don't have to escape them when displaying */
env = getenv("CHARSET_SAVED_QUERY_STRING");
DpsParseQStringUnescaped(&query_vars,env?env:query_string);
/* Unescape and save variables from QUERY_STRING */
/* Env->Vars will have unescaped values however */
DpsParseQueryString(Agent,&Env->Vars,query_string);
DPS_FREE(template_filename);
template_filename = (char*)DpsStrdup(DpsVarListFindStr(&Env->Vars, "tmplt", ""));
if (*template_filename == '\0') {
DPS_FREE(template_filename); template_filename = (char*)DpsStrdup("filler.htm");
}
/*// Get template name from command line variable &tmplt */
if(!template_name[0])
dps_snprintf(template_name,sizeof(template_name),"%s/%s", conf_dir, template_filename);
}
DpsVarListReplaceStr(&Agent->Conf->Vars, "tmplt", template_filename);
DPS_FREE(template_filename);
Agent->tmpl.Env_Vars = &Env->Vars;
DpsURLNormalizePath(template_name);
if (strncmp(template_name, conf_dir, dps_strlen(conf_dir))
|| (res = DpsTemplateLoad(Agent, Env, &Agent->tmpl, template_name))) {
if (strcmp(template_name, "filler.htm")) { /* trying load default template */
fprintf(stderr, "Can't load template: '%s' %s\n", template_name, Env->errstr);
DPS_FREE(template_filename);
template_filename = (char*)DpsStrdup("filler.htm");
dps_snprintf(template_name, sizeof(template_name), "%s/%s", conf_dir, template_filename);
if ((res = DpsTemplateLoad(Agent, Env, &Agent->tmpl, template_name))) {
if(httpd)printf("Content-Type: text/plain\r\n\r\n");
printf("%s\n",Env->errstr);
DpsVarListFree(&query_vars);
DpsEnvFree(Env);
DPS_FREE(query_string);
DpsAgentFree(Agent);
return(0);
}
} else {
if(httpd)printf("Content-Type: text/plain\r\n\r\n");
printf("%s\n",Env->errstr);
DpsVarListFree(&query_vars);
DpsEnvFree(Env);
DPS_FREE(query_string);
DpsAgentFree(Agent);
return(0);
}
}
/* set locale if specified */
if ((url = DpsVarListFindStr(&Env->Vars, "Locale", NULL)) != NULL) {
setlocale(LC_ALL, url);
/*#ifdef HAVE_ASPELL*/
{ char *p;
if ((p = strchr(url, '.')) != NULL) {
*p = '\0';
DpsVarListReplaceStr(&Env->Vars, "g-lc", url);
*p = '.';
}
}
/*#endif*/
url = NULL;
}
/* Call again to load search Limits if need */
DpsParseQueryString(Agent, &Env->Vars, query_string);
Agent->Flags = Env->Flags;
Agent->flags |= DPS_FLAG_UNOCON;
Env->flags |= DPS_FLAG_UNOCON;
DpsSetLogLevel(NULL, DpsVarListFindInt(&Env->Vars, "LogLevel", 0));
DpsOpenLog("filler.cgi", Env, !strcasecmp(DpsVarListFindStr(&Env->Vars, "Log2stderr", (!httpd) ? "yes" : "no"), "yes"));
DpsLog(Agent,DPS_LOG_ERROR,"filler.cgi started with '%s'",template_name);
DpsLog(Agent, DPS_LOG_DEBUG, "VarDir: '%s'", DpsVarListFindStr(&Agent->Conf->Vars, "VarDir", DPS_VAR_DIR));
DpsLog(Agent, DPS_LOG_DEBUG, "Affixes: %d, Spells: %d, Synonyms: %d, Acronyms: %d, Stopwords: %d",
Env->Affixes.naffixes,Env->Spells.nspell,
Env->Synonyms.nsynonyms,
Env->Acronyms.nacronyms,
Env->StopWords.nstopwords);
DpsLog(Agent, DPS_LOG_DEBUG, "Chinese dictionary with %d entries", Env->Chi.nwords);
DpsLog(Agent, DPS_LOG_DEBUG, "Korean dictionary with %d entries", Env->Korean.nwords);
DpsLog(Agent, DPS_LOG_DEBUG, "Thai dictionary with %d entries", Env->Thai.nwords);
DpsVarListAddLst(&Agent->Vars, &Env->Vars, NULL, "*");
Agent->tmpl.Env_Vars = &Agent->Vars;
/* DpsVarListAddEnviron(&Agent->Vars, "ENV");*/
/****************************************************************************************************************************************/
/* This is for query tracking */
DpsVarListAddStr(&Agent->Vars, "QUERY_STRING", query_string);
DpsVarListAddStr(&Agent->Vars, "self", self);
env = getenv("HTTP_X_FORWARDER_FOR");
if (env) {
DpsVarListAddStr(&Agent->Vars, "IP", env);
} else {
env = getenv("REMOTE_ADDR");
DpsVarListAddStr(&Agent->Vars, "IP", env ? env : "localhost");
}
bcharset = DpsVarListFindStr(&Agent->Vars, "BrowserCharset", "iso-8859-1");
Env->bcs=DpsGetCharSet(bcharset);
lcharset = DpsVarListFindStr(&Agent->Vars, "LocalCharset", "iso-8859-1");
Env->lcs=DpsGetCharSet(lcharset);
ResultContentType = DpsVarListFindStr(&Agent->Vars, "ResultContentType", "text/html");
if(httpd){
if(!Env->bcs){
printf("Content-Type: text/plain\r\n\r\n");
printf("Unknown BrowserCharset '%s' in template '%s'\n",bcharset,template_name);
exit(0);
}else if(!Env->lcs){
printf("Content-Type: text/plain\r\n\r\n");
printf("Unknown LocalCharset '%s' in template '%s'\n",lcharset,template_name);
exit(0);
}else{
printf("Content-type: %s; charset=%s\r\n\r\n", ResultContentType, bcharset);
}
}else{
if(!Env->bcs){
printf("Unknown BrowserCharset '%s' in template '%s'\n",bcharset,template_name);
exit(0);
}
if(!Env->lcs){
printf("Unknown LocalCharset '%s' in template '%s'\n",lcharset,template_name);
exit(0);
}
}
/* These parameters taken from "variable section of template"*/
res = DpsVarListFindInt(&Agent->Vars, "ps", DPS_DEFAULT_PS);
page_size = dps_min(res, MAX_PS);
page_number = DpsVarListFindInt(&Agent->Vars, "p", 0);
if (page_number == 0) {
page_number = DpsVarListFindInt(&Agent->Vars, "np", 0);
DpsVarListReplaceInt(&Agent->Vars, "p", page_number + 1);
} else page_number--;
res = DpsVarListFindInt(&Agent->Vars, "np", 0) * page_size;
DpsVarListAddInt(&Agent->Vars, "pn", res);
catcolumns = (size_t)atoi(DpsVarListFindStr(&Agent->Vars, "CatColumns", ""));
DpsTemplatePrint(Agent, (DPS_OUTPUTFUNCTION)&fprintf, stdout, NULL, 0, &Agent->tmpl, "top");
DpsTemplatePrint(Agent, (DPS_OUTPUTFUNCTION)&fprintf, stdout, NULL, 0, &Agent->tmpl, "restop");
DpsTemplatePrint(Agent, (DPS_OUTPUTFUNCTION)&fprintf, stdout, NULL, 0, &Agent->tmpl, "res");
DpsTemplatePrint(Agent, (DPS_OUTPUTFUNCTION)&fprintf, stdout, NULL, 0, &Agent->tmpl, "resbot");
DpsTemplatePrint(Agent, (DPS_OUTPUTFUNCTION)&fprintf, stdout, NULL, 0, &Agent->tmpl, "bottom");
DpsVarListFree(&query_vars);
DpsAgentFree(Agent);
DpsEnvFree(Env);
DPS_FREE(query_string);
DPS_FREE(url);
if (httpd) fflush(NULL); else fclose(stdout);
#ifdef EFENCE
fprintf(stderr, "Memory leaks checking\n");
DpsEfenceCheckLeaks();
#endif
#ifdef FILENCE
fprintf(stderr, "FD leaks checking\n");
DpsFilenceCheckLeaks(NULL);
#endif
return DPS_OK;
}
