common.c

#include "common.h"
#include "server.h"
#include "grp.h"

//for 'get default user'
#include "Authenticate.h"

TSettings Settings;
char *Version="4.5";

void SetTimezoneEnv()
{
    time_t Now;

    time(&Now);
    localtime(&Now);

    if (StrValid(tzname[1]))
    {
        setenv("TZ",tzname[1],TRUE);
    }
    else if (StrValid(tzname[0]))
    {
        setenv("TZ",tzname[0],TRUE);
    }
}



HTTPSession *HTTPSessionCreate()
{
    HTTPSession *Session;

    Session=(HTTPSession *) calloc(1,sizeof(HTTPSession));

//Must set all these to "" otherwise nulls can cause trouble later
    Session->Protocol=CopyStr(Session->Protocol,"HTTP/1.1");
    Session->ServerName=CopyStr(Session->ServerName,"");
    Session->UserAgent=CopyStr(Session->UserAgent,"");
    Session->UserName=CopyStr(Session->UserName,"");
    Session->RealUser=CopyStr(Session->RealUser,"");
    Session->ContentType=CopyStr(Session->ContentType,"");
    Session->Host=CopyStr(Session->Host,"");
    Session->Path=CopyStr(Session->Path,"");
    Session->Arguments=CopyStr(Session->Arguments,"");
    Session->ClientHost=CopyStr(Session->ClientHost,"");
    Session->ClientIP=CopyStr(Session->ClientIP,"");
    Session->ClientMAC=CopyStr(Session->ClientMAC,"");
    Session->ClientReferrer=CopyStr(Session->ClientReferrer,"");
    Session->StartDir=CopyStr(Session->StartDir,"");
    Session->Depth=1;
    Session->CacheTime=Settings.DocumentCacheTime;
    Session->Headers=ListCreate();
    Session->Flags |= SESSION_ALLOW_UPLOAD;

    return(Session);
}



HTTPSession *HTTPSessionClone(HTTPSession *Src)
{
    HTTPSession *Session;

    Session=(HTTPSession *) calloc(1,sizeof(HTTPSession));

//Must set all these to "" otherwise nulls can cause trouble later
    Session->Protocol=CopyStr(Session->Protocol, Src->Protocol);
    Session->Method=CopyStr(Session->Method, Src->Method);
    Session->URL=CopyStr(Session->URL, Src->URL);
    Session->ServerName=CopyStr(Session->ServerName, Src->ServerName);
    Session->UserAgent=CopyStr(Session->UserAgent, Src->UserAgent);

    Session->UserName=CopyStr(Session->UserName, Src->UserName);
    Session->RealUser=CopyStr(Session->RealUser, Src->RealUser);
    Session->Group=CopyStr(Session->Group, Src->Group);
    Session->HomeDir=CopyStr(Session->HomeDir, Src->HomeDir);
    Session->RemoteAuthenticate=CopyStr(Session->RemoteAuthenticate, Src->RemoteAuthenticate);

    Session->ContentType=CopyStr(Session->ContentType, Src->ContentType);
    Session->ContentBoundary=CopyStr(Session->ContentBoundary, Src->ContentBoundary);
    Session->Host=CopyStr(Session->Host, Src->Host);
    Session->Path=CopyStr(Session->Path, Src->Path);
    Session->Arguments=CopyStr(Session->Arguments, Src->Arguments);
    Session->ClientHost=CopyStr(Session->ClientHost, Src->ClientHost);
    Session->ClientIP=CopyStr(Session->ClientIP, Src->ClientIP);
    Session->ClientMAC=CopyStr(Session->ClientMAC, Src->ClientMAC);
    Session->ClientReferrer=CopyStr(Session->ClientReferrer, Src->ClientReferrer);
    Session->StartDir=CopyStr(Session->StartDir, Src->StartDir);
    Session->Cookies=CopyStr(Session->Cookies, Src->Cookies);
    Session->Cipher=CopyStr(Session->Cipher, Src->Cipher);
    Session->Depth=Src->Depth;
    Session->ContentSize=Src->ContentSize;
    Session->CacheTime=Src->CacheTime;
    Session->Flags=Src->Flags;
    Session->AuthFlags=Src->AuthFlags;
    Session->Headers=ListCreate();
    CopyVars(Session->Headers, Src->Headers);

    return(Session);
}


