/*--------------------------------------------------------------------------*/
int dictionary_set(dictionary * d, char * key, char * val)
{
int i ;
unsigned hash ;
if (d==NULL || key==NULL) return -1 ;
/* Compute hash for this key */
hash = dictionary_hash(key) ;
/* Find if value is already in dictionary */
if (d->n>0) {
for (i=0 ; i<d->size ; i++) {
if (d->key[i]==NULL)
continue ;
if (hash==d->hash[i]) { /* Same hash value */
if (!strcmp(key, d->key[i])) { /* Same key */
/* Found a value: modify and return */
if (d->val[i]!=NULL)
free(d->val[i]);
d->val[i] = val ? xstrdup(val) : NULL ;
/* Value has been modified: return */
return 0 ;
}
}
}
}
/* Add a new value */
/* See if dictionary needs to grow */
if (d->n==d->size) {
/* Reached maximum size: reallocate dictionary */
d->val = (char **)mem_double(d->val, d->size * sizeof(char*)) ;
d->key = (char **)mem_double(d->key, d->size * sizeof(char*)) ;
d->hash = (unsigned int *)mem_double(d->hash, d->size * sizeof(unsigned)) ;
if ((d->val==NULL) || (d->key==NULL) || (d->hash==NULL)) {
/* Cannot grow dictionary */
return -1 ;
}
/* Double size */
d->size *= 2 ;
}
/* Insert key in the first empty slot */
for (i=0 ; i<d->size ; i++) {
if (d->key[i]==NULL) {
/* Add key here */
break ;
}
}
/* Copy key */
d->key[i] = xstrdup(key);
d->val[i] = val ? xstrdup(val) : NULL ;
d->hash[i] = hash;
d->n ++ ;
return 0 ;
}
/*--------------------------------------------------------------------------*/
void dictionary_unset(dictionary* d, const char* key)
{
unsigned hash ;
size_t i ;
if (key == NULL)
{
return;
}
hash = dictionary_hash(key);
for (i=0 ; i<(size_t)d->size ; i++)
{
if (d->key[i]==NULL)
{
continue ;
}
/* Compare hash */
if (hash==d->hash[i])
{
/* Compare string, to avoid hash collisions */
if (!strcmp(key, d->key[i]))
{
/* Found key */
break ;
}
}
}
if (i>=(size_t)d->size)
/* Key not found */
{
return ;
}
free(d->key[i]);
d->key[i] = NULL ;
if (d->val[i]!=NULL)
{
free(d->val[i]);
d->val[i] = NULL ;
}
d->hash[i] = 0 ;
d->n -- ;
return ;
}
int dictionary_getbufsize(dictionary * d, char * key)
{
unsigned hash ;
int i ;
hash = dictionary_hash(key);
for (i=0 ; i<d->size ; i++) {
if (d->key[i]==NULL)
continue ;
/* Compare hash */
if (hash==d->hash[i]) {
/* Compare string, to avoid hash collisions */
if (!strcmp(key, d->key[i])) {
return d->bufsize[i] ;
}
}
}
return 0 ;
}
/*--------------------------------------------------------------------------*/
void dictionary_unset
(LPDICTIONARY lpDict, // Ptr to workspace dictionary
LPWCHAR lpwKey)
{
UINT hash;
int i;
Assert (lpDict NE NULL);
Assert (lpwKey NE NULL);
// Hash the key
hash = dictionary_hash (lpwKey);
for (i = 0; i < lpDict->size; i++)
if (lpDict->key[i] NE NULL)
{
/* Compare hash */
if (hash EQ lpDict->hash[i])
{
/* Compare string, to avoid hash collisions */
if (!lstrcmpW (lpwKey, lpDict->key[i]))
/* Found key */
break;
} // End IF
} // End FOR/IF
if (i >= lpDict->size)
/* Key not found */
return;
// Free the key
free (lpDict->key[i]); lpDict->key[i] = NULL;
// Free values if they were allocated
if (lpDict->val[i] NE NULL)
{
free (lpDict->val[i]);
lpDict->val[i] = NULL;
} // End IF
lpDict->hash[i] = 0;
lpDict->n--;
} // End dictionary_unset
/*--------------------------------------------------------------------------*/
static const char * dictionary_get(dictionary * d, const char * key, const char * def)
{
unsigned hash ;
int i ;
hash = dictionary_hash(key);
for (i=0 ; i<d->size ; i++) {
if (d->key==NULL)
continue ;
/* Compare hash */
if (hash==d->hash[i]) {
/* Compare string, to avoid hash collisions */
if (!strcmp(key, d->key[i])) {
return d->val[i] ;
}
}
}
return def ;
}
static t_hash_element *dictionary_get_element(t_dictionary *self, char *key) {
unsigned int key_hash = dictionary_hash(key, strlen(key));
int index = key_hash % self->table_max_size;
t_hash_element *element = self->elements[index];
if (element == NULL) {
return NULL;
}
do {
if (element->hashcode == key_hash) {
return element;
}
} while ((element = element->next) != NULL);
return NULL;
}
/*--------------------------------------------------------------------------*/
static void
dictionary_unset (dictionary * d, char * key)
{
unsigned hash;
int i;
hash = dictionary_hash (key);
for (i = 0; i < d->size; i++)
{
if (!d->key[i])
continue;
/* Compare hash */
if (hash == d->hash[i])
{
/* Compare string, to avoid hash collisions */
if (!strcmp (key, d->key[i]))
{
/* Found key */
break;
}
}
}
if (i >= d->size)
/* Key not found */
return;
free (d->key[i]);
d->key[i] = NULL;
if (d->val[i])
{
free (d->val[i]);
d->val[i] = NULL;
}
d->hash[i] = 0;
d->n --;
}
int iniparser_find_entry(
dictionary * ini,
char * entry
)
{
int i ;
int hash ;
int found ;
found = 0 ;
hash = dictionary_hash(entry);
for (i=0 ; i<ini->n ; i++) {
if (hash==ini->hash[i]) {
if (!strcmp(entry, ini->key[i])) {
found = 1 ;
break ;
}
}
}
return found ;
}
/*--------------------------------------------------------------------------*/
LPWCHAR dictionary_get
(LPDICTIONARY lpDict, // Ptr to workspace dictionary
LPWCHAR lpwKey,
LPWCHAR lpwDef,
LPINT lpIndex) // Ptr to index on output (may be NULL)
{
UINT hash;
int i;
Assert (lpDict NE NULL);
// If it's valid, ...
if (lpIndex NE NULL)
// Initialize it
*lpIndex = -1;
// Hash the key
hash = dictionary_hash (lpwKey);
for (i = 0; i < lpDict->size; i++)
if (lpDict->key[i] NE NULL)
{
/* Compare hash */
if (hash EQ lpDict->hash[i])
{
/* Compare string, to avoid hash collisions */
if (!lstrcmpW (lpwKey, lpDict->key[i]))
{
if (lpIndex NE NULL)
*lpIndex = i;
return lpDict->val[i];
} // End IF
} // End IF
} // End FOR/IF
return lpwDef;
} // End dictionary_get
static void *dictionary_remove_element(t_dictionary *self, char *key) {
unsigned int key_hash = dictionary_hash(key, strlen(key));
int index = key_hash % self->table_max_size;
t_hash_element *element = self->elements[index];
if (element == NULL) {
return NULL;
}
if (element->hashcode == key_hash) {
void *data = element->data;
self->elements[index] = element->next;
if (self->elements[index] == NULL) {
self->table_current_size--;
}
free(element->key);
free(element);
return data;
}
while (element->next != NULL) {
if (element->next->hashcode == key_hash) {
void *data = element->next->data;
t_hash_element *aux = element->next;
element->next = element->next->next;
free(aux->key);
free(aux);
return data;
}
element = element->next;
}
return NULL;
}
int main(int argc, char **argv) {
int port = 5586,
notification_timeout = 5,
config_preceeds = 1,
sockfd,
newsockfd,
c;
socklen_t clilen;
char msg[256];
char buffer[256];
struct sockaddr_in serv_addr, cli_addr;
while (1) {
static struct option long_options[] =
{
/* These options don't set a flag.
* We distinguish them by their indices. */
{"port", required_argument, 0, 'p'},
{"timeout", required_argument, 0, 't'},
{"help", no_argument, 0, 'h'},
{0, 0, 0, 0}
};
/* getopt_long stores the option index here. */
int option_index = 0;
c = getopt_long (argc, argv, "hp:t:",
long_options, &option_index);
/* Detect the end of the options. */
if (c == -1)
break;
switch (c)
{
case 0:
/* If this option set a flag, do nothing else now. */
if (long_options[option_index].flag != 0)
break;
printf ("option %s", long_options[option_index].name);
if (optarg)
printf (" with arg %s", optarg);
printf ("\n");
break;
case 'p':
port = atoi(optarg);
config_preceeds = 0;
break;
case 't':
notification_timeout = atoi(optarg);
config_preceeds = 0;
break;
case 'h':
printf ("Usage:\n");
printf ("%s [-h] [-p port_number] [-t notification_timeout]\n", argv[0]);
exit(EXIT_SUCCESS);
case '?':
/* getopt_long already printed an error message. */
break;
default:
printf("Unkown parameter. Exiting.\n");
exit(EXIT_FAILURE);
}
}
/* Our process ID and Session ID */
pid_t pid, sid, pid_found;
dictionary *dict;
/* Fork off the parent process */
pid = fork();
if (pid < 0) {
printf("Cannot fork the daemon. Exiting...\n");
exit(EXIT_FAILURE);
}
/* If we got a good PID, then
* we can exit the parent process. */
if (pid > 0) {
exit(EXIT_SUCCESS);
}
/* Change the file mode mask */
umask(0);
openlog ("notifmed", LOG_CONS | LOG_PID | LOG_NDELAY, LOG_LOCAL0);
syslog (LOG_INFO, "Program started by user %d", getuid ());
if (config_preceeds) {
char * home = getenv("HOME");
char * home_path_config = malloc(snprintf(NULL, 0, "%s/%s", home, ".notifmedrc") + 1);
sprintf(home_path_config, "%s/%s", home, ".notifmedrc");
if (file_exists(home_path_config)) {
dict = iniparser_load(home_path_config);
} else if (file_exists("/etc/notifmed.rc")) {
dict = iniparser_load("/etc/notifmed.rc");
/* a config file could also be given as argument
} else if (file_exists()) {
dict = iniparser_load();*/
} else {
syslog (LOG_INFO, "No configuration file found.");
syslog (LOG_INFO, "Using defaults:");
syslog (LOG_INFO, " port = 5586 ; notification_timeout = 5");
}
if (!dict) {
syslog (LOG_ERR, "Dictionary configuration file problem.");
closelog();
exit(EXIT_FAILURE);
}
int i;
unsigned int hh=dictionary_hash("server");
for ( i=0 ; (i<dict->n) && (hh!=dict->hash[i]) ; i++);
// No "server" section found
if( i == dict->n ) {
syslog (LOG_INFO, "No server section found.");
syslog (LOG_INFO, "Using defaults:");
syslog (LOG_INFO, " port = 5586 ; notification_timeout = 5");
}
for ( i++ ; ( i < dict->n ) && strncmp(dict->key[i],"server:",6) == 0 ; i++ ) {
if (strcmp(dict->key[i],"server:port") == 0) {
port = atoi(dict->val[i]);
} else if (strcmp(dict->key[i],"server:notification_timeout") == 0) {
notification_timeout = atoi(dict->val[i]);
}
}
}
syslog (LOG_INFO, "Config found: port=%i - notification_timeout=%i", port, notification_timeout);
/* Create a new SID for the child process */
sid = setsid();
if (sid < 0) {
syslog (LOG_ERR, "Cannot create a new SID.");
closelog();
exit(EXIT_FAILURE);
}
// Preparing the network part
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0) {
syslog (LOG_ERR, "Cannot open the socket.");
closelog();
exit(EXIT_FAILURE);
}
bzero((char *) &serv_addr, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = INADDR_ANY;
serv_addr.sin_port = htons(port);
if (bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0) {
syslog (LOG_ERR, "Cannot bind the socket.");
closelog();
exit(EXIT_FAILURE);
}
listen(sockfd,5);
clilen = sizeof(cli_addr);
/* Change the current working directory */
if ((chdir("/")) < 0) {
syslog (LOG_ERR, "Cannot create a new SID.");
closelog();
exit(EXIT_FAILURE);
}
/* Close out the standard file descriptors */
close(STDIN_FILENO);
close(STDOUT_FILENO);
close(STDERR_FILENO);
NotifyNotification *n;
notify_init("Initialization");
n = notify_notification_new ("notifmed","Initialized!\nMonitoring for client requests...", NULL);
notify_notification_set_timeout(n, notification_timeout * 1000); //3 seconds
if (!notify_notification_show (n, NULL)) {
g_error("Failed to send notification.\n");
return 1;
}
g_object_unref(G_OBJECT(n));
/* The Big Loop */
while (1) {
newsockfd = accept(sockfd, (struct sockaddr *) &cli_addr, &clilen);
if (newsockfd < 0) {
syslog (LOG_ERR, "Cannot accept messages.");
closelog();
close(newsockfd);
close(sockfd);
exit(EXIT_FAILURE);
}
bzero(buffer,256);
n = read(newsockfd,buffer,255);
if (n < 0) {
syslog (LOG_ERR, "Error reading from the socket.");
closelog();
close(newsockfd);
close(sockfd);
exit(EXIT_FAILURE);
}
syslog (LOG_INFO, "Here is the message: %s\n",buffer);
pid_found = getProcessID((char *)buffer);
sprintf(msg,"Monitoring process: %s (PID: %i)",buffer, pid_found);
n = notify_notification_new ("notifmed",msg, NULL);
notify_notification_set_timeout(n, notification_timeout * 1000); //3 seconds
if (!notify_notification_show (n, NULL)) {
g_error("Failed to send notification.\n");
return 1;
}
n = write(newsockfd,msg,255);
if (n < 0) {
syslog (LOG_ERR, "Error writing to the socket.");
closelog();
close(newsockfd);
close(sockfd);
exit(EXIT_FAILURE);
}
//sleep(3); /* wait 3 seconds */
}
close(newsockfd);
close(sockfd);
closelog();
exit(EXIT_SUCCESS);
}
/*--------------------------------------------------------------------------*/
int dictionary_set(dictionary* d, const char* key, const char* val)
{
size_t i ;
unsigned hash ;
if (d==NULL || key==NULL)
{
return -1 ;
}
/* Compute hash for this key */
hash = dictionary_hash(key) ;
/* Find if value is already in dictionary */
if (d->n>0)
{
for (i=0 ; i<(size_t)d->size ; i++)
{
if (d->key[i]==NULL)
{
continue ;
}
if (hash==d->hash[i]) /* Same hash value */
{
if (!strcmp(key, d->key[i])) /* Same key */
{
/* Found a value: modify and return */
if (d->val[i]!=NULL)
{
free(d->val[i]);
}
d->val[i] = val ? xstrdup(val) : NULL ;
/* Value has been modified: return */
return 0 ;
}
}
}
}
/* Add a new value */
/* See if dictionary needs to grow */
if (d->n==d->size)
{
/* Reached maximum size: reallocate dictionary */
d->val = (char** )mem_double(d->val, d->size * sizeof *d->val) ;
d->key = (char** )mem_double(d->key, d->size * sizeof *d->key) ;
d->hash = (unsigned* )mem_double(d->hash, d->size * sizeof *d->hash) ;
if ((d->val==NULL) || (d->key==NULL) || (d->hash==NULL))
{
/* Cannot grow dictionary */
return -1 ;
}
/* Double size */
d->size *= 2 ;
}
/* Insert key in the first empty slot. Start at d->n and wrap at
d->size. Because d->n < d->size this will necessarily
terminate. */
for (i=d->n ; d->key[i] ; )
{
if(++i == (size_t)d->size)
{
i = 0;
}
}
/* Copy key */
d->key[i] = xstrdup(key);
d->val[i] = val ? xstrdup(val) : NULL ;
d->hash[i] = hash;
d->n ++ ;
return 0 ;
}
/*--------------------------------------------------------------------------*/
dictionary_value* dictionary_set(dictionary * d, const char * key, char * val, int type, void* ptr,void (*cb)(void))
{
int i;
unsigned hash;
if (d==NULL || key==NULL)
return NULL ;
/* Compute hash for this key */
hash = dictionary_hash(key) ;
/* Find if value is already in dictionary */
if (d->n>0) {
for (i=0 ; i<d->size ; i++) {
if (d->key[i]==NULL)
continue ;
if (hash==d->hash[i]) { /* Same hash value */
if (!strcmp(key, d->key[i])) { /* Same key */
/* Found a value: modify and return */
if (d->values[i].val!=NULL)
free(d->values[i].val);
d->values[i].val = (val != NULL) ? xstrdup(val) : NULL ;
/* Value has been modified: return */
return &d->values[i];
}
}
}
}
/* Add a new value */
/* See if dictionary needs to grow */
if (d->n==d->size) {
/* Reached maximum size: reallocate dictionary */
d->values = (dictionary_value *)mem_double(d->values, d->size * sizeof(dictionary_value*)) ;
d->key = (char **)mem_double(d->key, d->size * sizeof(char*)) ;
d->hash = (unsigned int *)mem_double(d->hash, d->size * sizeof(unsigned)) ;
if ((d->values==NULL) || (d->key==NULL) || (d->hash==NULL)) {
/* Cannot grow dictionary */
return NULL;
}
/* Double size */
d->size *= 2 ;
}
/* Insert key in the first empty slot */
for (i=0 ; i<d->size ; i++) {
if (d->key[i]==NULL) {
/* Add key here */
break ;
}
}
/* Copy key */
d->key[i] = xstrdup(key);
d->values[i].val = (val != NULL) ? xstrdup(val) : NULL;
d->values[i].type = type;
d->values[i].callback = NULL;
d->values[i].rw = 0;
d->values[i].scope = -1;
d->values[i].ptr = ptr;
d->hash[i] = hash;
d->n ++ ;
return &d->values[i] ;
}
/*--------------------------------------------------------------------------*/
int dictionary_set
(LPDICTIONARY lpDict, // Ptr to workspace dictionary
LPWCHAR lpwKey,
LPWCHAR lpwVal)
{
int i;
UINT hash;
Assert (lpDict NE NULL);
Assert (lpwKey NE NULL);
// Hash the key
hash = dictionary_hash (lpwKey);
/* Find if value is already in dictionary */
if (lpDict->n > 0)
{
for (i = 0; i < lpDict->size; i++)
if (lpDict->key[i] NE NULL)
{
if (hash EQ lpDict->hash[i])
{ /* Same hash value */
if (!lstrcmpW (lpwKey, lpDict->key[i]))
{ /* Same key */
/* Found a value: modify and return */
if (lpwVal EQ NULL
|| (lpDict->inifile <= lpwVal
&& lpwVal < (lpDict->inifile + lpDict->size)))
lpDict->val[i] = lpwVal;
else
{
if (lpDict->val[i] NE NULL)
{
free (lpDict->val[i]); lpDict->val[i] = NULL;
} // End IF
if (lpwVal NE NULL)
{
lpwVal = strdupW (lpwVal);
if (lpwVal EQ NULL)
return -1;
} // End IF
lpDict->val[i] = lpwVal;
} // End IF/ELSE
/* Value has been modified: return */
return 0;
} // End IF
} // End IF
} // End FOR/IF
} // End IF
/* Add a new value */
/* See if dictionary needs to grow */
if (lpDict->n EQ lpDict->size)
{
LPWCHAR *val; // Ptr to list of string values
LPWCHAR *key; // Ptr to list of string keys
LPUINT hash; // Ptr to list of hash values for keys
/* Reached maximum size: reallocate dictionary */
val = (LPWCHAR *) mem_double (lpDict->val, lpDict->size * sizeof (*lpDict->val));
key = (LPWCHAR *) mem_double (lpDict->key, lpDict->size * sizeof (*lpDict->key));
hash = (LPUINT) mem_double (lpDict->hash, lpDict->size * sizeof (*lpDict->hash));
if ((val EQ NULL) || (key EQ NULL) || (hash EQ NULL))
{
// Replace the values that succeeded in doubling
if (val NE NULL) lpDict->val = val;
if (key NE NULL) lpDict->key = key;
if (hash NE NULL) lpDict->hash = hash;
/* Cannot grow dictionary */
return -1;
} // End IF
lpDict->val = val;
lpDict->key = key;
lpDict->hash = hash;
/* Double size */
lpDict->size *= 2;
} // End IF
/* Insert key in the first empty slot */
for (i = 0; i < lpDict->size; i++)
if (lpDict->key[i] EQ NULL)
/* Add key here */
break;
// If the key is NULL or within the file contents, it can be
// stored directly; otherwise it must be duplicated.
if (lpwKey EQ NULL
|| (lpDict->inifile <= lpwKey
&& lpwKey < (lpDict->inifile + lpDict->size)))
lpDict->key[i] = lpwKey;
else
{
lpDict->key[i] = strdupW (lpwKey);
if (lpDict->key[i] EQ NULL)
return -1;
} // End IF/ELSE
// If the value is NULL or within the file contents, it can be
// stored directly; otherwise it must be duplicated.
if (lpwVal EQ NULL
|| (lpDict->inifile <= lpwVal
&& lpwVal < (lpDict->inifile + lpDict->size)))
lpDict->val[i] = lpwVal;
else
{
if (lpDict->val[i] NE NULL)
{
free (lpDict->val[i]); lpDict->val[i] = NULL;
} // End IF
lpDict->val[i] = strdupW (lpwVal);
if (lpDict->val[i] EQ NULL)
return -1;
} // End IF/ELSE
lpDict->hash[i] = hash;
lpDict->n++;
return 0;
} // End dictionary_set
/*--------------------------------------------------------------------------*/
static void
dictionary_set (dictionary * d, char * key, char * val)
{
int i;
unsigned hash;
if (!d || !key)
return;
/* Compute hash for this key */
hash = dictionary_hash (key);
/* Find if value is already in blackboard */
if (d->n > 0)
{
for (i = 0; i < d->size; ++i)
{
if (!d->key[i])
continue;
if (hash == d->hash[i])
{
/* Same hash value */
if (!strcmp (key, d->key[i]))
{
/* Same key */
/* Found a value: modify and return */
if (d->val[i])
free (d->val[i]);
d->val[i] = val ? strdup (val) : NULL;
/* Value has been modified: return */
return;
}
}
}
}
/* Add a new value */
/* See if dictionary needs to grow */
if (d->n == d->size)
{
/* Reached maximum size: reallocate blackboard */
d->val = (char **) mem_double (d->val, d->size * sizeof (char*));
d->key = (char **) mem_double (d->key, d->size * sizeof (char*));
d->hash = (unsigned int *) mem_double (d->hash,
d->size * sizeof (unsigned));
/* Double size */
d->size *= 2;
}
/* Insert key in the first empty slot */
for (i = 0; i < d->size; ++i)
{
if (!d->key[i])
{
/* Add key here */
break;
}
}
/* Copy key */
d->key[i] = strdup (key);
d->val[i] = val ? strdup (val) : NULL;
d->hash[i] = hash;
++d->n;
}
void Test_dictionary_hash(CuTest *tc)
{
/* NULL test */
CuAssertIntEquals(tc, 0, dictionary_hash(NULL));
}
