Github
/
FTL
mirror of
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Improve code based on a full static analysis of our code. There are no real bugs, nowever, we use the obtained knowledge to improve the code such as unify declarations and function definitions, reduce the scope of local variables, mark many function arguments and local variables const when they are, fix the type expected by %x and fix one if-condition 

Signed-off-by: DL6ER <dl6er@dl6er.de>
This commit is contained in:
DL6ER 2019-04-15 21:29:50 +02:00
parent 320a9c89e5
commit 6fcbce6c34
No known key found for this signature in database
GPG Key ID: FB60471F0575164A
23 changed files with 334 additions and 342 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

111
api.c
View File

@ -19,8 +19,8 @@
/* qsort comparision function (count field), sort ASC */
static int __attribute__((pure)) cmpasc(const void *a, const void *b)
{
int *elem1 = (int*)a;
int *elem2 = (int*)b;
const int *elem1 = (int*)a;
const int *elem2 = (int*)b;
if (elem1[1] < elem2[1])
return -1;
@ -33,8 +33,8 @@ static int __attribute__((pure)) cmpasc(const void *a, const void *b)
// qsort subroutine, sort DESC
static int __attribute__((pure)) cmpdesc(const void *a, const void *b)
{
int *elem1 = (int*)a;
int *elem2 = (int*)b;
const int *elem1 = (int*)a;
const int *elem2 = (int*)b;
if (elem1[1] > elem2[1])
return -1;
@ -44,10 +44,10 @@ static int __attribute__((pure)) cmpdesc(const void *a, const void *b)
return 0;
}
void getStats(int *sock)
void getStats(const int *sock)
{
int blocked = counters->blocked;
int total = counters->queries;
const int blocked = counters->blocked;
const int total = counters->queries;
float percentage = 0.0f;
// Avoid 1/0 condition
@ -111,7 +111,7 @@ void getStats(int *sock)
pack_uint8(*sock, blockingstatus);
}
void getOverTime(int *sock)
void getOverTime(const int *sock)
{
int i, from = 0, until = OVERTIME_SLOTS;
bool found = false;
@ -171,12 +171,12 @@ void getOverTime(int *sock)
}
}
void getTopDomains(const char *client_message, int *sock)
void getTopDomains(const char *client_message, const int *sock)
{
int i, temparray[counters->domains][2], count=10, num;
bool blocked, audit = false, asc = false;
bool audit = false, asc = false;
blocked = command(client_message, ">top-ads");
const bool blocked = command(client_message, ">top-ads");
// Exit before processing any data if requested via config setting
get_privacy_level(NULL);
@ -224,7 +224,7 @@ void getTopDomains(const char *client_message, int *sock)
// Get filter
char * filter = read_setupVarsconf("API_QUERY_LOG_SHOW");
const char* filter = read_setupVarsconf("API_QUERY_LOG_SHOW");
bool showpermitted = true, showblocked = true;
if(filter != NULL)
{
@ -264,7 +264,7 @@ void getTopDomains(const char *client_message, int *sock)
for(i=0; i < counters->domains; i++)
{
// Get sorted indices
int j = temparray[i][0];
const int j = temparray[i][0];
validate_access("domains", j, true, __LINE__, __FUNCTION__, __FILE__);
// Skip this domain if there is a filter on it
@ -333,7 +333,7 @@ void getTopDomains(const char *client_message, int *sock)
clearSetupVarsArray();
}
void getTopClients(const char *client_message, int *sock)
void getTopClients(const char *client_message, const int *sock)
{
int i, temparray[counters->clients][2], count=10, num;
@ -389,7 +389,7 @@ void getTopClients(const char *client_message, int *sock)
qsort(temparray, counters->clients, sizeof(int[2]), cmpdesc);
// Get clients which the user doesn't want to see
char * excludeclients = read_setupVarsconf("API_EXCLUDE_CLIENTS");
const char* excludeclients = read_setupVarsconf("API_EXCLUDE_CLIENTS");
if(excludeclients != NULL)
{
getSetupVarsArray(excludeclients);
@ -405,8 +405,8 @@ void getTopClients(const char *client_message, int *sock)
for(i=0; i < counters->clients; i++)
{
// Get sorted indices and counter values (may be either total or blocked count)
int j = temparray[i][0];
int ccount = temparray[i][1];
const int j = temparray[i][0];
const int ccount = temparray[i][1];
validate_access("clients", j, true, __LINE__, __FUNCTION__, __FILE__);
// Skip this client if there is a filter on it
@ -447,7 +447,7 @@ void getTopClients(const char *client_message, int *sock)
}
void getForwardDestinations(const char *client_message, int *sock)
void getForwardDestinations(const char *client_message, const int *sock)
{
bool sort = true;
int temparray[counters->forwarded][2], totalqueries = 0;
@ -538,17 +538,17 @@ void getForwardDestinations(const char *client_message, int *sock)
}
void getQueryTypes(int *sock)
void getQueryTypes(const int *sock)
{
int i,total = 0;
for(i=0; i < TYPE_MAX-1; i++)
int total = 0;
for(int i=0; i < TYPE_MAX-1; i++)
total += counters->querytype[i];
float percentage[TYPE_MAX-1] = { 0.0 };
// Prevent floating point exceptions by checking if the divisor is != 0
if(total > 0)
for(i=0; i < TYPE_MAX-1; i++)
for(int i=0; i < TYPE_MAX-1; i++)
percentage[i] = 1e2f*counters->querytype[i]/total;
if(istelnet[*sock]) {
@ -576,7 +576,7 @@ void getQueryTypes(int *sock)
const char *querytypes[8] = {"A","AAAA","ANY","SRV","SOA","PTR","TXT","UNKN"};
void getAllQueries(const char *client_message, int *sock)
void getAllQueries(const char *client_message, const int *sock)
{
// Exit before processing any data if requested via config setting
get_privacy_level(NULL);
@ -631,10 +631,9 @@ void getAllQueries(const char *client_message, int *sock)
else
{
// Iterate through all known forward destinations
int i;
validate_access("forwards", MAX(0,counters->forwarded-1), true, __LINE__, __FUNCTION__, __FILE__);
forwarddestid = -3;
for(i = 0; i < counters->forwarded; i++)
for(int i = 0; i < counters->forwarded; i++)
{
// Try to match the requested string against their IP addresses and
// (if available) their host names
@ -664,9 +663,8 @@ void getAllQueries(const char *client_message, int *sock)
sscanf(client_message, ">getallqueries-domain %255s", domainname);
filterdomainname = true;
// Iterate through all known domains
int i;
validate_access("domains", MAX(0,counters->domains-1), true, __LINE__, __FUNCTION__, __FILE__);
for(i = 0; i < counters->domains; i++)
for(int i = 0; i < counters->domains; i++)
{
// Try to match the requested string
if(strcmp(getstr(domains[i].domainpos), domainname) == 0)
@ -692,9 +690,8 @@ void getAllQueries(const char *client_message, int *sock)
sscanf(client_message, ">getallqueries-client %255s", clientname);
filterclientname = true;
// Iterate through all known clients
int i;
validate_access("clients", MAX(0,counters->clients-1), true, __LINE__, __FUNCTION__, __FILE__);
for(i = 0; i < counters->clients; i++)
for(int i = 0; i < counters->clients; i++)
{
// Try to match the requested string
if(strcmp(getstr(clients[i].ippos), clientname) == 0 ||
@ -742,8 +739,8 @@ void getAllQueries(const char *client_message, int *sock)
}
clearSetupVarsArray();
int i;
for(i=ibeg; i < counters->queries; i++)
// Main loop
for(int i=ibeg; i < counters->queries; i++)
{
validate_access("queries", i, true, __LINE__, __FUNCTION__, __FILE__);
// Check if this query has been create while in maximum privacy mode
@ -845,7 +842,7 @@ void getAllQueries(const char *client_message, int *sock)
free(forwarddest);
}
void getRecentBlocked(const char *client_message, int *sock)
void getRecentBlocked(const char *client_message, const int *sock)
{
int num=1;
@ -883,7 +880,7 @@ void getRecentBlocked(const char *client_message, int *sock)
}
}
void getClientID(int *sock)
void getClientID(const int *sock)
{
if(istelnet[*sock])
ssend(*sock,"%i\n", *sock);
@ -891,11 +888,11 @@ void getClientID(int *sock)
pack_int32(*sock, *sock);
}
void getQueryTypesOverTime(int *sock)
void getQueryTypesOverTime(const int *sock)
{
int i, from = -1, until = OVERTIME_SLOTS;
int from = -1, until = OVERTIME_SLOTS;
time_t mintime = overTime[0].timestamp;
for(i = 0; i < OVERTIME_SLOTS; i++)
for(int i = 0; i < OVERTIME_SLOTS; i++)
{
if((overTime[i].total > 0 || overTime[i].blocked > 0) && overTime[i].timestamp >= mintime)
{
@ -905,7 +902,7 @@ void getQueryTypesOverTime(int *sock)
}
// End with last non-empty overTime slot
for(i = 0; i < OVERTIME_SLOTS; i++)
for(int i = 0; i < OVERTIME_SLOTS; i++)
{
if(overTime[i].timestamp >= time(NULL))
{
@ -918,7 +915,7 @@ void getQueryTypesOverTime(int *sock)
if(from < 0)
return;
for(i = from; i < until; i++)
for(int i = from; i < until; i++)
{
float percentageIPv4 = 0.0, percentageIPv6 = 0.0;
int sum = overTime[i].querytypedata[0] + overTime[i].querytypedata[1];
@ -938,7 +935,7 @@ void getQueryTypesOverTime(int *sock)
}
}
void getVersion(int *sock)
void getVersion(const int *sock)
{
const char * commit = GIT_HASH;
const char * tag = GIT_TAG;
@ -987,7 +984,7 @@ void getVersion(int *sock)
}
}
void getDBstats(int *sock)
void getDBstats(const int *sock)
{
// Get file details
struct stat st;
@ -1014,9 +1011,9 @@ void getDBstats(int *sock)
}
}
void getClientsOverTime(int *sock)
void getClientsOverTime(const int *sock)
{
int i, sendit = -1, until = OVERTIME_SLOTS;
int sendit = -1, until = OVERTIME_SLOTS;
// Exit before processing any data if requested via config setting
get_privacy_level(NULL);
@ -1024,7 +1021,7 @@ void getClientsOverTime(int *sock)
return;
// Find minimum ID to send
for(i = 0; i < OVERTIME_SLOTS; i++)
for(int i = 0; i < OVERTIME_SLOTS; i++)
{
if((overTime[i].total > 0 || overTime[i].blocked > 0) &&
overTime[i].timestamp >= overTime[0].timestamp)
@ -1037,7 +1034,7 @@ void getClientsOverTime(int *sock)
return;
// Find minimum ID to send
for(i = 0; i < OVERTIME_SLOTS; i++)
for(int i = 0; i < OVERTIME_SLOTS; i++)
{
if(overTime[i].timestamp >= time(NULL))
{
@ -1058,7 +1055,7 @@ void getClientsOverTime(int *sock)
{
getSetupVarsArray(excludeclients);
for(i=0; i < counters->clients; i++)
for(int i=0; i < counters->clients; i++)
{
validate_access("clients", i, true, __LINE__, __FUNCTION__, __FILE__);
// Check if this client should be skipped
@ -1069,7 +1066,7 @@ void getClientsOverTime(int *sock)
}
// Main return loop
for(i = sendit; i < until; i++)
for(int i = sendit; i < until; i++)
{
if(istelnet[*sock])
ssend(*sock, "%li", overTime[i].timestamp);
@ -1082,7 +1079,7 @@ void getClientsOverTime(int *sock)
if(skipclient[j])
continue;
int thisclient = clients[j].overTime[i];
const int thisclient = clients[j].overTime[i];
if(istelnet[*sock])
ssend(*sock, " %i", thisclient);
@ -1100,10 +1097,8 @@ void getClientsOverTime(int *sock)
clearSetupVarsArray();
}
void getClientNames(int *sock)
void getClientNames(const int *sock)
{
int i;
// Exit before processing any data if requested via config setting
get_privacy_level(NULL);
if(config.privacylevel >= PRIVACY_HIDE_DOMAINS_CLIENTS)
@ -1121,7 +1116,7 @@ void getClientNames(int *sock)
{
getSetupVarsArray(excludeclients);
for(i=0; i < counters->clients; i++)
for(int i=0; i < counters->clients; i++)
{
validate_access("clients", i, true, __LINE__, __FUNCTION__, __FILE__);
// Check if this client should be skipped
@ -1132,7 +1127,7 @@ void getClientNames(int *sock)
}
// Loop over clients to generate output to be sent to the client
for(i = 0; i < counters->clients; i++)
for(int i = 0; i < counters->clients; i++)
{
validate_access("clients", i, true, __LINE__, __FUNCTION__, __FILE__);
if(skipclient[i])
@ -1153,15 +1148,14 @@ void getClientNames(int *sock)
clearSetupVarsArray();
}
void getUnknownQueries(int *sock)
void getUnknownQueries(const int *sock)
{
// Exit before processing any data if requested via config setting
get_privacy_level(NULL);
if(config.privacylevel >= PRIVACY_HIDE_DOMAINS)
return;
int i;
for(i=0; i < counters->queries; i++)
for(int i=0; i < counters->queries; i++)
{
validate_access("queries", i, true, __LINE__, __FUNCTION__, __FILE__);
if(queries[i].status != QUERY_UNKNOWN && queries[i].complete) continue;
@ -1202,7 +1196,7 @@ void getUnknownQueries(int *sock)
}
}
void getDomainDetails(const char *client_message, int *sock)
void getDomainDetails(const char *client_message, const int *sock)
{
// Get domain name
char domain[128];
@ -1212,8 +1206,7 @@ void getDomainDetails(const char *client_message, int *sock)
return;
}
int i;
for(i = 0; i < counters->domains; i++)
for(int i = 0; i < counters->domains; i++)
{
validate_access("domains", i, true, __LINE__, __FUNCTION__, __FILE__);
if(strcmp(getstr(domains[i].domainpos), domain) == 0)
@ -1224,7 +1217,7 @@ void getDomainDetails(const char *client_message, int *sock)
const char *regexstatus;
if(domains[i].regexmatch == REGEX_BLOCKED)
regexstatus = "blocked";
if(domains[i].regexmatch == REGEX_NOTBLOCKED)
else if(domains[i].regexmatch == REGEX_NOTBLOCKED)
regexstatus = "not blocked";
else
regexstatus = "unknown";

54
api.h
View File

@ -9,36 +9,36 @@
* Please see LICENSE file for your rights under this license. */
// Statistic methods
void getStats(int *sock);
void getOverTime(int *sock);
void getTopDomains(const char *client_message, int *sock);
void getTopClients(const char *client_message, int *sock);
void getForwardDestinations(const char *client_message, int *sock);
void getQueryTypes(int *sock);
void getAllQueries(const char *client_message, int *sock);
void getRecentBlocked(const char *client_message, int *sock);
void getQueryTypesOverTime(int *sock);
void getClientsOverTime(int *sock);
void getClientNames(int *sock);
void getDomainDetails(const char *client_message, int *sock);
void getStats(const int *sock);
void getOverTime(const int *sock);
void getTopDomains(const char *client_message, const int *sock);
void getTopClients(const char *client_message, const int *sock);
void getForwardDestinations(const char *client_message, const int *sock);
void getQueryTypes(const int *sock);
void getAllQueries(const char *client_message, const int *sock);
void getRecentBlocked(const char *client_message, const int *sock);
void getQueryTypesOverTime(const int *sock);
void getClientsOverTime(const int *sock);
void getClientNames(const int *sock);
void getDomainDetails(const char *client_message, const int *sock);
// FTL methods
void getClientID(int *sock);
void getVersion(int *sock);
void getDBstats(int *sock);
void getUnknownQueries(int *sock);
void getClientID(const int *sock);
void getVersion(const int *sock);
void getDBstats(const int *sock);
void getUnknownQueries(const int *sock);
// DNS resolver methods (dnsmasq_interface.c)
void getCacheInformation(int *sock);
void getCacheInformation(const int *sock);
// MessagePack serialization helpers
void pack_eom(int sock);
void pack_bool(int sock, bool value);
void pack_uint8(int sock, uint8_t value);
void pack_uint64(int sock, uint64_t value);
void pack_int32(int sock, int32_t value);
void pack_int64(int sock, int64_t value);
void pack_float(int sock, float value);
bool pack_fixstr(int sock, const char *string);
bool pack_str32(int sock, const char *string);
void pack_map16_start(int sock, uint16_t length);
void pack_eom(const int sock);
void pack_bool(const int sock, const bool value);
void pack_uint8(const int sock, const uint8_t value);
void pack_uint64(const int sock, const uint64_t value);
void pack_int32(const int sock, const int32_t value);
void pack_int64(const int sock, const int64_t value);
void pack_float(const int sock, const float value);
bool pack_fixstr(const int sock, const char *string);
bool pack_str32(const int sock, const char *string);
void pack_map16_start(const int sock, const uint16_t length);

2
args.c
View File

@ -52,7 +52,6 @@ void parse_args(int argc, char* argv[])
strcmp(argv[i], "version") == 0 ||
strcmp(argv[i], "--version") == 0)
{
const char * commit = GIT_HASH;
const char * tag = GIT_TAG;
if(strlen(tag) > 1)
{
@ -60,6 +59,7 @@ void parse_args(int argc, char* argv[])
}
else
{
const char * commit = GIT_HASH;
char hash[8];
// Extract first 7 characters of the hash
strncpy(hash, commit, 7); hash[7] = 0;

2
capabilities.c
View File

@ -18,7 +18,7 @@ static const unsigned int capabilityIDs[] = { CAP_CHOWN , CAP_DAC_OVERRIDE ,
static const char* capabilityNames[] = {"CAP_CHOWN", "CAP_DAC_OVERRIDE", "CAP_DAC_READ_SEARCH", "CAP_FOWNER", "CAP_FSETID", "CAP_KILL", "CAP_SETGID", "CAP_SETUID", "CAP_SETPCAP", "CAP_LINUX_IMMUTABLE", "CAP_NET_BIND_SERVICE", "CAP_NET_BROADCAST", "CAP_NET_ADMIN", "CAP_NET_RAW", "CAP_IPC_LOCK", "CAP_IPC_OWNER", "CAP_SYS_MODULE", "CAP_SYS_RAWIO", "CAP_SYS_CHROOT", "CAP_SYS_PTRACE", "CAP_SYS_PACCT", "CAP_SYS_ADMIN", "CAP_SYS_BOOT", "CAP_SYS_NICE", "CAP_SYS_RESOURCE", "CAP_SYS_TIME", "CAP_SYS_TTY_CONFIG", "CAP_MKNOD", "CAP_LEASE", "CAP_AUDIT_WRITE", "CAP_AUDIT_CONTROL", "CAP_SETFCAP", "CAP_MAC_OVERRIDE", "CAP_MAC_ADMIN", "CAP_SYSLOG", "CAP_WAKE_ALARM", "CAP_BLOCK_SUSPEND", "CAP_AUDIT_READ"};
static const unsigned int numCaps = sizeof(capabilityIDs) / sizeof(const unsigned int);
bool check_capabilities()
bool check_capabilities(void)
{
// First assume header version 1
int capsize = 1; // VFS_CAP_U32_1

4
config.c
View File

@ -13,7 +13,7 @@
ConfigStruct config;
static char *parse_FTLconf(FILE *fp, const char * key);
static void release_config_memory(void);
void getpath(FILE* fp, const char *option, const char *defaultloc, char **pointer);
static void getpath(FILE* fp, const char *option, const char *defaultloc, char **pointer);
char *conflinebuffer = NULL;
@ -334,7 +334,7 @@ void read_FTLconf(void)
fclose(fp);
}
void getpath(FILE* fp, const char *option, const char *defaultloc, char **pointer)
static void getpath(FILE* fp, const char *option, const char *defaultloc, char **pointer)
{
// This subroutine is used to read paths from pihole-FTL.conf
// fp: File pointer to opened and readable config file

19
daemon.c
View File

@ -14,11 +14,8 @@ struct timeval t0[NUMTIMERS];
void go_daemon(void)
{
pid_t process_id = 0;
pid_t sid = 0;
// Create child process
process_id = fork();
pid_t process_id = fork();
// Indication of fork() failure
if (process_id < 0)
@ -41,7 +38,7 @@ void go_daemon(void)
//set new session
// creates a session and sets the process group ID
sid = setsid();
const pid_t sid = setsid();
if(sid < 0)
{
// Return failure
@ -80,7 +77,7 @@ void go_daemon(void)
// Closing stdin, stdout and stderr is handled by dnsmasq
}
void timer_start(int i)
void timer_start(const int i)
{
if(i >= NUMTIMERS)
{
@ -90,7 +87,7 @@ void timer_start(int i)
gettimeofday(&t0[i], 0);
}
double timer_elapsed_msec(int i)
double timer_elapsed_msec(const int i)
{
if(i >= NUMTIMERS)
{
@ -102,7 +99,7 @@ double timer_elapsed_msec(int i)
return (t1.tv_sec - t0[i].tv_sec) * 1000.0f + (t1.tv_usec - t0[i].tv_usec) / 1000.0f;
}
void sleepms(int milliseconds)
void sleepms(const int milliseconds)
{
struct timeval tv;
tv.tv_sec = milliseconds / 1000;
@ -113,7 +110,7 @@ void sleepms(int milliseconds)
void savepid(void)
{
FILE *f;
pid_t pid = getpid();
const pid_t pid = getpid();
if((f = fopen(FTLfiles.pid, "w+")) == NULL)
{
logg("WARNING: Unable to write PID to file.");
@ -143,8 +140,8 @@ char *getUserName(void)
char * name;
// the getpwuid() function shall search the user database for an entry with a matching uid
// the geteuid() function shall return the effective user ID of the calling process - this is used as the search criteria for the getpwuid() function
uid_t euid = geteuid();
struct passwd *pw = getpwuid(euid);
const uid_t euid = geteuid();
const struct passwd *pw = getpwuid(euid);
if(pw)
{
name = strdup(pw->pw_name);

38
database.c
View File

@ -19,8 +19,8 @@ long int lastdbindex = 0;
static pthread_mutex_t dblock;
bool db_set_counter(unsigned int ID, int value);
int db_get_FTL_property(unsigned int ID);
static bool db_set_counter(const unsigned int ID, const int value);
static int db_get_FTL_property(const unsigned int ID);
static void check_database(int rc)
{
@ -265,7 +265,7 @@ void db_init(void)
database = true;
}
int db_get_FTL_property(unsigned int ID)
static int db_get_FTL_property(const unsigned int ID)
{
// Prepare SQL statement
char* querystr = NULL;
@ -283,17 +283,17 @@ int db_get_FTL_property(unsigned int ID)
return value;
}
bool db_set_FTL_property(unsigned int ID, int value)
bool db_set_FTL_property(const unsigned int ID, const int value)
{
return dbquery("INSERT OR REPLACE INTO ftl (id, value) VALUES ( %u, %i );", ID, value);
}
bool db_set_counter(unsigned int ID, int value)
static bool db_set_counter(const unsigned int ID, const int value)
{
return dbquery("INSERT OR REPLACE INTO counters (id, value) VALUES ( %u, %i );", ID, value);
}
static bool db_update_counters(int total, int blocked)
static bool db_update_counters(const int total, const int blocked)
{
if(!dbquery("UPDATE counters SET value = value + %i WHERE id = %i;", total, DB_TOTALQUERIES))
return false;
@ -429,7 +429,7 @@ void save_to_DB(void)
unsigned int saved = 0, saved_error = 0;
long int i;
sqlite3_stmt* stmt;
sqlite3_stmt* stmt = NULL;
// Get last ID stored in the database
sqlite3_int64 lastID = last_ID_in_DB();
@ -599,7 +599,7 @@ static void delete_old_queries_in_DB(void)
}
// Get how many rows have been affected (deleted)
int affected = sqlite3_changes(db);
const int affected = sqlite3_changes(db);
// Print final message only if there is a difference
if((config.debug & DEBUG_DATABASE) || affected)
@ -674,8 +674,8 @@ void read_data_from_DB(void)
// Prepare request
char *rstr = NULL;
// Get time stamp 24 hours in the past
time_t now = time(NULL);
time_t mintime = now - config.maxlogage;
const time_t now = time(NULL);
const time_t mintime = now - config.maxlogage;
int rc = asprintf(&rstr, "SELECT * FROM queries WHERE timestamp >= %li", mintime);
if(rc < 1)
{
@ -686,7 +686,7 @@ void read_data_from_DB(void)
if(config.debug & DEBUG_DATABASE) logg("%s", rstr);
// Prepare SQLite3 statement
sqlite3_stmt* stmt;
sqlite3_stmt* stmt = NULL;
rc = sqlite3_prepare_v2(db, rstr, -1, &stmt, NULL);
if( rc ){
logg("read_data_from_DB() - SQL error prepare (%i): %s", rc, sqlite3_errmsg(db));
@ -698,8 +698,8 @@ void read_data_from_DB(void)
// Loop through returned database rows
while((rc = sqlite3_step(stmt)) == SQLITE_ROW)
{
sqlite3_int64 dbid = sqlite3_column_int64(stmt, 0);
time_t queryTimeStamp = sqlite3_column_int(stmt, 1);
const sqlite3_int64 dbid = sqlite3_column_int64(stmt, 0);
const time_t queryTimeStamp = sqlite3_column_int(stmt, 1);
// 1483228800 = 01/01/2017 @ 12:00am (UTC)
if(queryTimeStamp < 1483228800)
{
@ -712,7 +712,7 @@ void read_data_from_DB(void)
continue;
}
int type = sqlite3_column_int(stmt, 2);
const int type = sqlite3_column_int(stmt, 2);
if(type < TYPE_A || type >= TYPE_MAX)
{
logg("DB warn: TYPE should not be %i", type);
@ -725,7 +725,7 @@ void read_data_from_DB(void)
continue;
}
int status = sqlite3_column_int(stmt, 3);
const int status = sqlite3_column_int(stmt, 3);
if(status < QUERY_UNKNOWN || status > QUERY_EXTERNAL_BLOCKED_NXRA)
{
logg("DB warn: STATUS should be within [%i,%i] but is %i", QUERY_UNKNOWN, QUERY_EXTERNAL_BLOCKED_NXRA, status);
@ -768,15 +768,15 @@ void read_data_from_DB(void)
}
// Obtain IDs only after filtering which queries we want to keep
int timeidx = getOverTimeID(queryTimeStamp);
int domainID = findDomainID(domain);
int clientID = findClientID(client, true);
const int timeidx = getOverTimeID(queryTimeStamp);
const int domainID = findDomainID(domain);
const int clientID = findClientID(client, true);
// Ensure we have enough space in the queries struct
memory_check(QUERIES);
// Set index for this query
int queryIndex = counters->queries;
const int queryIndex = counters->queries;
// Store this query in memory
validate_access("queries", queryIndex, false, __LINE__, __FUNCTION__, __FILE__);

10
datastructure.c
View File

@ -17,7 +17,7 @@ void strtolower(char *str)
while(str[i]){ str[i] = tolower(str[i]); i++; }
}
int findForwardID(const char * forward, bool count)
int findForwardID(const char * forward, const bool count)
{
int i, forwardID = -1;
if(counters->forwarded > 0)
@ -106,7 +106,7 @@ int findDomainID(const char *domain)
return domainID;
}
int findClientID(const char *client, bool count)
int findClientID(const char *client, const bool count)
{
// Compare content of client against known client IP addresses
if(counters->clients > 0)
@ -181,7 +181,7 @@ bool isValidIPv6(const char *addr)
// Privacy-level sensitive subroutine that returns the domain name
// only when appropriate for the requested query
const char *getDomainString(int queryID)
const char *getDomainString(const int queryID)
{
if(queries[queryID].privacylevel < PRIVACY_HIDE_DOMAINS)
{
@ -194,7 +194,7 @@ const char *getDomainString(int queryID)
// Privacy-level sensitive subroutine that returns the client IP
// only when appropriate for the requested query
const char *getClientIPString(int queryID)
const char *getClientIPString(const int queryID)
{
if(queries[queryID].privacylevel < PRIVACY_HIDE_DOMAINS_CLIENTS)
{
@ -207,7 +207,7 @@ const char *getClientIPString(int queryID)
// Privacy-level sensitive subroutine that returns the client host name
// only when appropriate for the requested query
const char *getClientNameString(int queryID)
const char *getClientNameString(const int queryID)
{
if(queries[queryID].privacylevel < PRIVACY_HIDE_DOMAINS_CLIENTS)
{

166
dnsmasq_interface.c
View File

@ -17,18 +17,20 @@
// Prototype of getCacheInformation()
#include "api.h"
void print_flags(unsigned int flags);
void save_reply_type(unsigned int flags, int queryID, struct timeval response);
static unsigned long converttimeval(struct timeval time) __attribute__((const));
static void block_single_domain_regex(char *domain);
static void detect_blocked_IP(unsigned short flags, const char* answer, int queryID);
static void query_externally_blocked(int i, unsigned char status);
static int findQueryID(int id);
static void print_flags(const unsigned int flags);
static void save_reply_type(const unsigned int flags, const int queryID, const struct timeval response);
static unsigned long converttimeval(const struct timeval time) __attribute__((const));
static void block_single_domain_regex(const char *domain);
static void detect_blocked_IP(const unsigned short flags, const char* answer, const int queryID);
static void query_externally_blocked(const int i, const unsigned char status);
static int findQueryID(const int id);
unsigned char* pihole_privacylevel = &config.privacylevel;
char flagnames[28][12] = {"F_IMMORTAL ", "F_NAMEP ", "F_REVERSE ", "F_FORWARD ", "F_DHCP ", "F_NEG ", "F_HOSTS ", "F_IPV4 ", "F_IPV6 ", "F_BIGNAME ", "F_NXDOMAIN ", "F_CNAME ", "F_DNSKEY ", "F_CONFIG ", "F_DS ", "F_DNSSECOK ", "F_UPSTREAM ", "F_RRNAME ", "F_SERVER ", "F_QUERY ", "F_NOERR ", "F_AUTH ", "F_DNSSEC ", "F_KEYTAG ", "F_SECSTAT ", "F_NO_RR ", "F_IPSET ", "F_NOEXTRA "};
const char flagnames[28][12] = {"F_IMMORTAL ", "F_NAMEP ", "F_REVERSE ", "F_FORWARD ", "F_DHCP ", "F_NEG ", "F_HOSTS ", "F_IPV4 ", "F_IPV6 ", "F_BIGNAME ", "F_NXDOMAIN ", "F_CNAME ", "F_DNSKEY ", "F_CONFIG ", "F_DS ", "F_DNSSECOK ", "F_UPSTREAM ", "F_RRNAME ", "F_SERVER ", "F_QUERY ", "F_NOERR ", "F_AUTH ", "F_DNSSEC ", "F_KEYTAG ", "F_SECSTAT ", "F_NO_RR ", "F_IPSET ", "F_NOEXTRA "};
void _FTL_new_query(unsigned int flags, char *name, struct all_addr *addr, char *types, int id, char type, const char* file, const int line)
void _FTL_new_query(const unsigned int flags, const char *name, const struct all_addr *addr,
const char *types, const int id, const char type,
const char* file, const int line)
{
// Don't analyze anything if in PRIVACY_NOSTATS mode
if(config.privacylevel >= PRIVACY_NOSTATS)
@ -38,7 +40,7 @@ void _FTL_new_query(unsigned int flags, char *name, struct all_addr *addr, char
lock_shm();
// Get timestamp
time_t querytimestamp = time(NULL);
const time_t querytimestamp = time(NULL);
// Save request time
struct timeval request;
@ -78,7 +80,7 @@ void _FTL_new_query(unsigned int flags, char *name, struct all_addr *addr, char
// Ensure we have enough space in the queries struct
memory_check(QUERIES);
int queryID = counters->queries;
const int queryID = counters->queries;
// Convert domain to lower case
char *domain = strdup(name);
@ -124,7 +126,7 @@ void _FTL_new_query(unsigned int flags, char *name, struct all_addr *addr, char
counters->querytype[querytype-1]++;
// Update overTime
unsigned int timeidx = getOverTimeID(querytimestamp);
const unsigned int timeidx = getOverTimeID(querytimestamp);
overTime[timeidx].querytypedata[querytype-1]++;
// Skip rest of the analysis if this query is not of type A or AAAA
@ -141,10 +143,10 @@ void _FTL_new_query(unsigned int flags, char *name, struct all_addr *addr, char
}
// Go through already knows domains and see if it is one of them
int domainID = findDomainID(domain);
const int domainID = findDomainID(domain);
// Go through already knows clients and see if it is one of them
int clientID = findClientID(client, true);
const int clientID = findClientID(client, true);
// Save everything
validate_access("queries", queryID, false, __LINE__, __FUNCTION__, __FILE__);
@ -223,7 +225,7 @@ void _FTL_new_query(unsigned int flags, char *name, struct all_addr *addr, char
unlock_shm();
}
static int findQueryID(int id)
static int findQueryID(const int id)
{
// Loop over all queries - we loop in reverse order (start from the most recent query and
// continuously walk older queries while trying to find a match. Ideally, we should always
@ -234,8 +236,8 @@ static int findQueryID(int id)
// MAX(0, a) is used to return 0 in case a is negative (negative array indices are harmful)
// Validate access only once for the maximum index (all lower will work)
int until = MAX(0, counters->queries-MAXITER);
int start = MAX(0, counters->queries-1);
const int until = MAX(0, counters->queries-MAXITER);
const int start = MAX(0, counters->queries-1);
validate_access("queries", until, false, __LINE__, __FUNCTION__, __FILE__);
// Check UUIDs of queries
@ -247,7 +249,8 @@ static int findQueryID(int id)
return -1;
}
void _FTL_forwarded(unsigned int flags, char *name, struct all_addr *addr, int id, const char* file, const int line)
void _FTL_forwarded(const unsigned int flags, const char *name, const struct all_addr *addr, const int id,
const char* file, const int line)
{
// Don't analyze anything if in PRIVACY_NOSTATS mode
if(config.privacylevel >= PRIVACY_NOSTATS)
@ -270,7 +273,7 @@ void _FTL_forwarded(unsigned int flags, char *name, struct all_addr *addr, int i
if(config.debug & DEBUG_QUERIES) logg("**** forwarded %s to %s (ID %i, %s:%i)", name, forward, id, file, line);
// Save status and forwardID in corresponding query identified by dnsmasq's ID
int i = findQueryID(id);
const int i = findQueryID(id);
if(i < 0)
{
// This may happen e.g. if the original query was a PTR query or "pi.hole"
@ -295,10 +298,10 @@ void _FTL_forwarded(unsigned int flags, char *name, struct all_addr *addr, int i
// Get ID of forward destination, create new forward destination record
// if not found in current data structure
int forwardID = findForwardID(forward, true);
const int forwardID = findForwardID(forward, true);
queries[i].forwardID = forwardID;
unsigned int timeidx = queries[i].timeidx;
const unsigned int timeidx = queries[i].timeidx;
if(queries[i].status == QUERY_CACHE)
{
@ -390,7 +393,8 @@ void FTL_dnsmasq_reload(void)
check_capabilities();
}
void _FTL_reply(unsigned short flags, char *name, struct all_addr *addr, int id, const char* file, const int line)
void _FTL_reply(const unsigned short flags, const char *name, const struct all_addr *addr, const int id,
const char* file, const int line)
{
// Don't analyze anything if in PRIVACY_NOSTATS mode
if(config.privacylevel >= PRIVACY_NOSTATS)
@ -426,7 +430,7 @@ void _FTL_reply(unsigned short flags, char *name, struct all_addr *addr, int id,
gettimeofday(&response, 0);
// Save status in corresponding query identified by dnsmasq's ID
int i = findQueryID(id);
const int i = findQueryID(id);
if(i < 0)
{
// This may happen e.g. if the original query was "pi.hole"
@ -443,9 +447,9 @@ void _FTL_reply(unsigned short flags, char *name, struct all_addr *addr, int id,
}
// Determine if this reply is an exact match for the queried domain
int domainID = queries[i].domainID;
const int domainID = queries[i].domainID;
validate_access("domains", domainID, true, __LINE__, __FUNCTION__, __FILE__);
bool isExactMatch = (name != NULL && strcmp(getstr(domains[domainID].domainpos), name) == 0);
const bool isExactMatch = (name != NULL && strcmp(getstr(domains[domainID].domainpos), name) == 0);
if((flags & F_CONFIG) && isExactMatch && !queries[i].complete)
{
@ -454,7 +458,7 @@ void _FTL_reply(unsigned short flags, char *name, struct all_addr *addr, int id,
counters->unknown--;
// Get time index
unsigned int timeidx = queries[i].timeidx;
const unsigned int timeidx = queries[i].timeidx;
if(strcmp(answer, "(NXDOMAIN)") == 0 ||
strcmp(answer, "0.0.0.0") == 0 ||
@ -525,7 +529,7 @@ void _FTL_reply(unsigned short flags, char *name, struct all_addr *addr, int id,
unlock_shm();
}
static void detect_blocked_IP(unsigned short flags, const char* answer, int queryID)
static void detect_blocked_IP(const unsigned short flags, const char* answer, const int queryID)
{
if(flags & F_HOSTS)
{
@ -619,39 +623,40 @@ static void detect_blocked_IP(unsigned short flags, const char* answer, int quer
}
}
static void query_externally_blocked(int i, unsigned char status)
static void query_externally_blocked(const int queryID, const unsigned char status)
{
// If query is already known to be externally blocked,
// then we have nothing to do here
if(queries[i].status == QUERY_EXTERNAL_BLOCKED_IP ||
queries[i].status == QUERY_EXTERNAL_BLOCKED_NULL ||
queries[i].status == QUERY_EXTERNAL_BLOCKED_NXRA)
if(queries[queryID].status == QUERY_EXTERNAL_BLOCKED_IP ||
queries[queryID].status == QUERY_EXTERNAL_BLOCKED_NULL ||
queries[queryID].status == QUERY_EXTERNAL_BLOCKED_NXRA)
return;
// Get time index of this query
unsigned int timeidx = queries[i].timeidx;
const unsigned int timeidx = queries[queryID].timeidx;
// Correct counters if necessary ...
if(queries[i].status == QUERY_FORWARDED)
if(queries[queryID].status == QUERY_FORWARDED)
{
counters->forwardedqueries--;
overTime[timeidx].forwarded--;
validate_access("forwarded", queries[i].forwardID, true, __LINE__, __FUNCTION__, __FILE__);
forwarded[queries[i].forwardID].count--;
validate_access("forwarded", queries[queryID].forwardID, true, __LINE__, __FUNCTION__, __FILE__);
forwarded[queries[queryID].forwardID].count--;
}
// ... but as blocked
counters->blocked++;
overTime[timeidx].blocked++;
validate_access("domains", queries[i].domainID, true, __LINE__, __FUNCTION__, __FILE__);
domains[queries[i].domainID].blockedcount++;
validate_access("clients", queries[i].clientID, true, __LINE__, __FUNCTION__, __FILE__);
clients[queries[i].clientID].blockedcount++;
validate_access("domains", queries[queryID].domainID, true, __LINE__, __FUNCTION__, __FILE__);
domains[queries[queryID].domainID].blockedcount++;
validate_access("clients", queries[queryID].clientID, true, __LINE__, __FUNCTION__, __FILE__);
clients[queries[queryID].clientID].blockedcount++;
// Update status
queries[i].status = status;
queries[queryID].status = status;
}
void _FTL_cache(unsigned int flags, char *name, struct all_addr *addr, char *arg, int id, const char* file, const int line)
void _FTL_cache(const unsigned int flags, const char *name, const struct all_addr *addr,
const char *arg, const int id, const char* file, const int line)
{
// Don't analyze anything if in PRIVACY_NOSTATS mode
if(config.privacylevel >= PRIVACY_NOSTATS)
@ -729,8 +734,8 @@ void _FTL_cache(unsigned int flags, char *name, struct all_addr *addr, char *arg
print_flags(flags);
}
int i = findQueryID(id);
if(i < 0 || queries[i].complete)
const int queryID = findQueryID(id);
if(queryID < 0 || queries[queryID].complete)
{
// This may happen e.g. if the original query was a PTR query or "pi.hole"
// as we ignore them altogether or if the query is already complete
@ -742,25 +747,25 @@ void _FTL_cache(unsigned int flags, char *name, struct all_addr *addr, char *arg
counters->unknown--;
// Get time index
unsigned int timeidx = queries[i].timeidx;
const unsigned int timeidx = queries[queryID].timeidx;
int domainID = queries[i].domainID;
const int domainID = queries[queryID].domainID;
validate_access("domains", domainID, true, __LINE__, __FUNCTION__, __FILE__);
int clientID = queries[i].clientID;
const int clientID = queries[queryID].clientID;
validate_access("clients", clientID, true, __LINE__, __FUNCTION__, __FILE__);
// Mark this query as blocked if domain was matched by a regex
if(domains[domainID].regexmatch == REGEX_BLOCKED)
requesttype = QUERY_WILDCARD;
queries[i].status = requesttype;
queries[queryID].status = requesttype;
// Detect if returned IP indicates that this query was blocked
detect_blocked_IP(flags, dest, i);
detect_blocked_IP(flags, dest, queryID);
// Re-read requesttype as detect_blocked_IP() might have changed it
requesttype = queries[i].status;
requesttype = queries[queryID].status;
// Handle counters accordingly
switch(requesttype)
@ -786,10 +791,10 @@ void _FTL_cache(unsigned int flags, char *name, struct all_addr *addr, char *arg
}
// Save reply type and update individual reply counters
save_reply_type(flags, i, response);
save_reply_type(flags, queryID, response);
// Hereby, this query is now fully determined
queries[i].complete = true;
queries[queryID].complete = true;
}
else
{
@ -799,7 +804,7 @@ void _FTL_cache(unsigned int flags, char *name, struct all_addr *addr, char *arg
unlock_shm();
}
void _FTL_dnssec(int status, int id, const char* file, const int line)
void _FTL_dnssec(const int status, const int id, const char* file, const int line)
{
// Don't analyze anything if in PRIVACY_NOSTATS mode
if(config.privacylevel >= PRIVACY_NOSTATS)
@ -808,8 +813,8 @@ void _FTL_dnssec(int status, int id, const char* file, const int line)
// Process DNSSEC result for a domain
lock_shm();
// Search for corresponding query identified by ID
int i = findQueryID(id);
if(i < 0)
const int queryID = findQueryID(id);
if(queryID < 0)
{
// This may happen e.g. if the original query was an unhandled query type
unlock_shm();
@ -819,23 +824,23 @@ void _FTL_dnssec(int status, int id, const char* file, const int line)
// Debug logging
if(config.debug & DEBUG_QUERIES)
{
int domainID = queries[i].domainID;
const int domainID = queries[queryID].domainID;
validate_access("domains", domainID, true, __LINE__, __FUNCTION__, __FILE__);
logg("**** got DNSSEC details for %s: %i (ID %i, %s:%i)", getstr(domains[domainID].domainpos), status, id, file, line);
}
// Iterate through possible values
if(status == STAT_SECURE)
queries[i].dnssec = DNSSEC_SECURE;
queries[queryID].dnssec = DNSSEC_SECURE;
else if(status == STAT_INSECURE)
queries[i].dnssec = DNSSEC_INSECURE;
queries[queryID].dnssec = DNSSEC_INSECURE;
else
queries[i].dnssec = DNSSEC_BOGUS;
queries[queryID].dnssec = DNSSEC_BOGUS;
unlock_shm();
}
void _FTL_upstream_error(unsigned int rcode, int id, const char* file, const int line)
void _FTL_upstream_error(const unsigned int rcode, const int id, const char* file, const int line)
{
// Process upstream errors
// Queries with error are those where the RCODE
@ -848,8 +853,8 @@ void _FTL_upstream_error(unsigned int rcode, int id, const char* file, const int
// Process DNSSEC result for a domain
lock_shm();
// Search for corresponding query identified by ID
int i = findQueryID(id);
if(i < 0)
const int queryID = findQueryID(id);
if(queryID < 0)
{
// This may happen e.g. if the original query was an unhandled query type
unlock_shm();
@ -861,29 +866,29 @@ void _FTL_upstream_error(unsigned int rcode, int id, const char* file, const int
{
case SERVFAIL:
rcodestr = "SERVFAIL";
queries[i].reply = REPLY_SERVFAIL;
queries[queryID].reply = REPLY_SERVFAIL;
break;
case REFUSED:
rcodestr = "REFUSED";
queries[i].reply = REPLY_REFUSED;
queries[queryID].reply = REPLY_REFUSED;
break;
case NOTIMP:
rcodestr = "NOT IMPLEMENTED";
queries[i].reply = REPLY_NOTIMP;
queries[queryID].reply = REPLY_NOTIMP;
break;
default:
rcodestr = "UNKNOWN";
queries[i].reply = REPLY_OTHER;
queries[queryID].reply = REPLY_OTHER;
break;
}
// Debug logging
if(config.debug & DEBUG_QUERIES)
{
int domainID = queries[i].domainID;
const int domainID = queries[queryID].domainID;
validate_access("domains", domainID, true, __LINE__, __FUNCTION__, __FILE__);
logg("**** got error report for %s: %s (ID %i, %s:%i)", getstr(domains[domainID].domainpos), rcodestr, id, file, line);
if(queries[i].reply == REPLY_OTHER)
if(queries[queryID].reply == REPLY_OTHER)
{
logg("Unknown rcode = %i", rcode);
}
@ -914,7 +919,7 @@ void _FTL_header_analysis(const unsigned char header4, const unsigned int rcode,
lock_shm();
// Search for corresponding query identified by ID
int queryID = findQueryID(id);
const int queryID = findQueryID(id);
if(queryID < 0)
{
// This may happen e.g. if the original query was an unhandled query type
@ -924,7 +929,7 @@ void _FTL_header_analysis(const unsigned char header4, const unsigned int rcode,
if(config.debug & DEBUG_QUERIES)
{
int domainID = queries[queryID].domainID;
const int domainID = queries[queryID].domainID;
validate_access("domains", domainID, true, __LINE__, __FUNCTION__, __FILE__);
logg("**** %s externally blocked (ID %i, FTL %i, %s:%i)", getstr(domains[domainID].domainpos), id, queryID, file, line);
}
@ -943,7 +948,7 @@ void _FTL_header_analysis(const unsigned char header4, const unsigned int rcode,
unlock_shm();
}
void print_flags(unsigned int flags)
void print_flags(const unsigned int flags)
{
// Debug function, listing resolver flags in clear text
// e.g. "Flags: F_FORWARD F_NEG F_IPV6"
@ -952,16 +957,15 @@ void print_flags(unsigned int flags)
if(!(config.debug & DEBUG_FLAGS))
return;
unsigned int i;
char *flagstr = calloc(256,sizeof(char));
for(i = 0; i < sizeof(flags)*8; i++)
for(unsigned int i = 0; i < sizeof(flags)*8; i++)
if(flags & (1u << i))
strcat(flagstr, flagnames[i]);
logg(" Flags: %s", flagstr);
free(flagstr);
}
void save_reply_type(unsigned int flags, int queryID, struct timeval response)
void save_reply_type(const unsigned int flags, const int queryID, const struct timeval response)
{
// Iterate through possible values
validate_access("queries", queryID, false, __LINE__, __FUNCTION__, __FILE__);
@ -1088,7 +1092,7 @@ void FTL_fork_and_bind_sockets(struct passwd *ent_pw)
}
// int cache_inserted, cache_live_freed are defined in dnsmasq/cache.c
void getCacheInformation(int *sock)
void getCacheInformation(const int *sock)
{
ssend(*sock,"cache-size: %i\ncache-live-freed: %i\ncache-inserted: %i\n",
daemon->cachesize,
@ -1104,7 +1108,7 @@ void getCacheInformation(int *sock)
// which hasn't been looked up for the longest time is evicted.
}
void _FTL_forwarding_failed(struct server *server, const char* file, const int line)
void _FTL_forwarding_failed(const struct server *server, const char* file, const int line)
{
// Don't analyze anything if in PRIVACY_NOSTATS mode
if(config.privacylevel >= PRIVACY_NOSTATS)
@ -1121,7 +1125,7 @@ void _FTL_forwarding_failed(struct server *server, const char* file, const int l
// Convert forward to lower case
char *forward = strdup(dest);
strtolower(forward);
int forwardID = findForwardID(forward, false);
const int forwardID = findForwardID(forward, false);
if(config.debug & DEBUG_QUERIES) logg("**** forwarding to %s (ID %i, %s:%i) failed", dest, forwardID, file, line);
@ -1132,7 +1136,7 @@ void _FTL_forwarding_failed(struct server *server, const char* file, const int l
return;
}
static unsigned long __attribute__((const)) converttimeval(struct timeval time)
static unsigned long __attribute__((const)) converttimeval(const struct timeval time)
{
// Convert time from struct timeval into units
// of 10*milliseconds
@ -1196,8 +1200,8 @@ void rehash(int size);
// This routine adds one domain to the resolver's cache. Depending on the configured blocking mode it may create
// a single entry valid for IPv4 & IPv6 or two entries one for IPv4 and one for IPv6.
// When IPv6 is not available on the machine, we do not add IPv6 cache entries (likewise for IPv4)
static int add_blocked_domain(struct all_addr *addr4, struct all_addr *addr6, bool has_IPv4, bool has_IPv6,
char *domain, int len, struct crec **rhash, int hashsz, unsigned int index)
static int add_blocked_domain(struct all_addr *addr4, struct all_addr *addr6, const bool has_IPv4, const bool has_IPv6,
const char *domain, const int len, struct crec **rhash, int hashsz, unsigned int index)
{
int name_count = 0;
struct crec *cache4,*cache6;
@ -1251,7 +1255,7 @@ static int add_blocked_domain(struct all_addr *addr4, struct all_addr *addr6, bo
// Add a single domain to resolver's cache. This respects the configured blocking mode
// Note: This routine is meant for adding a single domain at a time. It should not be
// invoked for batch processing
static void block_single_domain_regex(char *domain)
static void block_single_domain_regex(const char *domain)
{
struct all_addr addr4 = {{{ 0 }}}, addr6 = {{{ 0 }}};
bool has_IPv4 = false, has_IPv6 = false;
@ -1266,7 +1270,7 @@ static void block_single_domain_regex(char *domain)
return;
}
int FTL_listsfile(char* filename, unsigned int index, FILE *f, int cache_size, struct crec **rhash, int hashsz)
int FTL_listsfile(const char* filename, unsigned int index, FILE *f, int cache_size, struct crec **rhash, int hashsz)
{
int name_count = cache_size;
int added = 0;

18
dnsmasq_interface.h
View File

@ -12,29 +12,29 @@ extern unsigned char* pihole_privacylevel;
enum { TCP, UDP };
#define FTL_new_query(flags, name, addr, types, id, type) _FTL_new_query(flags, name, addr, types, id, type, __FILE__, __LINE__)
void _FTL_new_query(unsigned int flags, char *name, struct all_addr *addr, char *types, int id, char type, const char* file, const int line);
void _FTL_new_query(const unsigned int flags, const char *name, const struct all_addr *addr, const char *types, const int id, const char type, const char* file, const int line);
#define FTL_forwarded(flags, name, addr, id) _FTL_forwarded(flags, name, addr, id, __FILE__, __LINE__)
void _FTL_forwarded(unsigned int flags, char *name, struct all_addr *addr, int id, const char* file, const int line);
void _FTL_forwarded(const unsigned int flags, const char *name, const struct all_addr *addr, const int id, const char* file, const int line);
#define FTL_reply(flags, name, addr, id) _FTL_reply(flags, name, addr, id, __FILE__, __LINE__)
void _FTL_reply(unsigned short flags, char *name, struct all_addr *addr, int id, const char* file, const int line);
void _FTL_reply(const unsigned short flags, const char *name, const struct all_addr *addr, const int id, const char* file, const int line);
#define FTL_cache(flags, name, addr, arg, id) _FTL_cache(flags, name, addr, arg, id, __FILE__, __LINE__)
void _FTL_cache(unsigned int flags, char *name, struct all_addr *addr, char * arg, int id, const char* file, const int line);
void _FTL_cache(const unsigned int flags, const char *name, const struct all_addr *addr, const char * arg, const int id, const char* file, const int line);
#define FTL_dnssec(status, id) _FTL_dnssec(status, id, __FILE__, __LINE__)
void _FTL_dnssec(int status, int id, const char* file, const int line);
void _FTL_dnssec(const int status, const int id, const char* file, const int line);
#define FTL_header_analysis(header4, rcode, id) _FTL_header_analysis(header4, rcode, id, __FILE__, __LINE__)
void _FTL_header_analysis(unsigned char header4, unsigned int rcode, int id, const char* file, const int line);
void _FTL_header_analysis(const unsigned char header4, const unsigned int rcode, const int id, const char* file, const int line);
#define FTL_forwarding_failed(server) _FTL_forwarding_failed(server, __FILE__, __LINE__)
void _FTL_forwarding_failed(struct server *server, const char* file, const int line);
void _FTL_forwarding_failed(const struct server *server, const char* file, const int line);
#define FTL_upstream_error(rcode, id) _FTL_upstream_error(rcode, id, __FILE__, __LINE__)
void _FTL_upstream_error(unsigned int rcode, int id, const char* file, const int line);
void _FTL_upstream_error(const unsigned int rcode, const int id, const char* file, const int line);
void FTL_dnsmasq_reload(void);
void FTL_fork_and_bind_sockets(struct passwd *ent_pw);
int FTL_listsfile(char* filename, unsigned int index, FILE *f, int cache_size, struct crec **rhash, int hashsz);
int FTL_listsfile(const char* filename, unsigned int index, FILE *f, int cache_size, struct crec **rhash, int hashsz);

12
gc.c
View File

@ -44,12 +44,11 @@ void *GC_thread(void *val)
if(config.debug & DEBUG_GC) timer_start(GC_TIMER);
long int i;
int removed = 0;
if(config.debug & DEBUG_GC) logg("GC starting, mintime: %lu %s", mintime, ctime(&mintime));
// Process all queries
for(i=0; i < counters->queries; i++)
for(long int i=0; i < counters->queries; i++)
{
validate_access("queries", i, true, __LINE__, __FUNCTION__, __FILE__);
// Test if this query is too new
@ -57,18 +56,18 @@ void *GC_thread(void *val)
break;
// Adjust client counter
int clientID = queries[i].clientID;
const int clientID = queries[i].clientID;
validate_access("clients", clientID, true, __LINE__, __FUNCTION__, __FILE__);
clients[clientID].count--;
// Adjust total counters and total over time data
int timeidx = queries[i].timeidx;
const int timeidx = queries[i].timeidx;
overTime[timeidx].total--;
// Adjust corresponding overTime counters
clients[clientID].overTime[timeidx]--;
// Adjust domain counter (no overTime information)
int domainID = queries[i].domainID;
const int domainID = queries[i].domainID;
validate_access("domains", domainID, true, __LINE__, __FUNCTION__, __FILE__);
domains[domainID].count--;
@ -164,7 +163,8 @@ void *GC_thread(void *val)
// Determine if overTime memory needs to get moved
moveOverTimeMemory(mintime);
if(config.debug & DEBUG_GC) logg("Notice: GC removed %i queries (took %.2f ms)", removed, timer_elapsed_msec(GC_TIMER));
if(config.debug & DEBUG_GC)
logg("Notice: GC removed %i queries (took %.2f ms)", removed, timer_elapsed_msec(GC_TIMER));
// Release thread lock
unlock_shm();

2
grep.c
View File

@ -105,7 +105,7 @@ int countlineswith(const char* str, const char* fname)
void check_blocking_status(void)
{
char* blocking = read_setupVarsconf("BLOCKING_ENABLED");
const char* blocking = read_setupVarsconf("BLOCKING_ENABLED");
const char* message;
if(blocking == NULL || getSetupVarsBool(blocking))

20
log.c
View File

@ -11,8 +11,8 @@
#include "FTL.h"
#include "version.h"
pthread_mutex_t lock;
FILE *logfile = NULL;
static pthread_mutex_t lock;
static FILE *logfile = NULL;
static void close_FTL_log(void)
{
@ -20,7 +20,7 @@ static void close_FTL_log(void)
fclose(logfile);
}
void open_FTL_log(bool test)
void open_FTL_log(const bool test)
{
if(test)
{
@ -52,11 +52,11 @@ void open_FTL_log(bool test)
static void get_timestr(char *timestring)
{
time_t t = time(NULL);
struct tm tm = *localtime(&t);
const time_t t = time(NULL);
const struct tm tm = *localtime(&t);
struct timeval tv;
gettimeofday(&tv, NULL);
int millisec = tv.tv_usec/1000;
const int millisec = tv.tv_usec/1000;
sprintf(timestring,"%d-%02d-%02d %02d:%02d:%02d.%03i", tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec, millisec);
}
@ -72,7 +72,7 @@ void __attribute__ ((format (gnu_printf, 1, 2))) logg(const char *format, ...)
// Get and log PID of current process to avoid ambiguities when more than one
// pihole-FTL instance is logging into the same file
long pid = (long)getpid();
const long pid = (long)getpid();
// Print to stdout before writing to file
if(!daemonmode)
@ -108,7 +108,7 @@ void __attribute__ ((format (gnu_printf, 1, 2))) logg(const char *format, ...)
pthread_mutex_unlock(&lock);
}
void format_memory_size(char *prefix, unsigned long int bytes, double *formated)
void format_memory_size(char *prefix, const unsigned long int bytes, double *formated)
{
int i;
*formated = bytes;
@ -124,7 +124,7 @@ void format_memory_size(char *prefix, unsigned long int bytes, double *formated)
strcpy(prefix, prefixes[i]);
}
void logg_struct_resize(const char* str, int to, int step)
void logg_struct_resize(const char* str, const int to, const int step)
{
logg("Notice: Increasing %s struct size from %i to %i", str, (to-step), to);
}
@ -141,7 +141,7 @@ void log_counter_info(void)
logg(" -> Known forward destinations: %i", counters->forwarded);
}
void log_FTL_version(bool crashreport)
void log_FTL_version(const bool crashreport)
{
logg("FTL branch: %s", GIT_BRANCH);
logg("FTL version: %s", GIT_TAG);

15
memory.c
View File

@ -44,7 +44,7 @@ clientsDataStruct *clients = NULL;
domainsDataStruct *domains = NULL;
overTimeDataStruct *overTime = NULL;
void memory_check(int which)
void memory_check(const int which)
{
switch(which)
{
@ -104,7 +104,8 @@ void memory_check(int which)
}
}
void validate_access(const char * name, int pos, bool testmagic, int line, const char * function, const char * file)
void validate_access(const char * name, const int pos, const bool testmagic,
const int line, const char * function, const char * file)
{
int limit = 0;
if(name[0] == 'c') limit = counters->clients_MAX;
@ -141,7 +142,7 @@ void validate_access(const char * name, int pos, bool testmagic, int line, const
// not be protected by our (error logging) functions!
#undef strdup
char* __attribute__((malloc)) FTLstrdup(const char *src, const char * file, const char * function, int line)
char* __attribute__((malloc)) FTLstrdup(const char *src, const char * file, const char * function, const int line)
{
// The FTLstrdup() function returns a pointer to a new string which is a
// duplicate of the string s. Memory for the new string is obtained with
@ -151,7 +152,7 @@ char* __attribute__((malloc)) FTLstrdup(const char *src, const char * file, cons
logg("WARN: Trying to copy a NULL string in %s() (%s:%i)", function, file, line);
return NULL;
}
size_t len = strlen(src);
const size_t len = strlen(src);
char *dest = calloc(len+1, sizeof(char));
if(dest == NULL)
{
@ -166,7 +167,7 @@ char* __attribute__((malloc)) FTLstrdup(const char *src, const char * file, cons
}
#undef calloc
void* __attribute__((malloc)) __attribute__((alloc_size(1,2))) FTLcalloc(size_t nmemb, size_t size, const char * file, const char * function, int line)
void* __attribute__((malloc)) __attribute__((alloc_size(1,2))) FTLcalloc(const size_t nmemb, const size_t size, const char * file, const char * function, const int line)
{
// The FTLcalloc() function allocates memory for an array of nmemb elements
// of size bytes each and returns a pointer to the allocated memory. The
@ -182,7 +183,7 @@ void* __attribute__((malloc)) __attribute__((alloc_size(1,2))) FTLcalloc(size_t
}
#undef realloc
void __attribute__((alloc_size(2))) *FTLrealloc(void *ptr_in, size_t size, const char * file, const char * function, int line)
void __attribute__((alloc_size(2))) *FTLrealloc(void *ptr_in, const size_t size, const char * file, const char * function, const int line)
{
// The FTLrealloc() function changes the size of the memory block pointed to
// by ptr to size bytes. The contents will be unchanged in the range from
@ -203,7 +204,7 @@ void __attribute__((alloc_size(2))) *FTLrealloc(void *ptr_in, size_t size, const
}
#undef free
void FTLfree(void *ptr, const char * file, const char * function, int line)
void FTLfree(void *ptr, const char * file, const char * function, const int line)
{
// The free() function frees the memory space pointed to by ptr, which
// must have been returned by a previous call to malloc(), calloc(), or

44
msgpack.c
View File

@ -11,19 +11,19 @@
#include "FTL.h"
#include "api.h"
void pack_eom(int sock) {
void pack_eom(const int sock) {
// This byte is explicitly never used in the MessagePack spec, so it is perfect to use as an EOM for this API.
uint8_t eom = 0xc1;
swrite(sock, &eom, sizeof(eom));
}
static void pack_basic(int sock, uint8_t format, void *value, size_t size) {
static void pack_basic(const int sock, const uint8_t format, const void *value, const size_t size) {
swrite(sock, &format, sizeof(format));
swrite(sock, value, size);
}
static uint64_t __attribute__((const)) leToBe64(uint64_t value) {
char *ptr = (char *) &value;
static uint64_t __attribute__((const)) leToBe64(const uint64_t value) {
const char *ptr = (char *) &value;
uint32_t part1, part2;
// Copy the two halves of the 64 bit input into uint32_t's so we can use htonl
@ -38,26 +38,26 @@ static uint64_t __attribute__((const)) leToBe64(uint64_t value) {
return (uint64_t) part1 << 32 | part2;
}
void pack_bool(int sock, bool value) {
void pack_bool(const int sock, const bool value) {
uint8_t packed = (uint8_t) (value ? 0xc3 : 0xc2);
swrite(sock, &packed, sizeof(packed));
}
void pack_uint8(int sock, uint8_t value) {
void pack_uint8(const int sock, const uint8_t value) {
pack_basic(sock, 0xcc, &value, sizeof(value));
}
void pack_uint64(int sock, uint64_t value) {
uint64_t bigEValue = leToBe64(value);
void pack_uint64(const int sock, const uint64_t value) {
const uint64_t bigEValue = leToBe64(value);
pack_basic(sock, 0xcf, &bigEValue, sizeof(bigEValue));
}
void pack_int32(int sock, int32_t value) {
uint32_t bigEValue = htonl((uint32_t) value);
void pack_int32(const int sock, const int32_t value) {
const uint32_t bigEValue = htonl((uint32_t) value);
pack_basic(sock, 0xd2, &bigEValue, sizeof(bigEValue));
}
void pack_int64(int sock, int64_t value) {
void pack_int64(const int sock, const int64_t value) {
// Need to use memcpy to do a direct copy without reinterpreting the bytes (making negatives into positives).
// It should get optimized away.
uint64_t bigEValue;
@ -66,7 +66,7 @@ void pack_int64(int sock, int64_t value) {
pack_basic(sock, 0xd3, &bigEValue, sizeof(bigEValue));
}
void pack_float(int sock, float value) {
void pack_float(const int sock, const float value) {
// Need to use memcpy to do a direct copy without reinterpreting the bytes. It should get optimized away.
uint32_t bigEValue;
memcpy(&bigEValue, &value, sizeof(bigEValue));
@ -75,16 +75,16 @@ void pack_float(int sock, float value) {
}
// Return true if successful
bool pack_fixstr(int sock, const char *string) {
bool pack_fixstr(const int sock, const char *string) {
// Make sure that the length is less than 32
size_t length = strlen(string);
const size_t length = strlen(string);
if(length >= 32) {
logg("Tried to send a fixstr longer than 31 bytes!");
return false;
}
uint8_t format = (uint8_t) (0xA0 | length);
const uint8_t format = (uint8_t) (0xA0 | length);
swrite(sock, &format, sizeof(format));
swrite(sock, string, length);
@ -92,27 +92,27 @@ bool pack_fixstr(int sock, const char *string) {
}
// Return true if successful
bool pack_str32(int sock, const char *string) {
bool pack_str32(const int sock, const char *string) {
// Make sure that the length is less than 4294967296
size_t length = strlen(string);
const size_t length = strlen(string);
if(length >= 2147483648u) {
logg("Tried to send a str32 longer than 2147483647 bytes!");
return false;
}
uint8_t format = 0xdb;
const uint8_t format = 0xdb;
swrite(sock, &format, sizeof(format));
uint32_t bigELength = htonl((uint32_t) length);
const uint32_t bigELength = htonl((uint32_t) length);
swrite(sock, &bigELength, sizeof(bigELength));
swrite(sock, string, length);
return true;
}
void pack_map16_start(int sock, uint16_t length) {
uint8_t format = 0xde;
void pack_map16_start(const int sock, const uint16_t length) {
const uint8_t format = 0xde;
swrite(sock, &format, sizeof(format));
uint16_t bigELength = htons(length);
const uint16_t bigELength = htons(length);
swrite(sock, &bigELength, sizeof(bigELength));
}

6
networktable.c
View File

@ -65,7 +65,7 @@ void parse_arp_cache(void)
char * linebuffer = NULL;
size_t linebuffersize = 0;
char ip[100], mask[100], hwaddr[100], iface[100];
int type, flags, entries = 0;
unsigned int type, flags, entries = 0;
time_t now = time(NULL);
// Start collecting database commands
@ -101,7 +101,7 @@ void parse_arp_cache(void)
}
// Perform SQL query
int dbID = db_query_int(querystr);
const int dbID = db_query_int(querystr);
free(querystr);
if(dbID == DB_FAILED)
@ -120,7 +120,7 @@ void parse_arp_cache(void)
// This client is known (by its IP address) to pihole-FTL if
// findClientID() returned a non-negative index
bool clientKnown = clientID >= 0;
const bool clientKnown = clientID >= 0;
// Get hostname of this client if the client is known
const char *hostname = "";

16
overTime.c
View File

@ -16,7 +16,7 @@
* @param index The overTime slot index
* @param timestamp The timestamp of the slot
*/
static void initSlot(unsigned int index, time_t timestamp)
static void initSlot(const unsigned int index, const time_t timestamp)
{
// Possible debug printing
if(config.debug & DEBUG_OVERTIME)
@ -67,10 +67,10 @@ unsigned int getOverTimeID(time_t timestamp)
timestamp += OVERTIME_INTERVAL/2;
// Get timestamp of first interval
time_t firstTimestamp = overTime[0].timestamp;
const time_t firstTimestamp = overTime[0].timestamp;
// Compute overTime ID
int id = (int) ((timestamp - firstTimestamp) / OVERTIME_INTERVAL);
const int id = (int) ((timestamp - firstTimestamp) / OVERTIME_INTERVAL);
// Check bounds manually
if(id < 0)
@ -93,9 +93,9 @@ unsigned int getOverTimeID(time_t timestamp)
}
// This routine is called by garbage collection to rearrange the overTime structure for the next hour
void moveOverTimeMemory(time_t mintime)
void moveOverTimeMemory(const time_t mintime)
{
time_t oldestOverTimeIS = overTime[0].timestamp;
const time_t oldestOverTimeIS = overTime[0].timestamp;
// Shift SHOULD timestemp into the future by the amount GC is running earlier
time_t oldestOverTimeSHOULD = mintime;
@ -105,10 +105,10 @@ void moveOverTimeMemory(time_t mintime)
// Calculate the number of slots to be garbage collected, which is also the
// ID of the slot to move to the zero position
unsigned int moveOverTime = (unsigned int) ((oldestOverTimeSHOULD - oldestOverTimeIS) / OVERTIME_INTERVAL);
const unsigned int moveOverTime = (unsigned int) ((oldestOverTimeSHOULD - oldestOverTimeIS) / OVERTIME_INTERVAL);
// The number of slots which will be moved (not garbage collected)
unsigned int remainingSlots = OVERTIME_SLOTS - moveOverTime;
const unsigned int remainingSlots = OVERTIME_SLOTS - moveOverTime;
if(config.debug & DEBUG_OVERTIME)
logg("moveOverTimeMemory(): IS: %lu, SHOULD: %lu, MOVING: %u", oldestOverTimeIS, oldestOverTimeSHOULD, moveOverTime);
@ -148,7 +148,7 @@ void moveOverTimeMemory(time_t mintime)
for(unsigned int timeidx = remainingSlots; timeidx < OVERTIME_SLOTS ; timeidx++)
{
// This slot is OVERTIME_INTERVAL seconds after the previous slot
time_t timestamp = overTime[timeidx-1].timestamp + OVERTIME_INTERVAL;
const time_t timestamp = overTime[timeidx-1].timestamp + OVERTIME_INTERVAL;
initSlot(timeidx, timestamp);
}
}

15
regex.c
View File

@ -17,22 +17,22 @@ static bool *regexconfigured = NULL;
static char **regexbuffer = NULL;
static whitelistStruct whitelist = { NULL, 0 };
static void log_regex_error(const char *where, int errcode, int index)
static void log_regex_error(const char *where, const int errcode, const int index)
{
// Regex failed for some reason (probably user syntax error)
// Get error string and log it
size_t length = regerror(errcode, &regex[index], NULL, 0);
const size_t length = regerror(errcode, &regex[index], NULL, 0);
char *buffer = calloc(length,sizeof(char));
(void) regerror (errcode, &regex[index], buffer, length);
logg("ERROR %s regex on line %i: %s (%i)", where, index+1, buffer, errcode);
free(buffer);
}
static bool init_regex(const char *regexin, int index)
static bool init_regex(const char *regexin, const int index)
{
// compile regular expressions into data structures that
// can be used with regexec to match against a string
int errcode = regcomp(&regex[index], regexin, REG_EXTENDED);
const int errcode = regcomp(&regex[index], regexin, REG_EXTENDED);
if(errcode != 0)
{
log_regex_error("compiling", errcode, index);
@ -47,7 +47,7 @@ static bool init_regex(const char *regexin, int index)
return true;
}
bool __attribute__((pure)) in_whitelist(char *domain)
bool __attribute__((pure)) in_whitelist(const char *domain)
{
bool found = false;
for(int i=0; i < whitelist.count; i++)
@ -77,14 +77,13 @@ static void free_whitelist_domains(void)
}
}
bool match_regex(char *input)
bool match_regex(const char *input)
{
int index;
bool matched = false;
// Start matching timer
timer_start(REGEX_TIMER);
for(index = 0; index < num_regex; index++)
for(int index = 0; index < num_regex; index++)
{
// Only check regex which have been successfully compiled
if(!regexconfigured[index])

4
resolve.c
View File

@ -72,7 +72,7 @@ static const char *resolveHostname(const char *addr)
}
// Resolve client host names
void resolveClients(bool onlynew)
void resolveClients(const bool onlynew)
{
int clientID;
for(clientID = 0; clientID < counters->clients; clientID++)
@ -103,7 +103,7 @@ void resolveClients(bool onlynew)
}
// Resolve upstream destination host names
void resolveForwardDestinations(bool onlynew)
void resolveForwardDestinations(const bool onlynew)
{
int forwardID;
for(forwardID = 0; forwardID < counters->forwarded; forwardID++)

57
routines.h
View File

@ -9,14 +9,14 @@
* Please see LICENSE file for your rights under this license. */
void go_daemon(void);
void timer_start(int i);
double timer_elapsed_msec(int i);
void sleepms(int milliseconds);
void timer_start(const int i);
double timer_elapsed_msec(const int i);
void sleepms(const int milliseconds);
void savepid(void);
char * getUserName(void);
void removepid(void);
void open_FTL_log(bool test);
void open_FTL_log(const bool test);
void logg(const char* format, ...) __attribute__ ((format (gnu_printf, 1, 2)));
void logg_struct_resize(const char* str, int to, int step);
void log_counter_info(void);
@ -25,20 +25,20 @@ void log_FTL_version(bool crashreport);
// datastructure.c
void strtolower(char *str);
int findForwardID(const char * forward, bool count);
int findForwardID(const char * forward, const bool count);
int findDomainID(const char *domain);
int findClientID(const char *client, bool addNew);
int findClientID(const char *client, const bool count);
bool isValidIPv4(const char *addr);
bool isValidIPv6(const char *addr);
const char *getDomainString(int queryID);
const char *getClientIPString(int queryID);
const char *getClientNameString(int queryID);
const char *getDomainString(const int queryID);
const char *getClientIPString(const int queryID);
const char *getClientNameString(const int queryID);
void close_telnet_socket(void);
void close_unix_socket(void);
void seom(int sock);
void ssend(int sock, const char *format, ...) __attribute__ ((format (gnu_printf, 2, 3)));
void swrite(int sock, const void* value, size_t size);
void seom(const int sock);
void ssend(const int sock, const char *format, ...) __attribute__ ((format (gnu_printf, 2, 3)));
void swrite(const int sock, const void* value, const size_t size);
void *telnet_listening_thread_IPv4(void *args);
void *telnet_listening_thread_IPv6(void *args);
@ -48,7 +48,6 @@ void bind_sockets(void);
void process_request(const char *client_message, int *sock);
bool command(const char *client_message, const char* cmd) __attribute__((pure));
bool matchesEndpoint(char *client_message, const char *cmd);
// grep.c
int countlines(const char* fname);
@ -84,7 +83,7 @@ void *DB_thread(void *val);
int get_number_of_queries_in_DB(void);
void save_to_DB(void);
void read_data_from_DB(void);
bool db_set_FTL_property(unsigned int ID, int value);
bool db_set_FTL_property(const unsigned int ID, const int value);
bool dbquery(const char *format, ...);
bool dbopen(void);
void dbclose(void);
@ -92,12 +91,12 @@ int db_query_int(const char*);
void SQLite3LogCallback(void *pArg, int iErrCode, const char *zMsg);
// memory.c
void memory_check(int which);
char *FTLstrdup(const char *src, const char *file, const char *function, int line) __attribute__((malloc));
void *FTLcalloc(size_t nmemb, size_t size, const char *file, const char *function, int line) __attribute__((malloc)) __attribute__((alloc_size(1,2)));
void *FTLrealloc(void *ptr_in, size_t size, const char *file, const char *function, int line) __attribute__((alloc_size(2)));
void FTLfree(void *ptr, const char* file, const char *function, int line);
void validate_access(const char * name, int pos, bool testmagic, int line, const char * function, const char * file);
void memory_check(const int which);
char *FTLstrdup(const char *src, const char *file, const char *function, const int line) __attribute__((malloc));
void *FTLcalloc(size_t nmemb, size_t size, const char *file, const char *function, const int line) __attribute__((malloc)) __attribute__((alloc_size(1,2)));
void *FTLrealloc(void *ptr_in, size_t size, const char *file, const char *function, const int line) __attribute__((alloc_size(2)));
void FTLfree(void *ptr, const char* file, const char *function, const int line);
void validate_access(const char * name, int pos, bool testmagic, const int line, const char * function, const char * file);
int main_dnsmasq(int argc, const char ** argv);
@ -106,27 +105,27 @@ void handle_signals(void);
// resolve.c
void *DNSclient_thread(void *val);
void resolveClients(bool onlynew);
void resolveForwardDestinations(bool onlynew);
void resolveClients(const bool onlynew);
void resolveForwardDestinations(const bool onlynew);
// regex.c
bool match_regex(char *input);
bool match_regex(const char *input);
void free_regex(void);
void read_regex_from_file(void);
bool in_whitelist(char *domain) __attribute__((pure));
bool in_whitelist(const char *domain) __attribute__((pure));
// shmem.c
bool init_shmem(void);
void destroy_shmem(void);
size_t addstr(const char *str);
const char *getstr(size_t pos);
void *enlarge_shmem_struct(char type);
const char *getstr(const size_t pos);
void *enlarge_shmem_struct(const char type);
/**
* Create a new overTime client shared memory block.
* This also updates `overTimeClientData`.
*/
void newOverTimeClient(int clientID);
void newOverTimeClient(const int clientID);
/**
* Add a new overTime slot to each overTime client shared memory block.
@ -136,7 +135,7 @@ void addOverTimeClientSlot(void);
// overTime.c
void initOverTime(void);
unsigned int getOverTimeID(time_t timestamp);
unsigned int getOverTimeID(const time_t timestamp);
/**
* Move the overTime slots so the oldest interval starts with mintime. The time
@ -144,7 +143,7 @@ unsigned int getOverTimeID(time_t timestamp);
*
* @param mintime The start of the oldest interval
*/
void moveOverTimeMemory(time_t mintime);
void moveOverTimeMemory(const time_t mintime);
// capabilities.c
bool check_capabilities(void);

37
shmem.c
View File

@ -46,7 +46,7 @@ static ShmSettings *shmSettings = NULL;
static int pagesize;
static unsigned int local_shm_counter = 0;
static size_t get_optimal_object_size(size_t objsize, size_t minsize);
static size_t get_optimal_object_size(const size_t objsize, const size_t minsize);
size_t addstr(const char *str)
{
@ -90,7 +90,7 @@ size_t addstr(const char *str)
return (shmSettings->next_str_pos - (len + 1));
}
const char *getstr(size_t pos)
const char *getstr(const size_t pos)
{
// Only access the string memory if this memory region has already been set
if(pos < shmSettings->next_str_pos)
@ -143,17 +143,17 @@ static void remap_shm(void)
local_shm_counter = shmSettings->global_shm_counter;
}
void _lock_shm(const char* function, const int line, const char * file) {
void _lock_shm(const char* func, const int line, const char * file) {
// Signal that FTL is waiting for a lock
shmLock->waitingForLock = true;
if(config.debug & DEBUG_LOCKS)
logg("Waiting for lock in %s() (%s:%i)", function, file, line);
logg("Waiting for lock in %s() (%s:%i)", func, file, line);
int result = pthread_mutex_lock(&shmLock->lock);
if(config.debug & DEBUG_LOCKS)
logg("Obtained lock for %s() (%s:%i)", function, file, line);
logg("Obtained lock for %s() (%s:%i)", func, file, line);
// Check if this process needs to remap the shared memory objects
if(shmSettings != NULL &&
@ -179,11 +179,11 @@ void _lock_shm(const char* function, const int line, const char * file) {
logg("Failed to obtain SHM lock: %s", strerror(result));
}
void _unlock_shm(const char* function, const int line, const char * file) {
void _unlock_shm(const char* func, const int line, const char * file) {
int result = pthread_mutex_unlock(&shmLock->lock);
if(config.debug & DEBUG_LOCKS)
logg("Removed lock in %s() (%s:%i)", function, file, line);
logg("Removed lock in %s() (%s:%i)", func, file, line);
if(result != 0)
logg("Failed to unlock SHM lock: %s", strerror(result));
@ -274,7 +274,7 @@ void destroy_shmem(void)
delete_shm(&shm_settings);
}
SharedMemory create_shm(const char *name, size_t size)
SharedMemory create_shm(const char *name, const size_t size)
{
if(config.debug & DEBUG_SHMEM)
logg("Creating shared memory with name \"%s\" and size %zu", name, size);
@ -307,10 +307,10 @@ SharedMemory create_shm(const char *name, size_t size)
}
// Resize shared memory file
int result = ftruncate(fd, size);
ret = ftruncate(fd, size);
// Check for `ftruncate` error
if(result == -1)
if(ret == -1)
{
logg("FATAL: create_shm(): ftruncate(%i, %zu): Failed to resize shared memory object \"%s\": %s",
fd, size, sharedMemory.name, strerror(errno));
@ -336,7 +336,7 @@ SharedMemory create_shm(const char *name, size_t size)
return sharedMemory;
}
void *enlarge_shmem_struct(char type)
void *enlarge_shmem_struct(const char type)
{
SharedMemory *sharedMemory = NULL;
size_t sizeofobj, allocation_step;
@ -383,7 +383,7 @@ void *enlarge_shmem_struct(char type)
return sharedMemory->ptr;
}
bool realloc_shm(SharedMemory *sharedMemory, size_t size, bool resize)
bool realloc_shm(SharedMemory *sharedMemory, const size_t size, const bool resize)
{
// Check if we can skip this routine as nothing is to be done
// when an object is not to be resized and its size didn't
@ -401,7 +401,7 @@ bool realloc_shm(SharedMemory *sharedMemory, size_t size, bool resize)
if(resize)
{
// Open shared memory object
int fd = shm_open(sharedMemory->name, O_RDWR, S_IRUSR | S_IWUSR);
const int fd = shm_open(sharedMemory->name, O_RDWR, S_IRUSR | S_IWUSR);
if(fd == -1)
{
logg("FATAL: realloc_shm(): Failed to open shared memory object \"%s\": %s",
@ -410,7 +410,7 @@ bool realloc_shm(SharedMemory *sharedMemory, size_t size, bool resize)
}
// Truncate shared memory object to specified size
int result = ftruncate(fd, size);
const int result = ftruncate(fd, size);
if(result == -1) {
logg("FATAL: realloc_shm(): ftruncate(%i, %zu): Failed to resize \"%s\": %s",
fd, size, sharedMemory->name, strerror(errno));
@ -444,8 +444,7 @@ bool realloc_shm(SharedMemory *sharedMemory, size_t size, bool resize)
void delete_shm(SharedMemory *sharedMemory)
{
// Unmap shared memory
int ret;
ret = munmap(sharedMemory->ptr, sharedMemory->size);
int ret = munmap(sharedMemory->ptr, sharedMemory->size);
if(ret != 0)
logg("delete_shm(): munmap(%p, %zu) failed: %s", sharedMemory->ptr, sharedMemory->size, strerror(errno));
@ -472,9 +471,9 @@ static size_t __attribute__((const)) gcd(size_t a, size_t b)
// shared memory objects. This routine works by computing the LCM
// of two numbers, the pagesize and the size of a single element
// in the shared memory object
static size_t get_optimal_object_size(size_t objsize, size_t minsize)
static size_t get_optimal_object_size(const size_t objsize, const size_t minsize)
{
size_t optsize = pagesize / gcd(pagesize, objsize);
const size_t optsize = pagesize / gcd(pagesize, objsize);
if(optsize < minsize)
{
if(config.debug & DEBUG_SHMEM)
@ -490,7 +489,7 @@ static size_t get_optimal_object_size(size_t objsize, size_t minsize)
// First part: Integer division, may cause clipping, e.g., 5/3 = 1
// Second part: Catch a possibly happened clipping event by adding
// one to the number: (5 % 3 != 0) is 1
size_t multiplier = (minsize/optsize) + ((minsize % optsize != 0) ? 1u : 0u);
const size_t multiplier = (minsize/optsize) + ((minsize % optsize != 0) ? 1u : 0u);
if(config.debug & DEBUG_SHMEM)
{
logg("DEBUG: Using %zu*%zu == %zu >= %zu",

4
shmem.h
View File

@ -27,7 +27,7 @@ typedef struct {
/// \param size the size to allocate
/// \return a structure with a pointer to the mounted shared memory. The pointer
/// will always be valid, because if it failed FTL will have exited.
SharedMemory create_shm(const char *name, size_t size);
SharedMemory create_shm(const char *name, const size_t size);
/// Reallocate shared memory
///
@ -35,7 +35,7 @@ SharedMemory create_shm(const char *name, size_t size);
/// \param size the new size
/// \param resize whether the object should be resized or only remapped
/// \return if reallocation was successful
bool realloc_shm(SharedMemory *sharedMemory, size_t size, bool resize);
bool realloc_shm(SharedMemory *sharedMemory, const size_t size, const bool resize);
/// Disconnect from shared memory. If there are no other connections to shared memory, it will be deleted.
///

20
socket.c
View File

@ -201,7 +201,7 @@ static void removeport(void)
fclose(f);
}
void seom(int sock)
void seom(const int sock)
{
if(istelnet[sock])
ssend(sock, "---EOM---\n\n");
@ -209,7 +209,7 @@ void seom(int sock)
pack_eom(sock);
}
void __attribute__ ((format (gnu_printf, 2, 3))) ssend(int sock, const char *format, ...)
void __attribute__ ((format (gnu_printf, 2, 3))) ssend(const int sock, const char *format, ...)
{
char *buffer;
va_list args;
@ -224,12 +224,12 @@ void __attribute__ ((format (gnu_printf, 2, 3))) ssend(int sock, const char *for
}
}
void swrite(int sock, const void *value, size_t size) {
void swrite(const int sock, const void *value, size_t size) {
if(write(sock, value, size) == -1)
logg("WARNING: Socket write returned error code %i", errno);
}
static inline int checkClientLimit(int socket) {
static inline int checkClientLimit(const int socket) {
if(socket < MAXCONNS)
{
return socket;
@ -243,7 +243,7 @@ static inline int checkClientLimit(int socket) {
}
}
static int listener(int sockfd, char type)
static int listener(const int sockfd, const char type)
{
struct sockaddr_un un_addr;
struct sockaddr_in in4_addr;
@ -430,7 +430,7 @@ void *telnet_listening_thread_IPv4(void *args)
while(!killed)
{
// Look for new clients that want to connect
int csck = listener(telnetfd4, 4);
const int csck = listener(telnetfd4, 4);
if(csck == -1)
{
logg("IPv4 telnet error: %s (%i)", strerror(errno), errno);
@ -471,7 +471,7 @@ void *telnet_listening_thread_IPv6(void *args)
while(!killed)
{
// Look for new clients that want to connect
int csck = listener(telnetfd6, 6);
const int csck = listener(telnetfd6, 6);
if(csck == -1)
{
logg("IPv6 telnet error: %s (%i)", strerror(errno), errno);
@ -512,7 +512,7 @@ void *socket_listening_thread(void *args)
while(!killed)
{
// Look for new clients that want to connect
int csck = listener(socketfd, 0);
const int csck = listener(socketfd, 0);
if(csck < 0) continue;
// Allocate memory used to transport client socket ID to client listening thread
@ -544,8 +544,8 @@ bool ipv6_available(void)
// Loop over interfaces
for (interface = allInterfaces; interface != NULL; interface = interface->ifa_next)
{
unsigned int flags = interface->ifa_flags;
struct sockaddr *addr = interface->ifa_addr;
const unsigned int flags = interface->ifa_flags;
const struct sockaddr *addr = interface->ifa_addr;
// Check only for up and running IPv4, IPv6 interfaces
if ((flags & (IFF_UP|IFF_RUNNING)) && addr != NULL)