//This copies certain fields from a request session object
//to a new response session object, but only those ones that
//are appropriate to a response!
HTTPSession *HTTPSessionResponse(HTTPSession *Src)
{
    HTTPSession *Session;

    Session=(HTTPSession *) calloc(1,sizeof(HTTPSession));

//Must set all these to "" otherwise nulls can cause trouble later
    Session->Protocol=CopyStr(Session->Protocol, Src->Protocol);
    Session->Method=CopyStr(Session->Method, Src->Method);
    Session->URL=CopyStr(Session->URL, Src->URL);
    Session->ServerName=CopyStr(Session->ServerName, Src->ServerName);
    Session->UserAgent=CopyStr(Session->UserAgent, Src->UserAgent);

    Session->UserName=CopyStr(Session->UserName, Src->UserName);
    Session->RealUser=CopyStr(Session->RealUser, Src->RealUser);
    Session->Group=CopyStr(Session->Group, Src->Group);
    Session->RemoteAuthenticate=CopyStr(Session->RemoteAuthenticate, Src->RemoteAuthenticate);

    Session->ContentType=CopyStr(Session->ContentType, Src->ContentType);
    Session->Host=CopyStr(Session->Host, Src->Host);
    Session->Path=CopyStr(Session->Path, Src->Path);
    Session->Arguments=CopyStr(Session->Arguments, Src->Arguments);
    Session->ClientHost=CopyStr(Session->ClientHost, Src->ClientHost);
    Session->ClientIP=CopyStr(Session->ClientIP, Src->ClientIP);
    Session->ClientMAC=CopyStr(Session->ClientMAC, Src->ClientMAC);
    Session->StartDir=CopyStr(Session->StartDir, Src->StartDir);
    Session->Depth=Src->Depth;
    Session->CacheTime=Src->CacheTime;

//only copy certain flags!
    Session->Flags=Src->Flags & (SESSION_KEEPALIVE | SESSION_REUSE | SESSION_AUTHENTICATED | SESSION_SSL | SESSION_ICECAST | SESSION_ALLOW_UPLOAD) ;
    Session->AuthFlags=Src->AuthFlags;
    Session->Headers=ListCreate();

    return(Session);
}



void HTTPSessionDestroy(void *p_Trans)
{
    HTTPSession *Trans;

    if (! p_Trans) return;
    Trans=(HTTPSession *) p_Trans;

    Destroy(Trans->Protocol);
    Destroy(Trans->Method);
    Destroy(Trans->ResponseCode);
    Destroy(Trans->OriginalURL);
    Destroy(Trans->URL);
    Destroy(Trans->Path);
    Destroy(Trans->Cipher);
    Destroy(Trans->Arguments);
    Destroy(Trans->Destination);
    Destroy(Trans->ContentType);
    Destroy(Trans->ContentBoundary);
    Destroy(Trans->UserName);
    Destroy(Trans->Password);
    Destroy(Trans->RealUser);
    Destroy(Trans->HomeDir);
    Destroy(Trans->Host);
    Destroy(Trans->ClientIP);
    Destroy(Trans->ClientMAC);
    Destroy(Trans->ClientHost);
    Destroy(Trans->ClientReferrer);
    Destroy(Trans->UserAgent);
    Destroy(Trans->ServerName);
    Destroy(Trans->SearchPath);
    Destroy(Trans->UserSettings);
    Destroy(Trans->StartDir);

    ListDestroy(Trans->Headers,Destroy);
    free(Trans);
}


void HTTPSessionClear(void *p_Trans)
{
    HTTPSession *Trans;

    if (! p_Trans) return;
    Trans=(HTTPSession *) p_Trans;

//Clear everything but SESSION_REUSE, SESSION_AUTHENTICATED and HTTP_SSL, which are persistent
    Trans->Flags &= (SESSION_REUSE | SESSION_AUTHENTICATED | SESSION_ALLOW_UPLOAD | HTTP_SSL);

    Trans->Method=CopyStr(Trans->Method,"");
    Trans->ResponseCode=CopyStr(Trans->ResponseCode,"");
    Trans->URL=CopyStr(Trans->URL,"");
    Trans->Path=CopyStr(Trans->Path,"");
    Trans->Arguments=CopyStr(Trans->Arguments,"");
    Trans->Destination=CopyStr(Trans->Destination,"");
    Trans->ContentType=CopyStr(Trans->ContentType,"");
    Trans->ContentBoundary=CopyStr(Trans->ContentBoundary,"");
    Trans->UserName=CopyStr(Trans->UserName,"");
    Trans->Password=CopyStr(Trans->Password,"");
    Trans->Host=CopyStr(Trans->Host,"");
    Trans->ClientReferrer=CopyStr(Trans->ClientReferrer,"");
    Trans->UserAgent=CopyStr(Trans->UserAgent,"");
    Trans->SearchPath=CopyStr(Trans->SearchPath,"");

//Do not clear these values, as 'SessionClear' is only called on persistent
//'HTTP Keep-Alive' sessions
//Trans->Protocol=CopyStr(Trans->Protocol,"");
//Trans->Cipher=CopyStr(Trans->Cipher,"");
//Trans->ClientIP=CopyStr(Trans->ClientIP,"");
//Trans->ClientHost=CopyStr(Trans->ClientHost,"");
//Trans->StartDir=CopyStr(Trans->StartDir,"");
//Trans->HomeDir=CopyStr(Trans->HomeDir,"");
//Trans->RealUser=CopyStr(Trans->RealUser,"");
//Trans->UserSettings=CopyStr(Trans->UserSettings,"");
//Trans->ServerName=CopyStr(Trans->ServerName,"");


    ListClear(Trans->Headers,Destroy);
}

