/*
FILE
	$Id: mysqlrad.h 6 2005-11-24 00:02:59Z ggw $
PURPOSE
	mysqlSendmail RAD + branched mods main .h file.
LEGAL
	(C) 2001-2004 Gary Wallis. 
	GPL license applies: See www.fsf.org for details.
	LICENSE included in this distribution.
*/

#include <stdio.h>
#include <stdlib.h>
#include <pwd.h>
#include <signal.h>
#include <time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/socket.h>
#ifndef Linux
        #include <sys/systeminfo.h>
#else
        #ifndef FreeBSD
                #include <crypt.h>
        #endif
#endif
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <string.h>
#include <sys/file.h>

#include "cgi.h"

#ifdef FreeBSD
	#include "/usr/local/include/mysql/mysql.h"
#else
	#include <mysql/mysql.h>
#endif

#include <unistd.h>

#include "language.h"
#include "local.h"

extern char cHost[];
extern char cHostname[];
extern char cUser[];
#define PERMLEVEL
extern int uPermLevel; 
extern unsigned uLoginClient; 
extern unsigned uReseller; 

extern char function[];
extern char query[];
extern char *qstr;
extern MYSQL mysql; 
extern unsigned long rowid;
extern unsigned start;
extern unsigned end;
extern unsigned i;
extern unsigned n;
extern char command[];
extern char filter[];
extern char find[];
extern char table[];
extern int mode;
extern int error;
extern char errormsg[];

void mysqlSendmail(const char *result);
void ConnectDb(void);
void Footer_ism3(void);
void Header_ism3(char *msg, int js);
void ProcessControlVars(pentry entries[], int x);
void OpenRow(char *cFieldLabel, char *cColor);
void LoadConf(void);
void NoSuchFunction(void);
void tTablePullDownOwner(char *cTableName, char *cFieldName,
                        char *cOrderby, int unsigned uSelector);
void tTablePullDown(char *cTableName, char *cFieldName,
                        char *cOrderby, int unsigned uSelector);
void tTablePullDownReadOnly(char *cTableName, char *cFieldName,
                        char *cOrderby, int unsigned uSelector);
int ReadPullDown(char *cTableName,char *cFieldName,char *cLabel);
const char *TextAreaSave(const char *cField);
const char *TransformAngleBrackets(const char *cField);
const char *EncodeDoubleQuotes(const char *cField);
void YesNoPullDown(char *cFieldName, unsigned uSelect);
void YesNo(unsigned uSelect);
int ReadYesNoPullDown(char *cLabel);
const char *ForeignKey(const char *cTableName, const char *cFieldName, unsigned uKey);
void GetClientOwner(unsigned uClient, unsigned *uOwner);

 //Standard tInputFunc functions
char *WordToLower(char *cInput);
char *EmailUser(char *cInput);
char *IPNumber(char *cInput);
char *FQDomainName(char *cInput);
char *EmailInput(char *cInput);

 //Standard tValidFunc functions
char *EmptyString(char *cInput);
char *BadIPNum(char *cInput);
char *IsZero(unsigned uInput);

 //External pagination form processing vars
void PageMachine(char *funcName, int mode, char *msg);

 //Place ModuleCommands() and Module() prototypes here
#define ISPNAME "OpenISP"
#define ISPURL "www.openisp.net"
#define ADMIN 9

#define ACCESS_SOURCE_WEBCONSOLE 1
#define ACCESS_SOURCE_POPPER 2
#define ACCESS_SOURCE_RADIUSD 3
#define ACCESS_SOURCE_NUKESPAM_MISSES 4
#define ACCESS_SOURCE_NUKESPAM_NSENT 5
#define ACCESS_SOURCE_NUKESPAM_RESERVED 6
#define ACCESS_SOURCE_DUL 7


 //MakeTableSource prototypes
//tUser
int tUserCommands(pentry entries[], int x);
void tUser(const char *results);
void ProcesstUserVars(pentry entries[], int x);
void tUserContent(void);
void tUserInputContent(void);
void tUserList(void);
void NewtUser(unsigned uMode);
void ModtUser(void);
void CreatetUser(void);
void DeletetUser(void);
void ExttUserGetHook(entry gentries[], int x);

