Return to serv_hash.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / iftop

Annotation of embedaddon/iftop/serv_hash.c, revision 1.1

1.1     ! misho       1: /* hash table */
        !             2: 
        !             3: #include <stdio.h>
        !             4: #include <stdlib.h>
        !             5: #include <netdb.h>
        !             6: #include "serv_hash.h"
        !             7: #include "hash.h"
        !             8: #include "iftop.h"
        !             9: 
        !            10: // Deliberately not a power of 2 or 10
        !            11: #define hash_table_size 123
        !            12: 
        !            13: int serv_hash_compare(void* a, void* b) {
        !            14:     ip_service* aa = (ip_service*)a;
        !            15:     ip_service* bb = (ip_service*)b;
        !            16:     return (aa->port == bb->port &&
        !            17:             aa->protocol == bb->protocol);
        !            18: }
        !            19: 
        !            20: int serv_hash_hash(void* key) {
        !            21:     ip_service* serv = (ip_service*)key;
        !            22:     return serv->protocol % hash_table_size;
        !            23: }
        !            24: 
        !            25: void* serv_hash_copy_key(void* orig) {
        !            26:     ip_service* copy;
        !            27:     copy = xmalloc(sizeof *copy);
        !            28:     *copy = *(ip_service*)orig;
        !            29:     return copy;
        !            30: }
        !            31: 
        !            32: void serv_hash_delete_key(void* key) {
        !            33:     free(key);
        !            34: }
        !            35: 
        !            36: /*
        !            37:  * Allocate and return a hash
        !            38:  */
        !            39: hash_type* serv_hash_create() {
        !            40:     hash_type* hash_table;
        !            41:     hash_table = xcalloc(hash_table_size, sizeof *hash_table);
        !            42:     hash_table->size = hash_table_size;
        !            43:     hash_table->compare = &serv_hash_compare;
        !            44:     hash_table->hash = &serv_hash_hash;
        !            45:     hash_table->delete_key = &serv_hash_delete_key;
        !            46:     hash_table->copy_key = &serv_hash_copy_key;
        !            47:     hash_initialise(hash_table);
        !            48:     return hash_table;
        !            49: }
        !            50: 
        !            51: void serv_hash_initialise(hash_type* sh) {
        !            52:   struct servent* ent;
        !            53:   struct protoent* pent;
        !            54:   ip_service* service;
        !            55:   setprotoent(1);
        !            56:   while((ent = getservent()) != NULL) {
        !            57:     pent = getprotobyname(ent->s_proto);
        !            58:     if(pent != NULL) {
        !            59:       service = xmalloc(sizeof(ip_service));
        !            60:       service->port = ntohs(ent->s_port);
        !            61:       service->protocol = pent->p_proto;
        !            62:       hash_insert(sh, service, xstrdup(ent->s_name));
        !            63:     }
        !            64:   }
        !            65:   endprotoent();
        !            66: }