char *HTTPSessionGetArg(char *RetStr, HTTPSession *Session, const char *Arg)
{
    char *Name=NULL, *Value=NULL;
    const char *ptr;

    RetStr=CopyStr(RetStr, "");
    ptr=GetNameValuePair(Session->Arguments,"&","=",&Name,&Value);
    while (ptr)
    {
        if (strcasecmp(Name, Arg) ==0)
        {
            RetStr=HTTPUnQuote(RetStr, Value);
            break;
        }
        ptr=GetNameValuePair(ptr,"&","=",&Name,&Value);
    }

    Destroy(Name);
    Destroy(Value);

    return(RetStr);
}


void HandleError(int Flags, const char *FmtStr, ...)
{
    va_list args;
    char *Tempstr=NULL;

    va_start(args,FmtStr);
    Tempstr=VFormatStr(Tempstr,FmtStr,args);
    va_end(args);

    if (Flags & ERR_LOG) LogToFile(Settings.LogPath, "%s", Tempstr);
    if (Flags & ERR_PRINT) printf("%s\n",Tempstr);

    Destroy(Tempstr);
    if (Flags & ERR_EXIT) exit(1);
}


TPathItem *PathItemCreate(int Type, const char *URL, const char *Path)
{
    TPathItem *PI=NULL;

    PI=(TPathItem *) calloc(1, sizeof(TPathItem));
    PI->Type=Type;
    PI->Path=CopyStr(PI->Path,Path);
    PI->Name=CopyStr(PI->Name,GetBasename((char *) Path));
    PI->URL=CopyStr(PI->URL,URL);
    PI->ContentType=CopyStr(PI->ContentType, "");
    return(PI);
}

void PathItemDestroy(void *pi_ptr)
{
    TPathItem *PI;

    if (! pi_ptr) return;
    PI=(TPathItem *) pi_ptr;
    Destroy(PI->Path);
    Destroy(PI->URL);
    Destroy(PI->Name);
    Destroy(PI->ContentType);

    free(PI);
}




char *FormatURL(char *Buff, HTTPSession *Session, const char *ItemPath)
{
    char *Tempstr=NULL, *Quoted=NULL;
    const char *ptr=NULL, *sd_ptr;
    int len;

    if (StrValid(Session->Host))
    {
        if (Settings.Flags & FLAG_SSL) Tempstr=MCopyStr(Buff,"https://",Session->Host,"/",NULL);
        else Tempstr=MCopyStr(Buff,"http://",Session->Host,"/",NULL);
    }
    else Tempstr=CopyStr(Tempstr,"/");

    ptr=ItemPath;
    while (*ptr == '/') ptr++;

    if (StrValid(Session->StartDir)) sd_ptr=Session->StartDir;
    else sd_ptr="";

    while (*sd_ptr == '/') sd_ptr++;

    len=StrLen(sd_ptr);

    if (strncmp(ptr, sd_ptr,len)==0) ptr+=len;
    Quoted=HTTPQuoteChars(Quoted, ptr, " ()[]{}\t?&%!,+\':;#");

    Tempstr=CatStr(Tempstr,Quoted);

    Destroy(Quoted);
    return(Tempstr);
}