//tAlias
int tAliasCommands(pentry entries[], int x);
void tAlias(const char *results);
void ProcesstAliasVars(pentry entries[], int x);
void tAliasContent(void);
void tAliasInputContent(void);
void tAliasList(void);
void NewtAlias(unsigned uMode);
void ModtAlias(void);
void CreatetAlias(void);
void DeletetAlias(void);
void ExttAliasGetHook(entry gentries[], int x);

//tDomain
int tDomainCommands(pentry entries[], int x);
void tDomain(const char *results);
void ProcesstDomainVars(pentry entries[], int x);
void tDomainContent(void);
void tDomainInputContent(void);
void tDomainList(void);
void NewtDomain(unsigned uMode);
void ModtDomain(void);
void CreatetDomain(void);
void DeletetDomain(void);
void ExttDomainGetHook(entry gentries[], int x);

//tVUT
int tVUTCommands(pentry entries[], int x);
void tVUT(const char *results);
void ProcesstVUTVars(pentry entries[], int x);
void tVUTContent(void);
void tVUTInputContent(void);
void tVUTList(void);
void NewtVUT(unsigned uMode);
void ModtVUT(void);
void CreatetVUT(void);
void DeletetVUT(void);
void ExttVUTGetHook(entry gentries[], int x);

//tVUTEntries
int tVUTEntriesCommands(pentry entries[], int x);
void tVUTEntries(const char *results);
void ProcesstVUTEntriesVars(pentry entries[], int x);
void tVUTEntriesContent(void);
void tVUTEntriesInputContent(void);
void tVUTEntriesList(void);
void NewtVUTEntries(unsigned uMode);
void ModtVUTEntries(void);
void CreatetVUTEntries(void);
void DeletetVUTEntries(void);
void ExttVUTEntriesGetHook(entry gentries[], int x);

//tDUL
int tDULCommands(pentry entries[], int x);
void tDUL(const char *results);
void ProcesstDULVars(pentry entries[], int x);
void tDULContent(void);
void tDULInputContent(void);
void tDULList(void);
void NewtDUL(unsigned uMode);
void ModtDUL(void);
void CreatetDUL(void);
void DeletetDUL(void);
void ExttDULGetHook(entry gentries[], int x);

//tAccess
int tAccessCommands(pentry entries[], int x);
void tAccess(const char *results);
void ProcesstAccessVars(pentry entries[], int x);
void tAccessContent(void);
void tAccessInputContent(void);
void tAccessList(void);
void NewtAccess(unsigned uMode);
void ModtAccess(void);
void CreatetAccess(void);
void DeletetAccess(void);
void ExttAccessGetHook(entry gentries[], int x);

//tLocal
int tLocalCommands(pentry entries[], int x);
void tLocal(const char *results);
void ProcesstLocalVars(pentry entries[], int x);
void tLocalContent(void);
void tLocalInputContent(void);
void tLocalList(void);
void NewtLocal(unsigned uMode);
void ModtLocal(void);
void CreatetLocal(void);
void DeletetLocal(void);
void ExttLocalGetHook(entry gentries[], int x);

//tJob
int tJobCommands(pentry entries[], int x);
void tJob(const char *results);
void ProcesstJobVars(pentry entries[], int x);
void tJobContent(void);
void tJobInputContent(void);
void tJobList(void);
void NewtJob(unsigned uMode);
void ModtJob(void);
void CreatetJob(void);
void DeletetJob(void);
void ExttJobGetHook(entry gentries[], int x);

//tLog
int tLogCommands(pentry entries[], int x);
void tLog(const char *results);
void ProcesstLogVars(pentry entries[], int x);
void tLogContent(void);
void tLogInputContent(void);
void tLogList(void);
void NewtLog(unsigned uMode);
void ModtLog(void);
void CreatetLog(void);
void DeletetLog(void);
void ExttLogGetHook(entry gentries[], int x);

//tUsage
int tUsageCommands(pentry entries[], int x);
void tUsage(const char *results);
void ProcesstUsageVars(pentry entries[], int x);
void tUsageContent(void);
void tUsageInputContent(void);
void tUsageList(void);
void NewtUsage(unsigned uMode);
void ModtUsage(void);
void CreatetUsage(void);
void DeletetUsage(void);
void ExttUsageGetHook(entry gentries[], int x);

