void OAuthParseJSON(char *JSON, ListNode *Vars)
{
char *ptr, *ptr2, *Token=NULL, *Name=NULL, *Value=NULL;
StripLeadingWhitespace(JSON);
StripTrailingWhitespace(JSON);
ptr=JSON+StrLen(JSON)-1;
if (*ptr=='}') *ptr='\0';
ptr=JSON;
if (*ptr=='{') ptr++;
ptr=GetToken(ptr,",",&Token,0);
while (ptr)
{
printf("TOK: %s\n",Token);
ptr2=GetToken(Token,":",&Name,0);
StripTrailingWhitespace(Name);
StripQuotes(Name);
ptr2=GetToken(ptr2,":",&Value,GETTOKEN_QUOTES);
StripLeadingWhitespace(Value);
StripTrailingWhitespace(Value);
StripQuotes(Value);
printf("JSON: %s=%s\n",Name,Value);
SetVar(Vars,Name,Value);
ptr=GetToken(ptr,",",&Token,0);
}
DestroyString(Name);
DestroyString(Value);
DestroyString(Token);
}
void HTTPServerHandleAuthHeader(HTTPSession *Heads,int HeaderType, char *Type, char *Data)
{
char *Tempstr=NULL, *Name=NULL, *Value=NULL, *ptr;
char *nonce=NULL, *cnonce=NULL, *request_count=NULL, *qop=NULL, *algo=NULL, *uri=NULL;
int len;
if (strcmp(Type,"Basic")==0)
{
Tempstr=DecodeBase64(Tempstr, &len, Data);
ptr=GetToken(Tempstr,":",&Heads->UserName,0);
Heads->Password=CopyStr(Heads->Password,ptr);
}
else if (strcmp(Type,"Digest")==0)
{
uri=CopyStr(uri,"");
algo=CopyStr(algo,"");
ptr=GetNameValuePair(Data,",","=",&Name,&Value);
while (ptr)
{
if (StrLen(Name) && StrLen(Value))
{
StripLeadingWhitespace(Name);
StripLeadingWhitespace(Value);
if (strcmp(Name,"username")==0) Heads->UserName=CopyStr(Heads->UserName,Value);
if (strcmp(Name,"response")==0) Heads->Password=CopyStr(Heads->Password,Value);
if (strcmp(Name,"nonce")==0) nonce=CopyStr(nonce,Value);
if (strcmp(Name,"cnonce")==0) cnonce=CopyStr(cnonce,Value);
if (strcmp(Name,"nc")==0) request_count=CopyStr(request_count,Value);
if (strcmp(Name,"qop")==0) qop=CopyStr(qop,Value);
if (strcmp(Name,"uri")==0) uri=CopyStr(uri,Value);
if (strcmp(Name,"algorithm")==0) algo=CopyStr(algo,Value);
}
ptr=GetNameValuePair(ptr,",","=",&Name,&Value);
}
// server nonce (nonce), request counter (nc), client nonce (cnonce), quality of protection code (qop) and HA2 result is calculated. The result is the "response" value provided by the client.
if (StrLen(qop)) Heads->AuthDetails=MCopyStr(Heads->AuthDetails,uri,":",algo,":",nonce,":",request_count,":",cnonce,":",qop, NULL);
else Heads->AuthDetails=CopyStr(Heads->AuthDetails,nonce);
}
DestroyString(qop);
DestroyString(uri);
DestroyString(algo);
DestroyString(Name);
DestroyString(Value);
DestroyString(nonce);
DestroyString(cnonce);
DestroyString(Tempstr);
DestroyString(request_count);
}
static void ParseCrayonList(STREAM *S, TCrayon *Crayon)
{
char *Tempstr=NULL, *Token=NULL;
const char *ptr;
ListNode *Curr;
TCrayon *SubItem;
if (! Crayon) return;
Tempstr=STREAMReadLine(Tempstr,S);
while (Tempstr)
{
StripTrailingWhitespace(Tempstr);
StripLeadingWhitespace(Tempstr);
ptr=GetToken(Tempstr,"\\S",&Token,0);
if (StrLen(Token) && (*Token != '#'))
{
if (strcmp(Token,"}")==0) break;
if (strcmp(Token,"{")==0) ParseCrayonList(S, SubItem);
else if (CrayonType(Token) == CRAYON_ACTION) ParseCrayonAction(Crayon, Tempstr);
else
{
SubItem=NewCrayonAction(Crayon, 0);
ParseCrayonEntry(SubItem, Token,ptr);
}
}
Tempstr=STREAMReadLine(Tempstr,S);
}
Destroy(Tempstr);
Destroy(Token);
}
ListNode *ParserParseDocument(const char *TypeStr, const char *Doc)
{
ListNode *Node, *Items;
const char *Types[]= {"json","rss","yaml","config","ini","url",NULL};
const char *ptr;
char *Token=NULL;
int Type;
if (! StrValid(TypeStr)) return(NULL);
if (! StrValid(Doc)) return(NULL);
GetToken(TypeStr,";",&Token,0);
StripTrailingWhitespace(Token);
StripLeadingWhitespace(Token);
ptr=Token;
if (strncmp(ptr,"application/",12)==0) ptr+=12;
if (strncmp(ptr,"x-www-form-urlencoded",21)==0) ptr="url";
Type=MatchTokenFromList(ptr,Types,0);
Items=ListCreate();
ptr=Doc;
while (isspace(*ptr)) ptr++;
if (*ptr=='{') ptr++;
if (*ptr=='[') ptr++;
ParserParseItems(Type, ptr, Items, 0);
fflush(NULL);
return(ParserOpenItem(Items,"/"));
}
void HTTPHandleWWWAuthenticate(HTTPInfoStruct *Info, char *Line)
{
char *ptr, *ptr2, *Token=NULL, *Name=NULL, *Value=NULL;
char *AuthTypeStrings[]={"Basic","Digest",NULL};
typedef enum {AUTH_BASIC, AUTH_DIGEST} TAuthTypes;
int result;
if (! Info->Authorization) Info->Authorization=(HTTPAuthStruct *) calloc(1,sizeof(HTTPAuthStruct));
ptr=Line;
while (isspace(*ptr)) ptr++;
ptr=GetToken(ptr," ",&Token,0);
result=MatchTokenFromList(Token,AuthTypeStrings,0);
if (result==AUTH_BASIC) Info->Authorization->Flags |=HTTP_AUTH_BASIC;
if (result==AUTH_DIGEST) Info->Authorization->Flags |=HTTP_AUTH_DIGEST;
while (ptr)
{
ptr=GetToken(ptr,",",&Token,GETTOKEN_QUOTES);
StripLeadingWhitespace(Token);
StripTrailingWhitespace(Token);
ptr2=GetToken(Token,"=",&Name,GETTOKEN_QUOTES);
ptr2=GetToken(ptr2,"=",&Value,GETTOKEN_QUOTES);
if (strcasecmp(Name,"realm")==0) Info->Authorization->AuthRealm=CopyStr(Info->Authorization->AuthRealm,Value);
if (strcasecmp(Name,"qop")==0) Info->Authorization->AuthQOP=CopyStr(Info->Authorization->AuthQOP,Value);
if (strcasecmp(Name,"nonce")==0) Info->Authorization->AuthNonce=CopyStr(Info->Authorization->AuthNonce,Value);
if (strcasecmp(Name,"opaque")==0) Info->Authorization->AuthOpaque=CopyStr(Info->Authorization->AuthOpaque,Value);
}
DestroyString(Token);
DestroyString(Name);
DestroyString(Value);
}
void ParseFunction(STREAM *S, const char *Config)
{
char *Token=NULL, *Tempstr=NULL;
const char *ptr;
ListNode *Select;
TCrayon *Crayon;
if (! Functions) Functions=ListCreate();
ptr=GetToken(Config, "\\S", &Token, GETTOKEN_QUOTES);
Select=ListCreate();
ListAddNamedItem(Functions, Token, Select);
Tempstr=STREAMReadLine(Tempstr, S);
while (Tempstr)
{
StripTrailingWhitespace(Tempstr);
StripLeadingWhitespace(Tempstr);
ptr=GetToken(Tempstr, "\\S", &Token, GETTOKEN_QUOTES);
if (strcmp(Token,"}")==0) break;
if (MatchActionType(Token) > -1)
{
ParseCrayonization("action", Tempstr, Select);
}
else ParseCrayonization(Token, ptr, Select);
Tempstr=STREAMReadLine(Tempstr, S);
}
Destroy(Tempstr);
Destroy(Token);
}
void ParseDirListType(char *Data)
{
char *Token=NULL, *ptr;
Settings.DirListFlags=DIR_REJECT;
ptr=GetToken(Data,",",&Token,0);
while (ptr)
{
StripLeadingWhitespace(Token);
StripTrailingWhitespace(Token);
if (strcasecmp(Token,"None")==0) Settings.DirListFlags=DIR_REJECT;
if (strcasecmp(Token,"Basic")==0) Settings.DirListFlags=DIR_SHOWFILES;
if (strcasecmp(Token,"Fancy")==0) Settings.DirListFlags=DIR_SHOWFILES | DIR_FANCY;
if (strcasecmp(Token,"Interactive")==0) Settings.DirListFlags=DIR_SHOWFILES | DIR_FANCY | DIR_INTERACTIVE;
if (strcasecmp(Token,"Full")==0) Settings.DirListFlags=DIR_SHOWFILES | DIR_FANCY | DIR_INTERACTIVE | DIR_MEDIA_EXT | DIR_SHOW_VPATHS | DIR_TARBALLS;
if (strcasecmp(Token,"Media")==0) Settings.DirListFlags |= DIR_MEDIA_EXT;
if (strcasecmp(Token,"IndexPages")==0) Settings.DirListFlags |= DIR_INDEX_FILES;
if (strcasecmp(Token,"ShowVPaths")==0) Settings.DirListFlags |= DIR_SHOW_VPATHS;
if (strcasecmp(Token,"TarDownloads")==0) Settings.DirListFlags |= DIR_TARBALLS;
if (strcasecmp(Token,"MimeIcons")==0) Settings.DirListFlags |= DIR_MIMEICONS;
ptr=GetToken(ptr,",",&Token,0);
}
DestroyString(Token);
}
int DownloadM3U(char *URL, char *Title, int Flags)
{
char *Tempstr=NULL, *ID=NULL, *Doc=NULL, *ptr;
int Port=0, BytesRead=0, len=0, count=0;
int RetVal=FALSE;
ListNode *Items, *Curr;
int M3UType=M3U_PLAYLIST;
STREAM *Con;
if (Flags & FLAG_DEBUG) fprintf(stderr,"M3U STREAM: %s\n",URL);
Items=ListCreate();
Con=ConnectAndRetryUntilDownload(URL, 0, 0);
if (Con)
{
Tempstr=STREAMReadLine(Tempstr,Con);
while (Tempstr)
{
StripTrailingWhitespace(Tempstr);
StripLeadingWhitespace(Tempstr);
if (Flags & (FLAG_DEBUG2 | FLAG_DEBUG3)) fprintf(stderr,"%s\n",Tempstr);
if (StrLen(Tempstr))
{
if (strncmp("#EXT-X-STREAM-INF",Tempstr,StrLen("#EXT-X-STREAM-INF"))==0)
{
RetVal=M3UStreamInfo(Con,Title,URL,Tempstr,Flags);
M3UType=M3U_STREAMINFO;
}
else if (strncmp("#EXT-X-MEDIA-SEQUENCE",Tempstr,StrLen("#EXT-X-MEDIA-SEQUENCE"))==0) M3UType=M3U_PLAYLIST;
else if (*Tempstr != '#')
{
if (strncasecmp(Tempstr,"http",4) !=0)
{
Doc=CopyStr(Doc,URL);
ptr=strrchr(Doc,'/');
if (ptr) *ptr='\0';
Doc=MCatStr(Doc,"/",Tempstr,NULL);
}
else Doc=CopyStr(Doc,Tempstr);
ListAddItem(Items,CopyStr(NULL,Doc));
}
}
Tempstr=STREAMReadLine(Tempstr,Con);
}
STREAMClose(Con);
if (M3UType == M3U_PLAYLIST) RetVal=DownloadStream(URL, Title, Items, Flags);
}
ListDestroy(Items,DestroyString);
DestroyString(Tempstr);
DestroyString(Doc);
DestroyString(ID);
return(RetVal);
}
int UploadReadMultipartHeaders(STREAM *S, char **Field, char **FileName)
{
char *Tempstr=NULL, *Name=NULL, *Value=NULL, *ptr;
int result=FALSE;
Tempstr=STREAMReadLine(Tempstr,S);
while (StrLen(Tempstr))
{
StripTrailingWhitespace(Tempstr);
ptr=GetToken(Tempstr,":",&Name,0);
if (strcasecmp(Name,"Content-Disposition")==0)
{
ptr=GetNameValuePair(ptr,";","=",&Name,&Value);
while (ptr)
{
StripLeadingWhitespace(Name);
StripTrailingWhitespace(Name);
StripLeadingWhitespace(Value);
StripTrailingWhitespace(Value);
if (strcasecmp(Name,"name")==0)
{
*Field=CopyStr(*Field,Value);
result=TRUE;
}
if (strcasecmp(Name,"filename")==0)
{
*FileName=CopyStr(*FileName,Value);
result=TRUE;
}
ptr=GetNameValuePair(ptr,";","=",&Name,&Value);
}
}
Tempstr=STREAMReadLine(Tempstr,S);
StripTrailingWhitespace(Tempstr);
}
DestroyString(Tempstr);
DestroyString(Name);
DestroyString(Value);
return(result);
}
static const char *ParserYAMLItems(int ParserType, const char *Doc, ListNode *Parent, int IndentLevel)
{
const char *ptr, *tptr;
char *Token=NULL, *PrevToken=NULL, *Name=NULL;
int count=0, BreakOut=FALSE;
ListNode *Node;
ptr=GetToken(Doc, "\n|#|[|]|{|}|:",&Token,GETTOKEN_MULTI_SEP|GETTOKEN_INCLUDE_SEP|GETTOKEN_HONOR_QUOTES);
while (ptr)
{
switch(*Token)
{
case ':':
Name=CopyStr(Name, PrevToken);
PrevToken=CopyStr(PrevToken,"");
break;
case '#':
while ((*ptr != '\0') && (*ptr != '\n')) ptr++;
break;
case '\n':
if (StrValid(PrevToken))
{
StripTrailingWhitespace(PrevToken);
StripLeadingWhitespace(PrevToken);
Node=ListAddNamedItem(Parent, Name, CopyStr(NULL, PrevToken));
Node->ItemType=ITEM_VALUE;
}
count=0;
for (tptr=ptr; *tptr==' '; tptr++) count++;
if (count > IndentLevel) ptr=ParserAddNewStructure(ParserType, tptr, Parent, ITEM_ENTITY, Name, count);
else if (count < IndentLevel) BreakOut=TRUE;
PrevToken=CopyStr(PrevToken,"");
break;
default:
PrevToken=CopyStr(PrevToken, Token);
break;
}
if (BreakOut)
{
break;
}
ptr=GetToken(ptr, "\n|#[|]|{|}|:",&Token,GETTOKEN_MULTI_SEP|GETTOKEN_INCLUDE_SEP|GETTOKEN_HONOR_QUOTES);
}
DestroyString(PrevToken);
DestroyString(Token);
DestroyString(Name);
return(ptr);
}
void M3UParseStreamInfo(char *Line, char **Resolution, char **Bandwidth)
{
char *Name=NULL, *Value=NULL, *ptr;
ptr=GetToken(Line,":",&Name,0);
ptr=GetNameValuePair(ptr,",","=",&Name,&Value);
while (ptr)
{
StripLeadingWhitespace(Name);
StripTrailingWhitespace(Name);
StripLeadingWhitespace(Value);
StripTrailingWhitespace(Value);
if (strcasecmp(Name,"RESOLUTION")==0) *Resolution=CopyStr(*Resolution,Value);
if (strcasecmp(Name,"BANDWIDTH")==0) *Bandwidth=CopyStr(*Bandwidth,Value);
ptr=GetNameValuePair(ptr,",","=",&Name,&Value);
}
DestroyString(Name);
DestroyString(Value);
}
int STREAMAddConnectionHop(STREAM *S, char *Value)
{
char *Tempstr=NULL;
StripTrailingWhitespace(Value);
StripLeadingWhitespace(Value);
if (! S->Values) S->Values=ListCreate();
Tempstr=FormatStr(Tempstr,"ConnectHop:%d",ListSize(S->Values));
STREAMSetValue(S,Tempstr,Value);
DestroyString(Tempstr);
return(TRUE);
}
int M3UStreamDownload(STREAM *ManifestCon, const char *URL, const char *Title)
{
STREAM *Con=NULL;
char *Tempstr=NULL, *BasePath=NULL, *Line=NULL;
const char *ptr;
ListNode *Segments, *Curr;
int result;
double BytesRead=0;
Segments=ListCreate();
ptr=strrchr(URL, '/');
if (ptr)
{
BasePath=CopyStrLen(BasePath, URL, ptr - URL);
Line=STREAMReadLine(Line,ManifestCon);
while (Line)
{
StripLeadingWhitespace(Line);
StripTrailingWhitespace(Line);
if (*Line != '#')
{
Tempstr=MCopyStr(Tempstr, BasePath, "/", Line, NULL);
ListAddItem(Segments, CopyStr(NULL, Tempstr));
}
Line=STREAMReadLine(Line,ManifestCon);
}
OpenOutputFiles(Title, URL, &BytesRead);
Tempstr=SetStrLen(Tempstr,BUFSIZ);
Curr=ListGetNext(Segments);
while (Curr)
{
Con=ConnectAndRetryUntilDownload(Curr->Item, 0, 0);
if (Con)
{
TransferItem(Con, Title, URL, "m3u8-stream", 0, 0, &BytesRead, FALSE);
STREAMClose(Con);
}
Curr=ListGetNext(Curr);
}
CloseOutputFiles();
}
ListDestroy(Segments, DestroyString);
DestroyString(Tempstr);
DestroyString(BasePath);
DestroyString(Line);
}
char *ParseVar(char *Buff, const char **Line, ListNode *LocalVars, int Flags)
{
char *VarName=NULL, *OutStr=NULL, *Tempstr=NULL;
const char *ptr, *vptr;
OutStr=Buff;
ptr=*Line;
if (*ptr=='(') ptr++;
while ((*ptr !=')') && (*ptr !='\0'))
{
if (*ptr=='$')
{
ptr++;
Tempstr=ParseVar(Tempstr,&ptr,LocalVars,Flags);
VarName=CatStr(VarName,Tempstr);
}
else VarName=AddCharToStr(VarName,*ptr);
ptr++;
}
*Line=ptr; //very important! Otherwise the calling process will not
//know we have consumed some of the text!
//Now lookup var/format/append to output
if (! (Flags & SUBS_CASE_VARNAMES)) strlwr(VarName);
vptr=GetVar(LocalVars,VarName);
if (Flags & SUBS_QUOTE_VARS) OutStr=CatStr(OutStr,"'");
if (Flags & SUBS_STRIP_VARS_WHITESPACE)
{
Tempstr=CopyStr(Tempstr,vptr);
StripTrailingWhitespace(Tempstr);
StripLeadingWhitespace(Tempstr);
OutStr=CatStr(OutStr,Tempstr);
}
else OutStr=CatStr(OutStr, vptr);
if (Flags & SUBS_QUOTE_VARS) OutStr=CatStr(OutStr,"'");
DestroyString(VarName);
DestroyString(Tempstr);
return(OutStr);
}
int DownloadASX(char *URL, char *Title, int Flags)
{
char *Tempstr=NULL, *Token=NULL, *ptr;
int Port=0, len=0;
int RetVal=FALSE;
STREAM *Con=NULL;
ListNode *Items;
if (Flags & FLAG_DEBUG) fprintf(stderr,"ASX STREAM: %s\n",URL);
Items=ListCreate();
Con=ConnectAndRetryUntilDownload(URL, 0, 0);
if (Con)
{
Tempstr=STREAMReadLine(Tempstr,Con);
while (Tempstr)
{
StripTrailingWhitespace(Tempstr);
StripLeadingWhitespace(Tempstr);
if (Flags & (FLAG_DEBUG2 | FLAG_DEBUG3)) fprintf(stderr,"%s\n",Tempstr);
if (StrLen(Tempstr) && (strncasecmp(Tempstr,"<Ref href",9)==0))
{
ptr=GetToken(Tempstr,"=",&Token,0);
while (isspace(*ptr)) ptr++;
if (*ptr=='"') ptr++;
ptr=GetToken(ptr,"\"",&Token,0);
ListAddItem(Items,CopyStr(NULL,Token));
}
Tempstr=STREAMReadLine(Tempstr,Con);
}
STREAMClose(Con);
RetVal=DownloadStream(URL, Title, Items, Flags);
}
ListDestroy(Items,DestroyString);
DestroyString(Tempstr);
return(RetVal);
}
int CheckAuth(const char *KeyList, const char *ActiveUSBKeys, const char *User, const char *TTY, const char *RHost)
{
char *KeyInfo=NULL;
const char *ptr;
int result=PAM_IGNORE;
ptr=GetTok(KeyList, '|', &KeyInfo);
while (ptr)
{
StripTrailingWhitespace(KeyInfo);
StripLeadingWhitespace(KeyInfo);
result=CheckAuthItem(KeyInfo, ActiveUSBKeys, User, TTY, RHost);
ptr=GetTok(ptr, '|', &KeyInfo);
}
Destroy(KeyInfo);
return(result);
}
int DownloadPLS(char *URL, char *Title, int Flags)
{
char *Tempstr=NULL, *Token=NULL, *ptr;
int Port=0, len=0;
STREAM *Con=NULL;
int RetVal=FALSE;
ListNode *Items;
if (Flags & FLAG_DEBUG) fprintf(stderr,"PLS STREAM: %s\n",URL);
Items=ListCreate();
Con=ConnectAndRetryUntilDownload(URL, 0, 0);
if (Con)
{
Tempstr=STREAMReadLine(Tempstr,Con);
while (Tempstr)
{
StripTrailingWhitespace(Tempstr);
StripLeadingWhitespace(Tempstr);
if (Flags & (FLAG_DEBUG2 | FLAG_DEBUG3)) fprintf(stderr,"%s\n",Tempstr);
if (StrLen(Tempstr))
{
ptr=GetToken(Tempstr,"=",&Token,0);
if (strncmp(Token,"File",4)==0) ListAddItem(Items,CopyStr(NULL,ptr));
}
Tempstr=STREAMReadLine(Tempstr,Con);
}
//Close the Connection and Download the next stage
STREAMClose(Con);
RetVal=DownloadStream(URL, Title, Items, Flags);
}
ListDestroy(Items,DestroyString);
DestroyString(Tempstr);
return(RetVal);
}
int ConfigReadFile(const char *Path, const char *CommandLine, char **CrayonizerDir, ListNode *CrayonList)
{
STREAM *S;
char *Tempstr=NULL, *Token=NULL;
char *ProgName=NULL;
const char *ptr, *Args;
S=STREAMOpen(Path, "r");
if (! S) return(FALSE);
Args=GetToken(CommandLine," ",&ProgName,GETTOKEN_QUOTES);
Tempstr=STREAMReadLine(Tempstr,S);
while (Tempstr)
{
StripTrailingWhitespace(Tempstr);
StripLeadingWhitespace(Tempstr);
ptr=GetToken(Tempstr,"\\S",&Token,0);
if (strcasecmp(Token,"CrayonizerDir")==0) *CrayonizerDir=CopyStr(*CrayonizerDir,ptr);
else if (strcasecmp(Token,"allowchildcrayon")==0) GlobalFlags |= FLAG_CHILDCRAYON;
else if (strcasecmp(Token,"entry")==0)
{
ptr=GetToken(ptr,"\\S",&Token,0);
if (EntryMatchesCommand(Token, ptr, ProgName, Args))
{
ConfigReadEntry(S, CrayonList);
}
else ConfigReadEntry(S, NULL);
}
else if (strcasecmp(Token,"function")==0) ParseFunction(S, ptr);
else if (strcasecmp(Token,"include")==0) ConfigReadFile(ptr, CommandLine, CrayonizerDir, CrayonList);
else if (strcasecmp(Token,"selection")==0) StatusBarParseSelection(S, ptr);
Tempstr=STREAMReadLine(Tempstr,S);
}
Destroy(ProgName);
Destroy(Tempstr);
Destroy(Token);
return(TRUE);
}
void ReadConfigFile(TSettings *Settings)
{
STREAM *S;
char *Tempstr=NULL;
S=STREAMOpenFile(Settings->ConfigPath,SF_RDONLY);
if (S)
{
Tempstr=STREAMReadLine(Tempstr,S);
while (Tempstr)
{
StripLeadingWhitespace(Tempstr);
StripTrailingWhitespace(Tempstr);
if (StrLen(Tempstr)) ParseConfigItem(Tempstr);
Tempstr=STREAMReadLine(Tempstr,S);
}
STREAMClose(S);
}
DestroyString(Tempstr);
}
static void ConfigReadEntry(STREAM *S, ListNode *CrayonList)
{
char *Tempstr=NULL, *Token=NULL, *Token2=NULL;
const char *ptr;
TCrayon *Crayon=NULL;
Tempstr=STREAMReadLine(Tempstr,S);
while (Tempstr)
{
StripTrailingWhitespace(Tempstr);
StripLeadingWhitespace(Tempstr);
ptr=GetToken(Tempstr,"\\S",&Token,0);
if (*Token=='#') /*do nothing*/;
else if (strcmp(Token,"}")==0) break;
else if (CrayonList)
{
if (strcasecmp(Token,"passinput")==0) KeypressFlags |= KEYPRESS_PASSINPUT;
else if (strcasecmp(Token,"lineedit")==0) KeypressFlags |= KEYPRESS_LINEDIT;
else if (strcasecmp(Token,"expectlines")==0) GlobalFlags |= FLAG_EXPECT_LINES;
else if (strcasecmp(Token,"allowchildcrayon")==0) GlobalFlags |= FLAG_CHILDCRAYON;
else if (strcasecmp(Token,"keypress")==0) Crayon=KeypressParse(ptr);
else if (strcasecmp(Token,"selection")==0) StatusBarParseSelection(S, ptr);
//these commands are effectively keypress without 'keypress' so pass
//all of Tempstr
else if (strcasecmp(Token,"focus")==0)
{
GlobalFlags |= HAS_FOCUS;
Crayon=KeypressParse(Tempstr);
}
else if (strcasecmp(Token,"unfocus")==0)
{
GlobalFlags |= HAS_FOCUS;
Crayon=KeypressParse(Tempstr);
}
else if (strcasecmp(Token,"timer")==0) ParseTimer(ptr);
else if (strcasecmp(Token,"pty")==0) GlobalFlags |= FLAG_USE_PTY;
else if (strcasecmp(Token,"stripansi")==0) GlobalFlags |= FLAG_STRIP_ANSI;
else if (strcasecmp(Token,"stripxtitle")==0) GlobalFlags |= FLAG_STRIP_XTITLE;
else if (strcasecmp(Token,"command")==0) SetVar(Vars,"ReplaceCommand",ptr);
else if (strcasecmp(Token,"cmdline-sub")==0)
{
ptr=GetToken(ptr, "\\S", &Token, GETTOKEN_QUOTES);
ptr=GetToken(ptr, "\\S", &Token2, GETTOKEN_QUOTES);
CommandLineAddSubstitution(CMDLINE_SUB, Token, Token2);
}
else if (strcasecmp(Token,"cmdline-insert")==0)
{
ptr=GetToken(ptr, "\\S", &Token, GETTOKEN_QUOTES);
ptr=GetToken(ptr, "\\S", &Token2, GETTOKEN_QUOTES);
CommandLineAddSubstitution(CMDLINE_INSERT, Token, Token2);
}
else if (strcasecmp(Token,"cmdline-append")==0)
{
ptr=GetToken(ptr, "\\S", &Token, GETTOKEN_QUOTES);
ptr=GetToken(ptr, "\\S", &Token2, GETTOKEN_QUOTES);
CommandLineAddSubstitution(CMDLINE_APPEND, Token, Token2);
}
else if(strcmp(Token,"{")==0)
{
if (Crayon) ParseCrayonList(S,Crayon);
}
//Otherwise it's a 'standard' crayonization that can occur
//in sublists/functions etc
else Crayon=ParseCrayonization(Token, ptr, CrayonList);
}
Tempstr=STREAMReadLine(Tempstr,S);
}
Destroy(Tempstr);
Destroy(Token2);
Destroy(Token);
}
static const char *ParserConfigItems(int ParserType, const char *Doc, ListNode *Parent, int IndentLevel)
{
const char *ptr;
char *Token=NULL, *PrevToken=NULL, *Name=NULL;
ListNode *Node;
int BreakOut=FALSE;
ptr=Doc;
while (ptr && (! BreakOut))
{
//while (isspace(*ptr)) ptr++;
ptr=GetToken(ptr, CONFIG_FILE_TOKENS, &Token,GETTOKEN_MULTI_SEP|GETTOKEN_INCLUDE_SEP|GETTOKEN_HONOR_QUOTES);
switch (*Token)
{
case '#':
ptr=GetToken(ptr,"\n",&Token,0);
break;
case '{':
StripLeadingWhitespace(Name);
StripTrailingWhitespace(Name);
ptr=ParserAddNewStructure(ParserType, ptr, Parent, ITEM_ENTITY, Name, IndentLevel+1);
Name=CopyStr(Name,"");
Token=CopyStr(Token,"");
break;
case '}':
BreakOut=TRUE;
break;
case ' ':
case ' ':
case ':':
case '=':
Name=CopyStr(Name, PrevToken);
ptr=GetToken(ptr,"\n|;|}|{",&Token,GETTOKEN_MULTI_SEP | GETTOKEN_INCLUDE_SEP | GETTOKEN_HONOR_QUOTES);
break;
case '\r':
break;
case '\n':
if (ParserConfigCheckForBrace(&ptr))
{
Name=MCatStr(Name, " ", PrevToken, NULL);
break;
}
case ';':
if (StrValid(PrevToken))
{
StripLeadingWhitespace(PrevToken);
StripTrailingWhitespace(PrevToken);
if (StrValid(Name))
{
Node=ListAddNamedItem(Parent, Name, CopyStr(NULL, PrevToken));
Node->ItemType=ITEM_VALUE;
}
Name=CopyStr(Name,"");
//we don't want \r \n or ; tokens included in anything
Token=CopyStr(Token,"");
}
break;
default:
break;
}
PrevToken=CopyStr(PrevToken, Token);
}
DestroyString(PrevToken);
DestroyString(Token);
DestroyString(Name);
return(ptr);
}
void VPathParse(ListNode *List, const char *PathType, const char *Data)
{
const char *PathTypes[]={"Files","Cgi","Websocket","Stream","Logout","Proxy","MimeIcons","FileType",NULL};
char *URL=NULL, *Path=NULL, *Tempstr=NULL;
char *User=NULL, *Group=NULL, *Password=NULL;
const char *ptr;
TPathItem *PI=NULL;
int Type, Flags=0;
unsigned int CacheTime=0;
Type=MatchTokenFromList(PathType,PathTypes,0);
if (Type > -1)
{
ptr=GetToken(Data,",",&Tempstr,0);
StripLeadingWhitespace(Tempstr);
if (*Tempstr !='/') URL=MCopyStr(URL,"/",Tempstr,NULL);
else URL=CopyStr(URL,Tempstr);
ptr=GetToken(ptr,",",&Tempstr,0);
while (ptr)
{
StripLeadingWhitespace(Tempstr);
if (strncasecmp(Tempstr,"cache=",6)==0) CacheTime=atoi(Tempstr+6);
else if (strncasecmp(Tempstr,"user="******"pass="******"passwd=",7)==0) Password=CopyStr(Password, Tempstr+7);
else if (strncasecmp(Tempstr,"password="******"group=",6)==0) Group=CopyStr(Group, Tempstr+6);
else if ( (strncasecmp(Tempstr,"exec=",5)==0) && YesNoTrueFalse(Tempstr+5)) Flags |= PATHITEM_EXEC;
else if ( (strncasecmp(Tempstr,"upload=",7)==0) && YesNoTrueFalse(Tempstr+7)) Flags |= PATHITEM_UPLOAD;
else if ( (strncasecmp(Tempstr,"uploads=",8)==0) && YesNoTrueFalse(Tempstr+8)) Flags |= PATHITEM_UPLOAD;
else if (strncasecmp(Tempstr,"compress=",9)==0)
{
if (YesNoTrueFalse(Tempstr+9)) Flags |= PATHITEM_COMPRESS;
else Flags |= PATHITEM_NO_COMPRESS;
}
else
{
if (StrLen(Path)) Path=MCatStr(Path, ":", Tempstr,NULL);
else Path=CopyStr(Path, Tempstr);
}
ptr=GetToken(ptr,",",&Tempstr,0);
}
PI=PathItemCreate(Type, URL, Path);
PI->Flags=Flags;
PI->CacheTime=CacheTime;
PI->User=CopyStr(PI->User, User);
PI->Password=CopyStr(PI->Password, Password);
PI->Group=CopyStr(PI->Group, Group);
switch (PI->Type)
{
case PATHTYPE_LOGOUT: Settings.Flags |= FLAG_LOGOUT_AVAILABLE; break;
case PATHTYPE_FILETYPE:
ptr=PI->URL;
if (*ptr=='/') ptr++;
PI->Path=CopyStr(PI->Path, ptr);
break;
}
ListAddNamedItem(List,PI->URL,PI);
}
else LogToFile(Settings.LogPath,"ERROR: Unknown Path type '%s' in Config File",Tempstr);
DestroyString(Tempstr);
DestroyString(Password);
DestroyString(Group);
DestroyString(User);
DestroyString(Path);
DestroyString(URL);
}
//This function Extracts Text from a line that's found between two specified
//chunks of text 'ItemStart' and 'ItemEnd'
char *GenericExtractFromLine(char *Line, char *ItemName, char *ItemStart, char *ItemEnd, ListNode *Vars, int Flags)
{
char *ptr, *ptr2, *Token=NULL, *Item=NULL;
int GTF=0;
if (Flags & EXTRACT_WITHIN_QUOTES) GTF=GETTOKEN_QUOTES;
if (StrLen(ItemStart)) ptr=Gettoken(Line,ItemStart,&Token,0);
else ptr=Line;
ptr=Gettoken(ptr,ItemEnd,&Token,GTF);
//check if the start string occurs more than once in the Token that we've grabbed
if (StrLen(ItemStart)) ptr2=strstr(Token,ItemStart);
else ptr2=NULL;
while (ptr2)
{
ptr2+=StrLen(ItemStart);
memmove(Token,ptr2,Token+StrLen(Token)-ptr2+1);
//because of memmove we can strstr in Token again
ptr2=strstr(Token,ItemStart);
}
if (Flags & EXTRACT_INCLUDE_START)
{
Item=MCopyStr(Item,ItemStart,Token,NULL);
Token=CopyStr(Token,Item);
}
if (Flags & EXTRACT_DEQUOTE) Item=HTTPUnQuote(Item,Token);
else if (Flags & EXTRACT_DEHTMLQUOTE) Item=HtmlDeQuote(Item,Token);
else if (Flags & EXTRACT_DESLASHQUOTE) Item=DeQuoteStr(Item,Token);
else Item=CopyStr(Item,Token);
StripLeadingWhitespace(Item);
StripTrailingWhitespace(Item);
StripQuotes(Item);
if (Flags & EXTRACT_NOSPACES)
{
ptr2=strchr(Item,' ');
while (ptr2)
{
*ptr2='+';
ptr2=strchr(ptr2,' ');
}
}
//Do this without disturbing ptr, as we must return ptr
ptr2=ItemName;
if (Flags & EXTRACT_GUESSTYPE)
{
Token=ItemCodeFromFileExtension(Token, ItemName, Item);
}
SetVar(Vars,ptr2,Item);
DestroyString(Token);
DestroyString(Item);
return(ptr);
}
void ParseConfigItem(char *ConfigLine)
{
const char *ConfTokens[]={"Chroot","Chhome","AllowUsers","DenyUsers","Port","LogFile","AuthPath","BindAddress","LogPasswords","HttpMethods","AuthMethods","DefaultUser","DefaultGroup","Path","FileType","LogVerbose","AuthRealm","Compression","DirListType","DisplayNameLen","MaxLogSize","ScriptHandler","ScriptHashFile","WebsocketHandler","LookupClientName","SanitizeAllowTags","CustomHeader","UserAgentSettings",
"SSLKey","SSLCert","SSLCiphers","SSLDHParams","SSLClientCertificate","SSLVerifyPath", "SSLVersion",
"Event","FileCacheTime","HttpKeepAlive","AccessTokenKey","Timezone","MaxMemory","MaxStack","ActivityTimeout","PackFormats",NULL};
typedef enum {CT_CHROOT, CT_CHHOME, CT_ALLOWUSERS,CT_DENYUSERS,CT_PORT, CT_LOGFILE,CT_AUTHFILE,CT_BINDADDRESS,CT_LOGPASSWORDS,CT_HTTPMETHODS, CT_AUTHMETHODS,CT_DEFAULTUSER, CT_DEFAULTGROUP, CT_PATH, CT_FILETYPE, CT_LOG_VERBOSE, CT_AUTH_REALM, CT_COMPRESSION, CT_DIRTYPE, CT_DISPLAYNAMELEN, CT_MAXLOGSIZE, CT_SCRIPTHANDLER, CT_SCRIPTHASHFILE, CT_WEBSOCKETHANDLER, CT_LOOKUPCLIENT, CT_SANITIZEALLOW, CT_CUSTOMHEADER, CT_USERAGENTSETTINGS,
CT_SSLKEY, CT_SSLCERT, CT_SSLCIPHERS, CT_SSLDHPARAMS, CT_CLIENT_CERTIFICATION, CT_SSLVERIFY_PATH, CT_SSL_VERSION,
CT_EVENT, CT_FILE_CACHE_TIME, CT_SESSION_KEEPALIVE, CT_ACCESS_TOKEN_KEY, CT_TIMEZONE, CT_MAX_MEM, CT_MAX_STACK, CT_ACTIVITY_TIMEOUT, CT_ARCHIVE_FORMATS} TConfigTokens;
char *Token=NULL, *ptr;
struct group *grent;
struct stat Stat;
TConfigTokens TokType;
ptr=GetToken(ConfigLine,"=|:",&Token,GETTOKEN_MULTI_SEPARATORS);
StripLeadingWhitespace(Token);
StripTrailingWhitespace(Token);
TokType=MatchTokenFromList(Token,ConfTokens,0);
switch(TokType)
{
case CT_PORT:
Settings.Port=atoi(ptr);
break;
case CT_CHROOT:
Settings.Flags &= ~FLAG_CHHOME;
Settings.Flags |= FLAG_CHROOT;
Settings.DefaultDir=CopyStr(Settings.DefaultDir,ptr);
break;
case CT_CHHOME:
Settings.Flags &= ~FLAG_CHROOT;
Settings.Flags|=FLAG_CHHOME;
break;
case CT_ALLOWUSERS:
Settings.AllowUsers=CopyStr(Settings.AllowUsers,ptr);
break;
case CT_DENYUSERS:
Settings.DenyUsers=CopyStr(Settings.DenyUsers,ptr);
break;
case CT_AUTHFILE:
Settings.AuthPath=CopyStr(Settings.AuthPath,ptr);
break;
case CT_BINDADDRESS:
Settings.BindAddress=CopyStr(Settings.BindAddress,ptr);
break;
case CT_LOGPASSWORDS:
// Settings.Flags |= FLAG_LOGPASSWORDS;
break;
case CT_DISPLAYNAMELEN:
Settings.DisplayNameLen=atoi(ptr);
break;
case CT_AUTHMETHODS:
Settings.AuthMethods=CopyStr(Settings.AuthMethods,ptr);
break;
case CT_HTTPMETHODS:
Settings.HttpMethods=CopyStr(Settings.HttpMethods,ptr);
break;
case CT_DEFAULTUSER:
Settings.DefaultUser=CopyStr(Settings.DefaultUser,ptr);
break;
case CT_DEFAULTGROUP:
Settings.DefaultGroup=CopyStr(Settings.DefaultGroup,ptr);
grent=getgrnam(ptr);
if (grent) Settings.DefaultGroupID=grent->gr_gid;
break;
case CT_SSLKEY:
if (! Settings.SSLKeys) Settings.SSLKeys=ListCreate();
Token=FormatStr(Token,"SSL_KEY_FILE:%d",ListSize(Settings.SSLKeys));
ListAddNamedItem(Settings.SSLKeys,Token,CopyStr(NULL,ptr));
Settings.Flags |=FLAG_SSL;
break;
case CT_SSLCERT:
if (! Settings.SSLKeys) Settings.SSLKeys=ListCreate();
Token=FormatStr(Token,"SSL_CERT_FILE:%d",ListSize(Settings.SSLKeys));
ListAddNamedItem(Settings.SSLKeys,Token,CopyStr(NULL,ptr));
Settings.Flags |=FLAG_SSL;
break;
case CT_SSLCIPHERS:
LibUsefulSetValue("SSL-Permitted-Ciphers",ptr);
break;
case CT_SSLDHPARAMS:
LibUsefulSetValue("SSL-DHParams-File",ptr);
break;
case CT_SSL_VERSION:
LibUsefulSetValue("SSL-Level",ptr);
break;
case CT_AUTH_REALM:
Settings.AuthRealm=CopyStr(Settings.AuthRealm,ptr);
break;
case CT_COMPRESSION:
if (strcasecmp(ptr,"partial")==0)
{
Settings.Flags &= ~FLAG_COMPRESS;
Settings.Flags |= FLAG_PARTIAL_COMPRESS;
}
else if (! YesNoTrueFalse(ptr)) Settings.Flags &= ~(FLAG_COMPRESS | FLAG_PARTIAL_COMPRESS);
else
{
Settings.Flags &= ~FLAG_PARTIAL_COMPRESS;
Settings.Flags |= FLAG_COMPRESS;
}
break;
case CT_PATH:
ptr=GetToken(ptr,",",&Token,0);
VPathParse(Settings.VPaths, Token, ptr);
break;
case CT_FILETYPE:
VPathParse(Settings.VPaths, Token, ptr);
break;
case CT_DIRTYPE:
ParseDirListType(ptr);
break;
case CT_LOGFILE:
Settings.LogPath=CopyStr(Settings.LogPath,ptr);
break;
case CT_LOG_VERBOSE:
if (YesNoTrueFalse(ptr)) Settings.Flags |= FLAG_LOG_VERBOSE;
else Settings.Flags &= ~FLAG_LOG_VERBOSE;
break;
case CT_MAXLOGSIZE:
Settings.MaxLogSize = (int) ParseHumanReadableDataQty(ptr, 0);
break;
case CT_SCRIPTHANDLER:
ptr=GetToken(ptr,"=",&Token,0);
if (! Settings.ScriptHandlers) Settings.ScriptHandlers=ListCreate();
SetTypedVar(Settings.ScriptHandlers,Token,ptr,PATHTYPE_CGI);
break;
case CT_SCRIPTHASHFILE:
Settings.ScriptHashFile=CopyStr(Settings.ScriptHashFile,ptr);
Settings.Flags |= FLAG_CHECK_SCRIPTS;
break;
case CT_WEBSOCKETHANDLER:
if (! Settings.ScriptHandlers) Settings.ScriptHandlers=ListCreate();
ptr=GetToken(ptr,"=",&Token,0);
SetTypedVar(Settings.ScriptHandlers,Token,ptr,PATHTYPE_WEBSOCKET);
break;
case CT_SANITIZEALLOW:
if (! Settings.SanitizeArgumentsAllowedTags) Settings.SanitizeArgumentsAllowedTags=ListCreate();
ptr=GetToken(ptr,",",&Token,0);
while (ptr)
{
SetVar(Settings.SanitizeArgumentsAllowedTags,Token,"Y");
ptr=GetToken(ptr,",",&Token,0);
}
break;
case CT_CUSTOMHEADER:
if (! Settings.CustomHeaders) Settings.CustomHeaders=ListCreate();
ptr=GetToken(ptr,":",&Token,0);
ListAddNamedItem(Settings.CustomHeaders,Token,CopyStr(NULL,ptr));
break;
case CT_LOOKUPCLIENT:
if (YesNoTrueFalse(ptr)) Settings.Flags |= FLAG_LOOKUP_CLIENT;
else Settings.Flags &= ~FLAG_LOOKUP_CLIENT;
break;
case CT_USERAGENTSETTINGS:
if (! Settings.UserAgents) Settings.UserAgents=ListCreate();
ptr=GetToken(ptr,",",&Token,0);
ListAddNamedItem(Settings.UserAgents,Token,CopyStr(NULL,ptr));
break;
case CT_SSLVERIFY_PATH:
if (stat(ptr,&Stat)==0)
{
if (S_ISDIR(Stat.st_mode)) LibUsefulSetValue("SSL_VERIFY_CERTDIR",ptr);
else if (S_ISREG(Stat.st_mode)) LibUsefulSetValue("SSL_VERIFY_CERTFILE",ptr);
}
else HandleError(ERR_PRINT|ERR_LOG|ERR_EXIT, "ERROR: Can't access SSL certificate verify data at '%s'",ptr);
break;
case CT_CLIENT_CERTIFICATION:
if (strcasecmp(ptr,"ask")==0) Settings.AuthFlags |= FLAG_AUTH_CERT_ASK;
if (strcasecmp(ptr,"required")==0) Settings.AuthFlags |= FLAG_AUTH_CERT_REQUIRED;
if (strcasecmp(ptr,"sufficient")==0) Settings.AuthFlags |= FLAG_AUTH_CERT_SUFFICIENT;
if (strcasecmp(ptr,"optional")==0) Settings.AuthFlags |= FLAG_AUTH_CERT_SUFFICIENT;
if (strcasecmp(ptr,"required+sufficient")==0) Settings.AuthFlags |= FLAG_AUTH_CERT_REQUIRED | FLAG_AUTH_CERT_SUFFICIENT;
break;
case CT_EVENT:
ParseEventConfig(ptr);
break;
case CT_FILE_CACHE_TIME:
Settings.DocumentCacheTime=strtol(ptr,NULL,10);
break;
case CT_SESSION_KEEPALIVE:
if (YesNoTrueFalse(ptr)) Settings.Flags |= FLAG_KEEPALIVES;
else Settings.Flags &= ~FLAG_KEEPALIVES;
break;
case CT_ACCESS_TOKEN_KEY:
Settings.AccessTokenKey=CopyStr(Settings.AccessTokenKey,ptr);
break;
case CT_TIMEZONE:
Settings.Timezone=CopyStr(Settings.Timezone,ptr);
break;
case CT_MAX_MEM:
Settings.AddressSpace=CopyStr(Settings.AddressSpace,ptr);
break;
case CT_MAX_STACK:
Settings.StackSize=CopyStr(Settings.StackSize,ptr);
break;
case CT_ACTIVITY_TIMEOUT:
Settings.ActivityTimeout=atoi(ptr);
break;
case CT_ARCHIVE_FORMATS:
Settings.PackFormats=ParsePackFormats(Settings.PackFormats, ptr);
break;
}
DestroyString(Token);
}
int HTTPServerReadHeaders(HTTPSession *Session)
{
char *Tempstr=NULL, *Token=NULL, *ptr;
ListNode *Curr;
int val;
HTTPSessionClear(Session);
Tempstr=STREAMReadLine(Tempstr,Session->S);
if (! Tempstr) return(FALSE);
StripTrailingWhitespace(Tempstr);
//First line of the HTTP request is the 'Command' in the form "<method> <url>?<arguments> <HTTP version>"
HTTPServerParseCommand(Session, Session->S, Tempstr);
Tempstr=STREAMReadLine(Tempstr,Session->S);
if (Tempstr)
{
StripTrailingWhitespace(Tempstr);
StripLeadingWhitespace(Tempstr);
}
while (StrLen(Tempstr) )
{
if (Settings.Flags & FLAG_LOG_VERBOSE) LogToFile(Settings.LogPath,"<< %s",Tempstr);
ptr=GetToken(Tempstr,":",&Token,0);
while (isspace(*ptr)) ptr++;
val=MatchTokenFromList(Token,HeaderStrings,0);
ListAddNamedItem(Session->Headers,Token,CopyStr(NULL,ptr));
switch (val)
{
case HEAD_PROXYAUTH:
if (IsProxyMethod(Session->MethodID))
{
ptr=GetToken(ptr,"\\S",&Token,0);
HTTPServerHandleAuthHeader(Session,val,Token,ptr);
Session->AuthFlags |= FLAG_AUTH_PRESENT;
}
break;
case HEAD_AUTH:
if (IsProxyMethod(Session->MethodID))
{
Session->RemoteAuthenticate=CopyStr(Session->RemoteAuthenticate,ptr);
}
if (StrLen(Session->UserName)==0)
{
ptr=GetToken(ptr,"\\S",&Token,0);
HTTPServerHandleAuthHeader(Session,val,Token,ptr);
Session->AuthFlags |= FLAG_AUTH_PRESENT;
}
break;
case HEAD_HOST:
Session->Host=CopyStr(Session->Host,ptr);
ptr=strchr(Session->Host,':');
if (! ptr)
{
Token=FormatStr(Token,":%d",Settings.Port);
Session->Host=CatStr(Session->Host,Token);
}
break;
case HEAD_DEST:
Session->Destination=HTTPUnQuote(Session->Destination,ptr);
break;
case HEAD_CONTENT_TYPE:
HTTPServerParsePostContentType(Session, ptr);
break;
case HEAD_CONTENT_LENGTH:
Session->ContentSize=atoi(ptr);
break;
case HEAD_DEPTH:
if (strcasecmp(ptr,"infinity")==0) Session->Depth=INT_MAX;
else Session->Depth=atoi(ptr);
break;
case HEAD_OVERWRITE:
if (*ptr=='T') Session->Flags |= SESSION_OVERWRITE;
break;
case HEAD_CONNECTION:
if ((Settings.Flags & FLAG_KEEPALIVES) && (strcasecmp(ptr,"Keep-Alive")==0)) Session->Flags |= SESSION_KEEPALIVE;
break;
case HEAD_AGENT:
Session->UserAgent=CopyStr(Session->UserAgent,ptr);
Curr=ListGetNext(Settings.UserAgents);
while (Curr)
{
if (fnmatch(Curr->Tag,Session->UserAgent,0)==0)
{
if (Settings.Flags & FLAG_LOG_VERBOSE) LogToFile(Settings.LogPath,"Applying User Agent Settings: %s",Curr->Item);
ParseConfigItemList((char *) Curr->Item);
}
Curr=ListGetNext(Curr);
}
break;
case HEAD_COOKIE:
if (StrLen(Session->Cookies)) Session->Cookies=MCopyStr(Session->Cookies,"; ",ptr,NULL);
else Session->Cookies=CopyStr(Session->Cookies,ptr);
Session->AuthFlags |= FLAG_AUTH_PRESENT;
break;
case HEAD_REFERER:
Session->ClientReferrer=CopyStr(Session->ClientReferrer,ptr);
break;
case HEAD_ACCEPT_ENCODING:
ptr=GetToken(ptr,",",&Token,0);
while (ptr)
{
if (strcmp(Token,"gzip")==0) Session->Flags|=SESSION_ENCODE_GZIP;
if (strcmp(Token,"x-gzip")==0) Session->Flags|=SESSION_ENCODE_GZIP | SESSION_ENCODE_XGZIP;
ptr=GetToken(ptr,",",&Token,0);
}
break;
case HEAD_ICECAST:
if (atoi(ptr)) Session->Flags |= SESSION_ICECAST;
break;
case HEAD_IFMOD_SINCE:
Session->IfModifiedSince=DateStrToSecs("%a, %d %b %Y %H:%M:%S %Z",ptr,NULL);
break;
case HEAD_UPGRADE:
if ((strcasecmp(ptr,"Upgrade")==0) && SSLAvailable())
{
if (! HTTPServerActivateSSL(Session,Settings.SSLKeys)) return;
}
else if (strcasecmp(ptr,"websocket")==0) Session->MethodID = METHOD_WEBSOCKET;
break;
case HEAD_WEBSOCK_KEY:
Session->ContentBoundary=CopyStr(Session->ContentBoundary, ptr);
break;
case HEAD_WEBSOCK_KEY1:
Session->ContentBoundary=CopyStr(Session->ContentBoundary, ptr);
if (Session->MethodID==METHOD_WEBSOCKET) Session->MethodID = METHOD_WEBSOCKET75;
break;
case HEAD_WEBSOCK_KEY2:
Session->ContentType=CopyStr(Session->ContentType, ptr);
if (Session->MethodID==METHOD_WEBSOCKET) Session->MethodID = METHOD_WEBSOCKET75;
break;
case HEAD_WEBSOCK_PROTOCOL:
Session->ContentType=CopyStr(Session->ContentType, ptr);
break;
case HEAD_WEBSOCK_VERSION:
break;
case HEAD_ORIGIN:
break;
}
Tempstr=STREAMReadLine(Tempstr,Session->S);
StripTrailingWhitespace(Tempstr);
StripLeadingWhitespace(Tempstr);
}
if (strstr(Session->Arguments,"AccessToken")) Session->AuthFlags |= FLAG_AUTH_PRESENT | FLAG_AUTH_ACCESS_TOKEN;
Session->URL=HTTPUnQuote(Session->URL,Session->OriginalURL);
if (*Session->URL=='/') Session->Path=CopyStr(Session->Path,Session->URL);
else Session->Path=MCopyStr(Session->Path,"/",Session->URL,NULL);
DestroyString(Tempstr);
DestroyString(Token);
return(TRUE);
}
void ParseConfigItem(char *ConfigLine)
{
char *Token=NULL, *ptr;
int result;
const char *ConfTokens[]={"Chroot","Chshare","Chhome","AllowUsers","DenyUsers","Port","Banner","BannerFile","DataConnectionLowPort","DataConnectionHighPort","DataConnectionPortRange","ServLogFile","LogFile","Idle","MaxIdle","Locks","AuthFile","BindAddress","LogPasswords","AuthMethods","UserPrompt","PermittedCommands","DefaultGroup","MaxFileSize","UploadHook", "DownloadHook","RenameHook","DeleteHook","LoginHook","LogoutHook","ConnectUpHook","ConnectDownHook","ConfirmTransfer",NULL};
typedef enum {CT_CHROOT, CT_CHSHARE, CT_CHHOME, CT_ALLOWUSERS,CT_DENYUSERS,CT_PORT,CT_BANNER,CT_BANNERFILE,CT_DC_LOW_PORT, CT_DC_HIGH_PORT, CT_DC_RANGE,CT_SERVLOGFILE,CT_LOGFILE,CT_IDLE,CT_MAXIDLE,CT_LOCKS,CT_AUTHFILE,CT_BINDADDRESS,CT_LOGPASSWORDS,CT_AUTHMETHODS,CT_USERPROMPT,CT_PERMITTEDCOMMANDS,CT_DEFAULTGROUP, CT_MAXFILESIZE, CT_UPLOADHOOK, CT_DOWNLOADHOOK, CT_RENAMEHOOK, CT_DELETEHOOK, CT_LOGINHOOK, CT_LOGOUTHOOK, CT_CONNECTUPHOOK, CT_CONNECTDOWNHOOK, CT_CONFIRM_TRANSFER} EConfigStrings;
struct group *grent;
ptr=GetToken(ConfigLine,"=",&Token,0);
StripLeadingWhitespace(Token);
StripTrailingWhitespace(Token);
result=MatchTokenFromList(Token,ConfTokens,0);
if (ptr)
{
StripLeadingWhitespace(ptr);
StripTrailingWhitespace(ptr);
}
switch(result)
{
case CT_PORT:
Settings.Port=atoi(ptr);
break;
case CT_CHROOT:
Settings.Flags|=FLAG_CHROOT;
Settings.Chroot=CopyStr(Settings.Chroot,ptr);
break;
case CT_CHSHARE:
Settings.Flags|=FLAG_CHSHARE;
Settings.Chroot=CopyStr(Settings.Chroot,ptr);
break;
case CT_CHHOME:
Settings.Flags|=FLAG_CHHOME;
break;
case CT_ALLOWUSERS:
Settings.AllowUsers=CopyStr(Settings.AllowUsers,ptr);
break;
case CT_DENYUSERS:
Settings.DenyUsers=CopyStr(Settings.DenyUsers,ptr);
break;
case CT_DC_LOW_PORT:
Settings.DataConnectionLowPort=atoi(ptr);
break;
case CT_DC_HIGH_PORT:
Settings.DataConnectionHighPort=atoi(ptr);
break;
case CT_DC_RANGE:
ptr=GetToken(ptr,"-",&Token,0);
Settings.DataConnectionLowPort=atoi(Token);
Settings.DataConnectionHighPort=atoi(ptr);
break;
case CT_IDLE:
Settings.DefaultIdle=atoi(ptr);
break;
case CT_MAXIDLE:
Settings.MaxIdle=atoi(ptr);
break;
case CT_BANNER:
Settings.ConnectBanner=CopyStr(Settings.ConnectBanner,ptr);
break;
case CT_BANNERFILE:
Settings.ConnectBanner=ReadBannerFile(Settings.ConnectBanner,ptr);
break;
case CT_AUTHFILE:
Settings.AuthFile=CopyStr(Settings.AuthFile,ptr);
break;
case CT_SERVLOGFILE:
Settings.ServerLogPath=CopyStr(Settings.ServerLogPath,ptr);
break;
case CT_LOGFILE:
Settings.LogPath=CopyStr(Settings.LogPath,ptr);
break;
case CT_LOCKS:
if (strcmp(ptr,"Advisory")==0) Settings.Flags |= FLAG_ALOCK;
else if (strcmp(ptr,"Mandatory")==0) Settings.Flags |= FLAG_MLOCK;
else if (strcmp(ptr,"MandatoryWrite")==0) Settings.Flags |= FLAG_MLOCK | FLAG_ALOCK;
break;
case CT_BINDADDRESS:
Settings.BindAddress=CopyStr(Settings.BindAddress,ptr);
break;
case CT_LOGPASSWORDS:
Settings.Flags |= FLAG_LOGPASSWORDS;
break;
case CT_AUTHMETHODS:
Settings.AuthMethods=CopyStr(Settings.AuthMethods,ptr);
break;
case CT_USERPROMPT:
Settings.UserPrompt=CopyStr(Settings.UserPrompt,ptr);
break;
case CT_PERMITTEDCOMMANDS:
ParsePermittedCommands(&Settings,ptr);
break;
case CT_DEFAULTGROUP:
grent=getgrnam(ptr);
Settings.DefaultGroupID=grent->gr_gid;
break;
case CT_MAXFILESIZE:
Settings.MaxFileSize=strtod(ptr,NULL);
break;
case CT_UPLOADHOOK:
Settings.UploadHook=CopyStr(Settings.UploadHook,ptr);
break;
case CT_DOWNLOADHOOK:
Settings.DownloadHook=CopyStr(Settings.DownloadHook,ptr);
break;
case CT_RENAMEHOOK:
Settings.RenameHook=CopyStr(Settings.RenameHook,ptr);
break;
case CT_DELETEHOOK:
Settings.DeleteHook=CopyStr(Settings.DeleteHook,ptr);
break;
case CT_LOGINHOOK:
Settings.LoginHook=CopyStr(Settings.LoginHook,ptr);
break;
case CT_LOGOUTHOOK:
Settings.LogoutHook=CopyStr(Settings.LogoutHook,ptr);
break;
case CT_CONNECTUPHOOK:
Settings.ConnectUpHook=CopyStr(Settings.ConnectUpHook,ptr);
break;
case CT_CONNECTDOWNHOOK:
Settings.ConnectDownHook=CopyStr(Settings.ConnectDownHook,ptr);
break;
case CT_CONFIRM_TRANSFER:
Settings.ConfirmTransfer=MatchTokenFromList(ptr,HashNames,0);
break;
}
DestroyString(Token);
}
int AuthenticateExamineMethods(char *Methods, int LogErrors)
{
char *ptr, *Token=NULL;
int MethodsFound=0, val;
LogToFile(Settings.LogPath,"CONSIDER AUTH METHODS: %s",Methods);
ptr=GetToken(Methods,",",&Token,0);
while (ptr)
{
StripTrailingWhitespace(Token);
StripLeadingWhitespace(Token);
val=MatchTokenFromList(Token,AuthMethods,0);
switch (val)
{
case -1:
if (LogErrors) LogToFile(Settings.LogPath,"WARNING: unknown authentication method '%s'",Token);
break;
case AUTHTOK_NONE:
case AUTHTOK_OPEN:
MethodsFound |= AUTH_OPEN;
break;
case AUTHTOK_DENY:
MethodsFound |= AUTH_DENY;
break;
case AUTHTOK_NATIVE:
MethodsFound |= AUTH_NATIVE;
break;
case AUTHTOK_PAM:
MethodsFound |= AUTH_PAM;
break;
case AUTHTOK_PASSWD:
MethodsFound |= AUTH_PASSWD;
break;
case AUTHTOK_SHADOW:
MethodsFound |= AUTH_SHADOW;
break;
case AUTHTOK_DIGEST:
MethodsFound |= AUTH_DIGEST;
break;
case AUTHTOK_ACCESSTOKEN:
MethodsFound |= AUTH_ACCESSTOKEN;
break;
case AUTHTOK_ACCESSTOKEN_HTTP:
break;
}
ptr=GetToken(ptr,",",&Token,0);
}
if (LogErrors)
{
if ((Settings.AuthFlags & FLAG_AUTH_REQUIRED) && (MethodsFound == 0))
{
LogToFile(Settings.LogPath,"WARNING: NO AUTHENTICATION SYSTEM CONFIGURED, but not set to run as an 'open' system");
}
else if ((MethodsFound & AUTH_OPEN) && (MethodsFound != AUTH_OPEN))
{
LogToFile(Settings.LogPath,"WARNING: 'open' authentication is enabled along with other authentication types. 'open' authentication means no authentication, so other auth types will be disabled.");
}
else if ( (MethodsFound & AUTH_DIGEST) && (((MethodsFound & ~(AUTH_DIGEST | AUTH_ACCESSTOKEN)) !=0) ) )
{
LogToFile(Settings.LogPath,"WARNING: 'digest' authentication is enabled along with other authentication types. Digest authentication requires plain-text passwords in the *native* alaya authentication file, and cannot authenticate against /etc/passwd, /etc/shadow or PAM. Most clients will use digest in preference to 'basic' authentication. Thus including 'digest' will thus disable other authentication types.");
}
}
DestroyString(Token);
return(MethodsFound);
}