char *ParentDirectory(char *RetBuff, const char *Path)
{
    char *RetStr=NULL, *ptr;
    int len;

    RetStr=CopyStr(RetBuff,Path);
    len=StrLen(RetStr);

//Don't strip slash if directory is root dir
    if (len > 1)
    {
        StripDirectorySlash(RetStr);

        //Now strip off one dir name (the result of '..')
        StrRTruncChar(RetStr,'/');
        if (! StrValid(RetStr)) RetStr=CopyStr(RetStr,"/");
    }
    RetStr=SlashTerminateDirectoryPath(RetStr);

    return(RetStr);
}


char *SessionGetArgument(char *RetBuff, HTTPSession *Session, const char *ReqName)
{
    char *Name=NULL, *Value=NULL, *RetStr=NULL;
    const char *ptr;

    ptr=GetNameValuePair(Session->Arguments, "&", "=", &Name, &Value);
    while (ptr)
    {
        if (strcasecmp(ReqName,Name)==0)
        {
            RetStr=HTTPUnQuote(RetBuff,Value);
            break;
        }
        ptr=GetNameValuePair(ptr, "&", "=", &Name, &Value);
    }

    Destroy(Name);
    Destroy(Value);

    return(RetStr);
}


int IsLocalHost(HTTPSession *Session, char *Host)
{
    const char *ptr;
    int len;

    if (! StrValid(Host)) return(TRUE);
    if (strcmp(Host,"localhost")==0) return(TRUE);
    if (strcmp(Host,"127.0.0.1")==0) return(TRUE);

    len=StrLen(Session->Host);
    if (len)
    {
        ptr=strchr(Session->Host, ':');
        if (ptr) len=ptr-Session->Host;
    }

    if (strncasecmp(Session->Host,Host,len)==0) return(TRUE);

    return(FALSE);
}




int CopyLocalItem(char *From, char *To)
{
    glob_t Glob;
    struct stat FStat;
    char *Tempstr=NULL, *ptr;
    int i,  RetVal=EFAULT;
    STREAM *In=NULL, *Out=NULL;

    stat(From,&FStat);
    if (S_ISDIR(FStat.st_mode))
    {
        mkdir(To,FStat.st_mode);
        Tempstr=MCopyStr(Tempstr, From, "/*", NULL);
        glob(Tempstr, 0, 0, &Glob);
        for (i=0; i < Glob.gl_pathc; i++)
        {
            ptr=strrchr(Glob.gl_pathv[i],'/');
            if (! ptr) ptr=Glob.gl_pathv[i];
            Tempstr=MCopyStr(Tempstr, To, ptr, NULL);
            CopyLocalItem(Glob.gl_pathv[i],Tempstr);
        }
        RetVal=0;
        globfree(&Glob);
    }
    else
    {
        In=STREAMFileOpen(From,SF_RDONLY);
        if (In)
        {
            Out=STREAMFileOpen(To, SF_CREAT| SF_WRONLY | SF_TRUNC);
            if (Out) RetVal=STREAMSendFile(In, Out, 0, SENDFILE_KERNEL | SENDFILE_LOOP);
        }
    }

//as In and Out are NULL if not opened, it's safe to close them
//here as STREAMClose will ignore a NULL argument
    STREAMClose(In);
    STREAMClose(Out);
    Destroy(Tempstr);

    return(RetVal);
}


int CopyURL(HTTPSession *Session, char *From, char *To)
{
    char *Tempstr=NULL, *Host=NULL, *PortStr=NULL, *FromPath=NULL, *ToPath=NULL, *User=NULL, *Password=NULL;
    int RetVal=EFAULT;
    STREAM *In=NULL, *Out=NULL;

    ParseURL(To, &Tempstr, &Host, &Tempstr, NULL, NULL, &ToPath, NULL);

    if ((access(ToPath,F_OK)==0) && (! (Session->Flags & SESSION_OVERWRITE))) RetVal=EEXIST;

//If the TO Host is local
    if (IsLocalHost(Session,Host))
    {
        ParseURL(From, &Tempstr, &Host, &PortStr, &User, &Password, &FromPath, NULL);

        if (! IsLocalHost(Session,Host))
        {
            In=HTTPGet(From);
            if (In) Out=STREAMFileOpen(ToPath,SF_CREAT|SF_WRONLY|SF_TRUNC);
            if (Out) RetVal=STREAMSendFile(In, Out, 0, SENDFILE_KERNEL | SENDFILE_LOOP);
            STREAMClose(In);
            STREAMClose(Out);
        }
        else RetVal=CopyLocalItem(FromPath, ToPath);
    }

    Destroy(User);
    Destroy(Password);
    Destroy(Tempstr);
    Destroy(Host);
    Destroy(PortStr);
    Destroy(FromPath);
    Destroy(ToPath);

    return(RetVal);
}


