int HashFinish(HASH *Hash, int Encoding, char **Return)
{
char *Token=NULL, *Bytes=NULL, *Hashed=NULL, *ptr;
int len;
ptr=GetToken(Hash->Type, "\\S", &Token, 0);
len=Hash->Finish(Hash, &Bytes);
while (StrValid(ptr))
{
ptr=GetToken(ptr, "\\S", &Token, 0);
len=HashBytes(&Hashed, Token, Bytes, len, 0);
Bytes=SetStrLen(Bytes, len);
memcpy(Bytes,Hashed,len);
}
if (Encoding > 0)
{
*Return=EncodeBytes(*Return, Bytes, len, Encoding);
len=StrLen(*Return);
}
else
{
*Return=SetStrLen(*Return, len);
memcpy(*Return, Bytes, len);
}
DestroyString(Hashed);
DestroyString(Token);
DestroyString(Bytes);
return(len);
}
int PBK2DF2(char **Return, char *Type, char *Bytes, int Len, char *Salt, int SaltLen, uint32_t Rounds, int Encoding)
{
char *Tempstr=NULL, *Hash=NULL;
uint32_t RoundsBE;
int i, len, hlen;
//Network byte order is big endian
RoundsBE=htonl(Rounds);
Tempstr=SetStrLen(Tempstr, Len + SaltLen + 20);
memcpy(Tempstr, Bytes, Len);
memcpy(Tempstr+Len, Salt, SaltLen);
memcpy(Tempstr+Len+SaltLen, &RoundsBE, sizeof(uint32_t));
len=Len+SaltLen+sizeof(uint32_t);
for (i=0; i <Rounds; i++)
{
hlen=HashBytes(&Hash, Type, Tempstr, len, 0);
Tempstr=SetStrLen(Tempstr, Len + hlen + 20);
memcpy(Tempstr, Bytes, Len);
memcpy(Tempstr+Len, Hash, hlen);
len=Len + hlen;
}
*Return=EncodeBytes(*Return, Hash, hlen, Encoding);
DestroyString(Tempstr);
DestroyString(Hash);
StrLen(*Return);
}
char *VFormatStr(char *InBuff, const char *InputFmtStr, va_list args)
{
int inc=100, count=1, result=0, FmtLen;
char *Tempstr=NULL, *FmtStr=NULL, *ptr;
va_list argscopy;
Tempstr=InBuff;
//Take a copy of the supplied Format string and change it.
//Do not allow '%n', it's useable for exploits
FmtLen=StrLen(InputFmtStr);
FmtStr=CopyStr(FmtStr,InputFmtStr);
//Deny %n. Replace it with %x which prints out the value of any supplied argument
ptr=strstr(FmtStr,"%n");
while (ptr)
{
memcpy(ptr,"%x",2);
ptr++;
ptr=strstr(ptr,"%n");
}
inc=4 * FmtLen; //this should be a good average
for (count=1; count < 100; count++)
{
result=inc * count +1;
Tempstr=SetStrLen(Tempstr, result);
//the vsnprintf function DESTROYS the arg list that is passed to it.
//This is just plain WRONG, it's a long-standing bug. The solution is to
//us va_copy to make a new one every time and pass that in.
va_copy(argscopy,args);
result=vsnprintf(Tempstr,result,FmtStr,argscopy);
va_end(argscopy);
/* old style returns -1 to say couldn't fit data into buffer.. so we */
/* have to guess again */
if (result==-1) continue;
/* new style returns how long buffer should have been.. so we resize it */
if (result > (inc * count))
{
Tempstr=SetStrLen(Tempstr, result+10);
va_copy(argscopy,args);
result=vsnprintf(Tempstr,result+10,FmtStr,argscopy);
va_end(argscopy);
}
break;
}
DestroyString(FmtStr);
return(Tempstr);
}
void HTTPServerRecieveURL(STREAM *S,HTTPSession *Heads)
{
STREAM *Doc;
struct stat FileStat;
char *Buffer=NULL, *Tempstr=NULL;
int BuffSize=4096;
Doc=STREAMOpenFile(Heads->Path, SF_CREAT | SF_TRUNC | SF_WRONLY);
if (! Doc) HTTPServerSendHTML(S, Heads, "403 Forbidden","Can't open document for write.");
else
{
fchmod(Doc->in_fd,0660);
Buffer=SetStrLen(Buffer,BuffSize);
STREAMSendFile(S,Doc,Heads->ContentSize, SENDFILE_KERNEL | SENDFILE_LOOP);
STREAMClose(Doc);
stat(Heads->Path,&FileStat);
LogToFile(Settings.LogPath,"%s@%s (%s) uploaded %s (%d bytes)",Heads->UserName,Heads->ClientHost,Heads->ClientIP,Heads->Path,FileStat.st_size);
HTTPServerSendHTML(S, Heads, "201 Created","");
}
DestroyString(Tempstr);
DestroyString(Buffer);
}
int HTTPServerReadBody(HTTPSession *Session, char **Data)
{
char *Tempstr=NULL;
int bytes_read=0, len;
if (Session->ContentSize > 0)
{
*Data=SetStrLen(*Data,Session->ContentSize+10);
while (bytes_read < Session->ContentSize)
{
len=STREAMReadBytes(Session->S, (*Data) + bytes_read, Session->ContentSize-bytes_read);
if (len < 1) break;
bytes_read+=len;
}
}
else
{
Tempstr=STREAMReadLine(Tempstr,Session->S);
while (Tempstr)
{
len=StrLen(Tempstr);
*Data=CatStrLen(*Data,Tempstr,len);
bytes_read+=len;
Tempstr=STREAMReadLine(Tempstr,Session->S);
}
}
DestroyString(Tempstr);
return(bytes_read);
}
int HashFile(char **Return, const char *Type, const char *Path, int Encoding)
{
HASH *Hash;
STREAM *S;
char *Tempstr=NULL;
int result;
S=STREAMOpen(Path,"r");
if (! S) return(FALSE);
Hash=HashInit(Type);
if (! Hash)
{
STREAMClose(S);
return(FALSE);
}
Tempstr=SetStrLen(Tempstr,4096);
result=STREAMReadBytes(S,Tempstr,4096);
while (result !=EOF)
{
Hash->Update(Hash, Tempstr, result);
result=STREAMReadBytes(S,Tempstr,4096);
}
DestroyString(Tempstr);
STREAMClose(S);
result=HashFinish(Hash, Encoding, Return);
return(result);
}
const char *OpenSSLQueryCipher(STREAM *S)
{
void *ptr;
if (! S) return(NULL);
ptr=STREAMGetItem(S,"LIBUSEFUL-SSL-CTX");
if (! ptr) return(NULL);
#ifdef HAVE_LIBSSL
const SSL_CIPHER *Cipher;
char *Tempstr=NULL;
Cipher=SSL_get_current_cipher((const SSL *) ptr);
if (Cipher)
{
Tempstr=FormatStr(Tempstr,"%d bit %s",SSL_CIPHER_get_bits(Cipher,NULL), SSL_CIPHER_get_name(Cipher));
STREAMSetValue(S,"SSL-Cipher",Tempstr);
Tempstr=SetStrLen(Tempstr,1024);
Tempstr=SSL_CIPHER_description(Cipher, Tempstr, 1024);
STREAMSetValue(S,"SSL-Cipher-Details",Tempstr);
}
DestroyString(Tempstr);
return(STREAMGetValue(S,"SSL-Cipher"));
#else
return(NULL);
#endif
}
int HashFinishWhirlpool(THash *Hash, int Encoding, char **HashStr)
{
int count, len;
char *Tempstr=NULL, *DigestBuff=NULL;
DigestBuff=(char *) calloc(1,WHIRLPOOL_DIGESTBYTES+1);
WHIRLPOOLfinalize((WHIRLPOOLstruct *) Hash->Ctx, DigestBuff);
free(Hash->Ctx);
if (Encoding > 0)
{
*HashStr=EncodeBytes(*HashStr, DigestBuff, WHIRLPOOL_DIGESTBYTES, Encoding);
len=StrLen(*HashStr);
}
else
{
len=WHIRLPOOL_DIGESTBYTES;
*HashStr=SetStrLen(*HashStr,len);
memcpy(*HashStr,DigestBuff,len);
}
DestroyString(DigestBuff);
DestroyString(Tempstr);
return(len);
}
int HashFinishJH(THash *Hash, int Encoding, char **HashStr)
{
int count, len;
char *Tempstr=NULL, *DigestBuff=NULL;
DigestBuff=(char *) calloc(1,1024);
len=JHFinal((hashState *) Hash->Ctx, DigestBuff);
free(Hash->Ctx);
if (Encoding > 0)
{
*HashStr=EncodeBytes(*HashStr, DigestBuff, len, Encoding);
len=StrLen(*HashStr);
}
else
{
*HashStr=SetStrLen(*HashStr,len);
memcpy(*HashStr,DigestBuff,len);
}
DestroyString(DigestBuff);
DestroyString(Tempstr);
return(len);
}
int HashFinishSHA1(THash *Hash, int Encoding, char **HashStr)
{
int count, len;
char *Tempstr=NULL, *DigestBuff=NULL;
DigestBuff=(char *) calloc(1,SHA1LEN+1);
sha1_finish_ctx((struct sha1_ctx *) Hash->Ctx, DigestBuff);
free(Hash->Ctx);
if (Encoding > 0)
{
*HashStr=EncodeBytes(*HashStr, DigestBuff, SHA1LEN, Encoding);
len=StrLen(*HashStr);
}
else
{
len=SHA1LEN;
*HashStr=SetStrLen(*HashStr,len);
memcpy(*HashStr,DigestBuff,len);
}
DestroyString(DigestBuff);
DestroyString(Tempstr);
return(len);
}
int HashFinishSHA512(THash *Hash, int Encoding, char **HashStr)
{
int count, len;
char *Tempstr=NULL, *DigestBuff=NULL;
DigestBuff=(char *) calloc(1,SHA2_SHA512_DIGEST_LENGTH+1);
SHA2_SHA512_Final(DigestBuff, (SHA2_SHA512_CTX *) Hash->Ctx);
free(Hash->Ctx);
if (Encoding > 0)
{
*HashStr=EncodeBytes(*HashStr, DigestBuff, SHA2_SHA512_DIGEST_LENGTH, Encoding);
len=StrLen(*HashStr);
}
else
{
len=SHA2_SHA512_DIGEST_LENGTH;
*HashStr=SetStrLen(*HashStr,len);
memcpy(*HashStr,DigestBuff,len);
}
DestroyString(DigestBuff);
DestroyString(Tempstr);
return(len);
}
int HashFinishMD5(THash *Hash, int Encoding, char **HashStr)
{
int count, len;
char *Tempstr=NULL, *DigestBuff=NULL;
DigestBuff=(char *) calloc(1,MD5LEN+1);
MD5Final(DigestBuff, (MD5_CTX *) Hash->Ctx);
free(Hash->Ctx);
if (Encoding > 0)
{
*HashStr=EncodeBytes(*HashStr, DigestBuff, MD5LEN, Encoding);
len=StrLen(*HashStr);
}
else
{
len=MD5LEN;
*HashStr=SetStrLen(*HashStr,len);
memcpy(*HashStr,DigestBuff,len);
}
DestroyString(DigestBuff);
DestroyString(Tempstr);
return(len);
}
int STREAMAddDataProcessor(STREAM *S, TProcessingModule *Mod, const char *Args)
{
ListNode *Curr;
char *Tempstr=NULL;
int len;
STREAMFlush(S);
if (! S->ProcessingModules) S->ProcessingModules=ListCreate();
Tempstr=MCopyStr(Tempstr,Mod->Name,NULL);
ListAddNamedItem(S->ProcessingModules,Tempstr,Mod);
len=S->InEnd - S->InStart;
Tempstr=SetStrLen(Tempstr,len);
memcpy(Tempstr,S->InputBuff + S->InStart,len);
STREAMResetInputBuffers(S);
Curr=ListGetNext(Mod->Values);
while (Curr)
{
STREAMSetValue(S,Curr->Tag,(char *) Curr->Item);
Curr=ListGetNext(Curr);
}
STREAMReadThroughProcessors(S, Tempstr, len);
DestroyString(Tempstr);
return(TRUE);
}
char *GetDateStrFromSecs(const char *DateFormat, time_t Secs, const char *TimeZone)
{
time_t val;
struct tm *TMS;
static char *Buffer=NULL;
char *Tempstr=NULL;
#define DATE_BUFF_LEN 255
val=Secs;
if (StrLen(TimeZone))
{
if (getenv("TZ")) Tempstr=CopyStr(Tempstr,getenv("TZ"));
setenv("TZ",TimeZone,TRUE);
tzset();
}
TMS=localtime(&val);
if (StrLen(TimeZone))
{
if (! Tempstr) unsetenv("TZ");
else setenv("TZ",Tempstr,TRUE);
tzset();
}
val=StrLen(DateFormat)+ DATE_BUFF_LEN;
Buffer=SetStrLen(Buffer,val);
strftime(Buffer,val,DateFormat,TMS);
DestroyString(Tempstr);
return(Buffer);
}
void HTTPServerSendResponse(STREAM *S, HTTPSession *Session, char *ResponseLine, char *ContentType, char *Body)
{
HTTPSession *Response;
char *Tempstr=NULL;
long ResponseCode=0;
LogToFile(Settings.LogPath,"RESPONSE: '%s' to %s@%s for '%s %s'",ResponseLine,Session->UserName,Session->ClientIP,Session->Method,Session->Path);
ResponseCode=strtol(ResponseLine,NULL,10);
//Create 'Response' rather than using session, because things set by the client in 'Session' might
//get copied into the response and interfere with the response otherwise
Response=HTTPSessionCreate();
/*Copy Values from Session object into Response */
if (Session)
{
Response->MethodID=Session->MethodID;
Response->LastModified=Session->LastModified;
Response->Flags |= Session->Flags & (SESSION_KEEPALIVE | SESSION_AUTHENTICATED);
//Response->Flags |= SESSION_KEEPALIVE;
Response->ClientIP=CopyStr(Response->ClientIP,Session->ClientIP);
Response->Path=CopyStr(Response->Path,Session->Path);
Response->Method=CopyStr(Response->Method,Session->Method);
Response->URL=CopyStr(Response->URL,Session->URL);
Response->UserName=CopyStr(Response->UserName,Session->UserName);
}
Response->ResponseCode=CopyStr(Response->ResponseCode,ResponseLine);
if (ResponseCode==302) SetVar(Response->Headers,"Location",Body);
else Response->ContentSize=StrLen(Body);
Response->ContentType=CopyStr(Response->ContentType,ContentType);
if (HTTPServerDecideToCompress(Session,NULL))
{
Response->Flags |= SESSION_ENCODE_GZIP;
Tempstr=SetStrLen(Tempstr,Response->ContentSize *2);
Response->ContentSize=CompressBytes(&Tempstr, "gzip",Body, StrLen(Body), 5);
}
else Tempstr=CopyStr(Tempstr,Body);
if ((ResponseCode==401) || (ResponseCode==407)) HTTPServerSendHeaders(S, Response,HEADERS_AUTH);
else HTTPServerSendHeaders(S, Response, HEADERS_KEEPALIVE);
STREAMWriteBytes(S,Tempstr,Response->ContentSize);
STREAMFlush(S);
/* If HTTPServerSendHeaders set SESSION_REUSE then set that in the Session object */
//if (Response->Flags & SESSION_REUSE) Session->Flags |= SESSION_REUSE;
//else Session->Flags &= ~SESSION_REUSE;
ProcessSessionEventTriggers(Response);
HTTPSessionDestroy(Response);
DestroyString(Tempstr);
}
char *EncodeBase64(char *Return, char *Text, int len)
{
char *RetStr;
RetStr=SetStrLen(Return,len *2);
to64frombits(RetStr,Text,len);
return(RetStr);
}
char *DecodeBase64(char *Return, int *len, char *Text)
{
char *RetStr;
RetStr=SetStrLen(Return,StrLen(Text) *2);
*len=from64tobits(RetStr,Text);
return(RetStr);
}
char *HTTPHeadersAppendAuth(char *RetStr, char *AuthHeader, HTTPInfoStruct *Info, HTTPAuthStruct *AuthInfo)
{
char *SendStr=NULL, *Tempstr=NULL;
char *HA1=NULL, *HA2=NULL, *ClientNonce=NULL, *Digest=NULL;
int i, AuthCounter;
if (! AuthInfo) return(RetStr);
SendStr=CatStr(RetStr,"");
//Authentication by an opaque authentication token that is handled
//elsewhere, and is set as the 'Password'
if (AuthInfo->Flags & HTTP_AUTH_TOKEN)
{
SendStr=MCatStr(SendStr,AuthHeader,": ",AuthInfo->Password,"\r\n",NULL);
AuthInfo->Flags |= HTTP_SENT_AUTH;
}
else if (AuthInfo->Flags & HTTP_AUTH_DIGEST)
{
AuthCounter++;
Tempstr=FormatStr(Tempstr,"%s:%s:%s",AuthInfo->Logon,AuthInfo->AuthRealm,AuthInfo->Password);
HashBytes(&HA1,"md5",Tempstr,StrLen(Tempstr),0);
Tempstr=FormatStr(Tempstr,"%s:%s",Info->Method,Info->Doc);
HashBytes(&HA2,"md5",Tempstr,StrLen(Tempstr),0);
for (i=0; i < 10; i++)
{
Tempstr=FormatStr(Tempstr,"%x",rand() % 255);
ClientNonce=CatStr(ClientNonce,Tempstr);
}
Tempstr=FormatStr(Tempstr,"%s:%s:%08d:%s:auth:%s",HA1,AuthInfo->AuthNonce,AuthCounter,ClientNonce,HA2);
HashBytes(&Digest,"md5",Tempstr,StrLen(Tempstr),0);
Tempstr=FormatStr(Tempstr,"%s: Digest username=\"%s\",realm=\"%s\",nonce=\"%s\",uri=\"%s\",qop=auth,nc=%08d,cnonce=\"%s\",response=\"%s\"\r\n",AuthHeader,AuthInfo->Logon,AuthInfo->AuthRealm,AuthInfo->AuthNonce,Info->Doc,AuthCounter,ClientNonce,Digest);
SendStr=CatStr(SendStr,Tempstr);
AuthInfo->Flags |= HTTP_SENT_AUTH;
}
else
{
Tempstr=CopyStr(Tempstr,AuthInfo->Logon);
Tempstr=CatStr(Tempstr,":");
Tempstr=CatStr(Tempstr,AuthInfo->Password);
Digest=SetStrLen(Digest,StrLen(Tempstr) *2);
to64frombits(Digest,Tempstr,strlen(Tempstr));
SendStr=MCatStr(SendStr,AuthHeader,": Basic ",Digest,"\r\n",NULL);
AuthInfo->Flags |= HTTP_SENT_AUTH;
}
DestroyString(HA1);
DestroyString(HA2);
DestroyString(ClientNonce);
DestroyString(Digest);
DestroyString(Tempstr);
return(SendStr);
}
void HMACPrepare(HASH *HMAC, const char *Data, int Len)
{
int i;
char *Key=NULL, *Tempstr=NULL;
//Whatever we've been given as a key, we have to turn it into a
//key of 'HMAC_BLOCKSIZE', either by hashing it to make it shorter
//or by padding with NULLS
Key=SetStrLen(Key,HMAC_BLOCKSIZE);
memset(Key,0,HMAC_BLOCKSIZE);
if (Len > HMAC_BLOCKSIZE)
{
HMAC->Key1Len=HashBytes(&Tempstr,HMAC->Type,HMAC->Key1,HMAC->Key1Len,0);
memcpy(Key,Tempstr,HMAC->Key1Len);
}
else
{
memcpy(Key,HMAC->Key1,HMAC->Key1Len);
}
HMAC->Key1=SetStrLen(HMAC->Key1,HMAC_BLOCKSIZE);
HMAC->Key2=SetStrLen(HMAC->Key2,HMAC_BLOCKSIZE);
HMAC->Key1Len=HMAC_BLOCKSIZE;
HMAC->Key2Len=HMAC_BLOCKSIZE;
for (i=0; i < HMAC_BLOCKSIZE; i++)
{
//inner key
HMAC->Key1[i]=Key[i] ^ 0x36;
//outer key
HMAC->Key2[i]=Key[i] ^ 0x5c;
}
//first thing to be hashed is the inner key, then data is 'concatted' onto it
HMACUpdate(HMAC, HMAC->Key1, HMAC->Key1Len);
HMACUpdate(HMAC, Data, Len);
HMAC->Update=HMACUpdate;
DestroyString(Tempstr);
DestroyString(Key);
}
int HTTPChunkedRead(TProcessingModule *Mod, const char *InBuff, int InLen, char **OutBuff, int *OutLen)
{
int len=0, val=0;
THTTPChunk *Chunk;
char *ptr, *vptr;
Chunk=(THTTPChunk *) Mod->Data;
len=Chunk->BuffLen+InLen;
Chunk->Buffer=SetStrLen(Chunk->Buffer,len);
memcpy(Chunk->Buffer+Chunk->BuffLen,InBuff,InLen);
Chunk->BuffLen=len;
ptr=Chunk->Buffer;
if (Chunk->ChunkSize==0)
{
vptr=ptr;
if (*vptr=='\r') vptr++;
if (*vptr=='\n') vptr++;
ptr=strchr(vptr,'\n');
if (ptr)
{
*ptr='\0';
ptr++;
}
else ptr=Chunk->Buffer;
Chunk->ChunkSize=strtol(vptr,NULL,16);
Chunk->BuffLen=Chunk->Buffer+len-ptr;
memmove(Chunk->Buffer,ptr,Chunk->BuffLen);
if (Chunk->ChunkSize==0) return(0);
}
else if (len >= Chunk->ChunkSize)
{
val=Chunk->ChunkSize;
//We should really grow OutBuff to take all the data
//but for the sake of simplicity we'll just use the space
//supplied
if (val > *OutLen) val=*OutLen;
memcpy(*OutBuff,Chunk->Buffer,val);
ptr=Chunk->Buffer+val;
Chunk->BuffLen-=val;
Chunk->ChunkSize-=val;
memmove(Chunk->Buffer, ptr, Chunk->BuffLen);
}
if (Chunk->ChunkSize < 0) Chunk->ChunkSize=0;
return(val);
}
int HashFinishCRC(HASH *Hash, char **HashStr)
{
unsigned long crc;
int len;
len=sizeof(unsigned long);
crc32Finish((unsigned long *) Hash->Ctx);
crc=htonl(* (unsigned long *) Hash->Ctx);
*HashStr=SetStrLen(*HashStr,len);
memcpy(*HashStr,&crc,len);
return(len);
}
void SendResponse(ConnectStruct *Con,DNSMessageStruct *Response)
{
struct sockaddr_in Send_sa;
short int sendlen;
int len, salen;
char *Buffer=NULL;
ListNode *Curr;
ResourceRecord *RR;
Buffer=SetStrLen(Buffer,1024);
len=CreateResponsePacket(Buffer,Buffer+1024,Response,&Settings);
if (len==0)
{
LogToFile(Settings.LogFilePath,"ERROR: Zero length response packet");
DestroyString(Buffer);
return;
}
if (Con->Type==TCP_CONNECT)
{
sendlen=htons(len);
write(Con->fd, &sendlen, sizeof(short int));
write(Con->fd, Buffer, len);
}
else if (Con->Type==UDP_CONNECT)
{
Send_sa.sin_family=AF_INET;
Send_sa.sin_addr.s_addr=Response->ClientIP;
Send_sa.sin_port=Response->ClientPort;
salen=sizeof(struct sockaddr_in);
sendto(Con->fd,Buffer,len,0,(struct sockaddr *) &Send_sa,salen);
}
else LogToFile(Settings.LogFilePath,"ERROR: Unknown Comms Type %d on send",Con->Type);
if (Settings.LogLevel >= LOG_RESPONSES)
{
LogToFile(Settings.LogFilePath,"Sent %d answers to %s for %s query",ListSize(Response->Answers), IPtoStr(Response->ClientIP),Response->Question);
Curr=ListGetNext(Response->Answers);
while (Curr)
{
RR=(ResourceRecord *) Curr->Item;
LogToFile(Settings.LogFilePath," ANS: %s->%s type=%d ttl=%d",RR->Question,RR->Answer,RR->Type,RR->TTL);
Curr=ListGetNext(Curr);
}
}
DestroyString(Buffer);
}
int SMTPLogin(STREAM *S, int Caps, const char *User, const char *Pass)
{
char *Tempstr=NULL, *Base64=NULL, *ptr;
int len, result=FALSE;
if (Caps & CAP_AUTH_LOGIN)
{
Tempstr=CopyStr(Tempstr, "AUTH LOGIN\r\n");
if (SMTPInteract(Tempstr, S))
{
Base64=EncodeBytes(Base64, User, StrLen(User), ENCODE_BASE64);
Tempstr=MCopyStr(Tempstr, Base64, "\r\n", NULL);
if (SMTPInteract(Tempstr, S))
{
Base64=EncodeBytes(Base64, Pass, StrLen(Pass), ENCODE_BASE64);
Tempstr=MCopyStr(Tempstr, Base64, "\r\n", NULL);
if (SMTPInteract(Tempstr, S)) result=TRUE;
}
}
}
else if (Caps & CAP_AUTH_PLAIN)
{
Tempstr=SetStrLen(Tempstr, StrLen(User) + StrLen(Pass) +10);
//this isn't what it looks like. The '\0' here do not terminate the string
//as this authentication system uses a string with '\0' as separators
len=StrLen(User);
ptr=Tempstr;
memcpy(ptr, User, len);
ptr+=len;
*ptr='\0';
ptr++;
len=StrLen(Pass);
memcpy(ptr, Pass, len);
ptr+=len;
*ptr='\0';
ptr++;
Base64=EncodeBytes(Base64, Tempstr, ptr-Tempstr, ENCODE_BASE64);
Tempstr=MCopyStr(Tempstr, "AUTH PLAIN ", Base64, "\r\n",NULL);
if (SMTPInteract(Tempstr, S)) result=TRUE;
}
DestroyString(Tempstr);
DestroyString(Base64);
return(result);
}
void HTTPCopyToSTREAM(STREAM *Con, STREAM *S)
{
char *Tempstr=NULL;
int result;
Tempstr=SetStrLen(Tempstr,BUFSIZ);
result=STREAMReadBytes(Con, Tempstr,BUFSIZ);
while (result > 0)
{
STREAMWriteBytes(S,Tempstr,result);
result=STREAMReadBytes(Con, Tempstr,BUFSIZ);
}
}
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);
}
int ConnectHopSocks(STREAM *S, int Type, const char *Host, int Port, const char *User, const char *Pass, const char *Path)
{
char *Tempstr=NULL;
uint8_t *ptr;
char *Token=NULL;
const char *tptr;
int result, RetVal=FALSE;
S->in_fd=ConnectToHost(Host,Port,0);
S->out_fd=S->in_fd;
if (S->in_fd == -1) return(FALSE);
//Horrid binary protocol.
Tempstr=SetStrLen(Tempstr, StrLen(User) +20);
ptr=Tempstr;
*ptr=4; //version number
ptr++;
*ptr=1; //outward connection (2 binds a port for incoming)
ptr++;
tptr=Path;
if (strncmp(tptr,"tcp:",4)==0) tptr+=4;
tptr=GetToken(tptr,":",&Token,0);
//destination port
*((uint16_t *) ptr) =htons(atoi(tptr));
ptr+=2;
//destination host
*((uint32_t *) ptr) =StrtoIP(Token);
ptr+=4;
strcpy(ptr,User);
ptr+=StrLen(User);
ptr++;
STREAMWriteBytes(S,Tempstr,(char *)ptr-Tempstr); STREAMFlush(S);
result=STREAMReadBytes(S,Tempstr,8);
//Positive response will be 0x00 0x5a 0x00 0x00 0x00 0x00 0x00 0x00
//although only the leading two bytes (0x00 0x5a, or \0Z) matters
if ((result==8) && (Tempstr[0]=='\0') && (Tempstr[1]=='Z')) RetVal=TRUE;
DestroyString(Tempstr);
DestroyString(Token);
return(RetVal);
}
void SendICYMessage(STREAM *Output, const char *ICYMessage)
{
uint8_t len;
char *Tempstr=NULL;
len=StrLen(ICYMessage);
if (len > 0) len=(len / 16) + 1;
Tempstr=SetStrLen(Tempstr,len * 16);
memset(Tempstr,0,len * 16);
strcpy(Tempstr,ICYMessage);
STREAMWriteBytes(Output,(char *) &len,1);
STREAMWriteBytes(Output,Tempstr,len * 16);
DestroyString(Tempstr);
}
int HashFinishJH(HASH *Hash, char **HashStr)
{
int len;
char *DigestBuff=NULL;
DigestBuff=(char *) calloc(1,1024);
len=JHFinal((hashState *) Hash->Ctx, (unsigned char *) DigestBuff);
*HashStr=SetStrLen(*HashStr,len);
memcpy(*HashStr,DigestBuff,len);
DestroyString(DigestBuff);
return(len);
}
int HashFinishWhirlpool(HASH *Hash, char **HashStr)
{
int len;
char *DigestBuff=NULL;
DigestBuff=(char *) calloc(1,WHIRLPOOL_DIGESTBYTES+1);
WHIRLPOOLfinalize((WHIRLPOOLstruct *) Hash->Ctx, (unsigned char *) DigestBuff);
len=WHIRLPOOL_DIGESTBYTES;
*HashStr=SetStrLen(*HashStr,len);
memcpy(*HashStr,DigestBuff,len);
DestroyString(DigestBuff);
return(len);
}
int HashFinishSHA512(HASH *Hash, char **HashStr)
{
int len;
char *DigestBuff=NULL;
DigestBuff=(char *) calloc(1,SHA2_SHA512_DIGEST_LENGTH+1);
SHA2_SHA512_Final((unsigned char *) DigestBuff, (SHA2_SHA512_CTX *) Hash->Ctx);
len=SHA2_SHA512_DIGEST_LENGTH;
*HashStr=SetStrLen(*HashStr,len);
memcpy(*HashStr,DigestBuff,len);
DestroyString(DigestBuff);
return(len);
}