//tConfiguration
int tConfigurationCommands(pentry entries[], int x);
void tConfiguration(const char *results);
void ProcesstConfigurationVars(pentry entries[], int x);
void tConfigurationContent(void);
void tConfigurationInputContent(void);
void tConfigurationList(void);
void NewtConfiguration(unsigned uMode);
void ModtConfiguration(void);
void CreatetConfiguration(void);
void DeletetConfiguration(void);
void ExttConfigurationGetHook(entry gentries[], int x);

//tServer
int tServerCommands(pentry entries[], int x);
void tServer(const char *results);
void ProcesstServerVars(pentry entries[], int x);
void tServerContent(void);
void tServerInputContent(void);
void tServerList(void);
void NewtServer(unsigned uMode);
void ModtServer(void);
void CreatetServer(void);
void DeletetServer(void);
void ExttServerGetHook(entry gentries[], int x);

//tJobStatus
int tJobStatusCommands(pentry entries[], int x);
void tJobStatus(const char *results);
void ProcesstJobStatusVars(pentry entries[], int x);
void tJobStatusContent(void);
void tJobStatusInputContent(void);
void tJobStatusList(void);
void NewtJobStatus(unsigned uMode);
void ModtJobStatus(void);
void CreatetJobStatus(void);
void DeletetJobStatus(void);
void ExttJobStatusGetHook(entry gentries[], int x);

//tStatus
int tStatusCommands(pentry entries[], int x);
void tStatus(const char *results);
void ProcesstStatusVars(pentry entries[], int x);
void tStatusContent(void);
void tStatusInputContent(void);
void tStatusList(void);
void NewtStatus(unsigned uMode);
void ModtStatus(void);
void CreatetStatus(void);
void DeletetStatus(void);
void ExttStatusGetHook(entry gentries[], int x);

//tHDQuota
int tHDQuotaCommands(pentry entries[], int x);
void tHDQuota(const char *results);
void ProcesstHDQuotaVars(pentry entries[], int x);
void tHDQuotaContent(void);
void tHDQuotaInputContent(void);
void tHDQuotaList(void);
void NewtHDQuota(unsigned uMode);
void ModtHDQuota(void);
void CreatetHDQuota(void);
void DeletetHDQuota(void);
void ExttHDQuotaGetHook(entry gentries[], int x);

//tTrafficQuota
int tTrafficQuotaCommands(pentry entries[], int x);
void tTrafficQuota(const char *results);
void ProcesstTrafficQuotaVars(pentry entries[], int x);
void tTrafficQuotaContent(void);
void tTrafficQuotaInputContent(void);
void tTrafficQuotaList(void);
void NewtTrafficQuota(unsigned uMode);
void ModtTrafficQuota(void);
void CreatetTrafficQuota(void);
void DeletetTrafficQuota(void);
void ExttTrafficQuotaGetHook(entry gentries[], int x);

//tMailFilter
int tMailFilterCommands(pentry entries[], int x);
void tMailFilter(const char *results);
void ProcesstMailFilterVars(pentry entries[], int x);
void tMailFilterContent(void);
void tMailFilterInputContent(void);
void tMailFilterList(void);
void NewtMailFilter(unsigned uMode);
void ModtMailFilter(void);
void CreatetMailFilter(void);
void DeletetMailFilter(void);
void ExttMailFilterGetHook(entry gentries[], int x);

//tClient
int tClientCommands(pentry entries[], int x);
void tClient(const char *results);
void ProcesstClientVars(pentry entries[], int x);
void tClientContent(void);
void tClientInputContent(void);
void tClientList(void);
void NewtClient(unsigned uMode);
void ModtClient(void);
void CreatetClient(void);
void DeletetClient(void);
void ExttClientGetHook(entry gentries[], int x);

//tAuthorize
int tAuthorizeCommands(pentry entries[], int x);
void tAuthorize(const char *results);
void ProcesstAuthorizeVars(pentry entries[], int x);
void tAuthorizeContent(void);
void tAuthorizeInputContent(void);
void tAuthorizeList(void);
void NewtAuthorize(unsigned uMode);
void ModtAuthorize(void);
void CreatetAuthorize(void);
void DeletetAuthorize(void);
void ExttAuthorizeGetHook(entry gentries[], int x);