char *FindScriptHandlerForScript(char *RetStr, const char *ScriptPath)
{
    char *Handler=NULL, *ptr;
    ListNode *Curr;

    ptr=strrchr(ScriptPath,'.');

    Handler=CopyStr(RetStr,"");
    if (ptr)
    {
        Curr=ListGetNext(Settings.ScriptHandlers);
        while (Curr)
        {
            if (
                (strcmp(Curr->Tag,ptr)==0) ||
                (strcmp(Curr->Tag,ptr+1)==0)
            )
            {
                Handler=CopyStr(Handler,(char *) Curr->Item);
                break;
            }
            Curr=ListGetNext(Curr);
        }
    }

    return(Handler);
}




void DropCapabilities(int Level)
{
#ifdef USE_LINUX_CAPABILITIES

//use portable 'libcap' interface if it's available
#ifdef HAVE_LIBCAP
#include <sys/capability.h>

#define CAPSET_SIZE 10
    int CapSet[CAPSET_SIZE];
    int NumCapsSet=0;
    cap_t cap;


//if we are a session then drop everything. Switch user should have happened,
//but if it failed we drop everything. Yes, a root attacker can probably
//reclaim caps, but it at least makes them do some work

    if (Level < CAPS_LEVEL_SESSION)
    {
        CapSet[NumCapsSet]= CAP_CHOWN;
        NumCapsSet++;

        CapSet[NumCapsSet]= CAP_SETUID;
        NumCapsSet++;

        CapSet[NumCapsSet]= CAP_SETGID;
        NumCapsSet++;
    }

    if (Level < CAPS_LEVEL_CHROOTED)
    {
        CapSet[NumCapsSet] = CAP_SYS_CHROOT;
        NumCapsSet++;

        CapSet[NumCapsSet] = CAP_FOWNER;
        NumCapsSet++;

        CapSet[NumCapsSet] = CAP_DAC_OVERRIDE;
        NumCapsSet++;
    }

    if (Level==CAPS_LEVEL_STARTUP)
    {
        CapSet[NumCapsSet] = CAP_NET_BIND_SERVICE;
        NumCapsSet++;
    }

    cap=cap_init();
    if (cap_set_flag(cap, CAP_EFFECTIVE, NumCapsSet, CapSet, CAP_SET) == -1)  ;
    if (cap_set_flag(cap, CAP_PERMITTED, NumCapsSet, CapSet, CAP_SET) == -1)  ;
    if (cap_set_flag(cap, CAP_INHERITABLE, NumCapsSet, CapSet, CAP_SET) == -1)  ;

    cap_set_proc(cap);
    cap_free(cap);

#else

//if libcap is not available try linux-only interface

#include <linux/capability.h>

    struct __user_cap_header_struct cap_hdr;
    cap_user_data_t cap_values;
    unsigned long CapVersions[]= { _LINUX_CAPABILITY_VERSION_3, _LINUX_CAPABILITY_VERSION_2, _LINUX_CAPABILITY_VERSION_1, 0};
    int val=0, i, result;

//the CAP_ values are not bitmask flags, but instead indexes, so we have
//to use shift to get the appropriate flag value
    if (Level < CAPS_LEVEL_SESSION)
    {
        val |=(1 << CAP_CHOWN);
        val |=(1 << CAP_SETUID);
        val |=(1 << CAP_SETGID);
    }

    if (Level < CAPS_LEVEL_CHROOTED)
    {
        val |= (1 << CAP_SYS_CHROOT);
        val |= (1 << CAP_FOWNER);
        val |= (1 << CAP_DAC_OVERRIDE);
    }


    if (Level==CAPS_LEVEL_STARTUP) val |= (1 << CAP_NET_BIND_SERVICE);


    for (i=0; CapVersions[i] > 0; i++)
    {
        cap_hdr.version=CapVersions[i];
        cap_hdr.pid=0;

        //Horrible cludgy interface. V1 uses 32bit, V2 uses 64 bit, and somehow spreads this over
        //two __user_cap_data_struct items
        if (CapVersions[i]==_LINUX_CAPABILITY_VERSION_1) cap_values=calloc(1,sizeof(struct __user_cap_data_struct));
        else cap_values=calloc(2,sizeof(struct __user_cap_data_struct));

        cap_values->effective=val;
        cap_values->permitted=val;
        cap_values->inheritable=val;
        result=capset(&cap_hdr, cap_values);
        free(cap_values);
        if (result == 0) break;
    }

#endif
#endif
}