// basic code from http://www-10.lotus.com/ldd/46dom.nsf/55c38d716d632d9b8525689b005ba1c0/dd8cc7c9ad12887a85256bca003476bf?OpenDocument

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include "dsapi.h"

#include "b64/cencode.h"
#include "b64/cdecode.h"

#define TRUE	1
#define FALSE	0

#define BUFFER_SIZE 4096

int MAX_USERNAME = 255;

char* filter_name = "Raidomatic Auto-Login";
int debug = FALSE;

int Authenticate(FilterContext* context, FilterAuthenticate* authData);
void dsapiMessage(char message[]);
//char* b64encode(char* string);
//char* b64decode(char* string);
int b64decode(char string[], char result[]);
//char* findCookie(char* cookies, char* cookieName);
void findCookie(char cookies[], char cookieName[], char result[]);
//char* xor(char* string, int key[], int keylen);
void xor(char string[], int key[], int keylen, char result[], int resultlen);

int FilterInit(FilterInitData* filterInitData) {
	filterInitData->appFilterVersion = kInterfaceVersion;
	filterInitData->eventFlags = kFilterAuthenticate;
	strcpy(filterInitData->filterDesc, filter_name);

	if(debug) dsapiMessage("Raidomatic Auto-Login started.");
	
	return kFilterHandledEvent;
}	// end FilterInit

unsigned int TerminateFilter(unsigned int reserved) {
	
	if(debug) dsapiMessage("Raidomatic Auto-Login unloaded.");

	return kFilterHandledEvent;
}	// end TerminateFilter


int HttpFilterProc(FilterContext* context, unsigned int eventType, void* eventData) {

	switch (eventType) {
		case kFilterAuthenticate:
			return Authenticate(context, eventData);
		default:
			return kFilterNotHandled;
	}
	
}	// end HttpFilterProc


int Authenticate(FilterContext* context, FilterAuthenticate* authData) {
	if(debug) dsapiMessage("Started Authenticate()");
	
	// Find our header information
	FilterRequest requestInfo;
	int errid;
	context->GetRequest(context, &requestInfo, &errid);
	
	char cookies[BUFFER_SIZE];
	int buffersize = BUFFER_SIZE;
	int cookiesLength;
	
	cookiesLength = authData->GetHeader(context, "Cookie", cookies, buffersize, &errid);
	if(cookiesLength == 0) { return kFilterNotHandled; }
	//cookies[cookiesLength] = '\0';
	if(debug) dsapiMessage("Found cookie data:");
	if(debug) dsapiMessage(cookies);
	
	//char* raidomaticUserCookie = findCookie(cookies, "RaidomaticAuthToken");
	char raidomaticUserCookie[BUFFER_SIZE];
	findCookie(cookies, "RaidomaticAuthToken1", raidomaticUserCookie);
	
	if(raidomaticUserCookie[0] != '\0') {
		// We've got a live one, here
		if(debug) AddInLogMessageText("RaidomaticAuthToken1: '%s'", 0, raidomaticUserCookie);
		
		//char* cookieLogin = b64decode(raidomaticUserCookie);
		char cookieLogin[BUFFER_SIZE];
		int resultlen = b64decode(raidomaticUserCookie, cookieLogin);
		if(debug) AddInLogMessageText("Decoded length: %d", 0, strlen(cookieLogin));
		if(debug) AddInLogMessageText("Reported b64 length: %d", 0, resultlen);
		cookieLogin[resultlen] = '\0';
		int key[3];
		key[0] = 343;
		key[1] = 3232;
		key[2] = 97;
		int keylen = 3;
		//char* decodedLogin = xor(cookieLogin, key, keylen);
		char decodedLogin[BUFFER_SIZE];
		xor(cookieLogin, key, keylen, decodedLogin, BUFFER_SIZE);
		if(debug) AddInLogMessageText("Un-xor'd length: %d", 0, strlen(decodedLogin));
		//if(debug) dsapiMessage("Auto-logging-in as:");
		//if(debug) dsapiMessage(decodedLogin);
		if(debug) AddInLogMessageText("Auto-logging-in as: '%s'", 0, decodedLogin);
		
	
		//char staticName[BUFFER_SIZE];
		//strncpy(&staticName, decodedLogin, BUFFER_SIZE-1);
	
		//authData->authName = decodedLogin;
		strncpy((char *)authData->authName, decodedLogin, authData->authNameSize);
		authData->authName[strlen(decodedLogin)] = '\0';
		authData->authType = kAuthenticBasic;
		authData->foundInCache = TRUE;
		
		if(debug) AddInLogMessageText("Resultant user is '%s'", 0, authData->authName);
		
		//free(cookieLogin);
		//free(decodedLogin);
		//free(raidomaticUserCookie);
	
		return kFilterHandledEvent;
	} else {	
		//free(raidomaticUserCookie);
		return kFilterNotHandled;
	}
}	// end Authenticate

void dsapiMessage(char message[]) {
	//FILE *file = fopen("/var/log/dsapi.log", "a+");
	//fprintf(file, "%s\n", message);
	//fclose(file);
	AddInLogMessageText(message, 0);
}

// char* b64encode(char* string) {
// 	base64_encodestate state;
// 	base64_init_encodestate(&state);
// 	int size = strlen(string);
// 	char* result = malloc((size+1) * 2 * sizeof(char));
// 	base64_encode_block(string, size+1, result, &state);
// 	return result;
// }
int b64decode(char string[], char result[]) {
	base64_decodestate state;
	base64_init_decodestate(&state);
	int size = strlen(string);
	if(debug) AddInLogMessageText("b64decode found length for '%s' to be %d", 0, string, size);
	//char* result = malloc((size+1) * sizeof(char));
	return base64_decode_block(string, size, result, &state);
	//return result;
}
void findCookie(char cookies[], char cookieName[], char result[]) {
	if(debug) dsapiMessage("entering findCookie() for:");
	int size = strlen(cookies);
	if(debug) dsapiMessage("found length of cookies");
	char strEqualsStub[] = "=";
	// For now, play it safe and set the size to be the maximum possible result, plus a bit extra
	//char* result = malloc(size * sizeof(char));
	result[0] = '\0';
	
	char* cookiePointer;
	cookiePointer = strstr(cookies, cookieName);
	if(debug) dsapiMessage(cookiePointer);
	if(strlen(&cookiePointer) == 0) {
		// Then the cookie wasn't found
		//return result;
		if(debug) dsapiMessage("didn't find cookie");
		return;
	}
	if(debug) dsapiMessage("found cookie");
	// Find and skip the '='
	cookiePointer = strstr(cookiePointer, strEqualsStub);
	cookiePointer++;
	
	// Now extract the value, going until the end of the string or the next cookie
	int index = 0;
	while(cookiePointer[index] != '\0' && cookiePointer[index] != ';' && index < BUFFER_SIZE-1) {
		result[index] = cookiePointer[index];
		index++;
	}
	result[index] = '\0';
	//return result;
}

void xor(char string[], int key[], int keylen, char result[], int resultlen) {
	int size = strlen(string);
	if(debug) AddInLogMessageText("Incoming xor length for '%s' is %d", 0, string, size);
	//char* result = malloc(size * sizeof(char));
	int i;
	for(i = 0; i < size && i < resultlen-1; i++) {
		result[i] = string[i] ^ key[i % keylen];
	}
	result[i] = '\0';
	//return result;
}