int
dir_hash_check(struct dir_hash *dh, const char *key)
{
unsigned int hash;
struct dir_hash_tnode *tn;
hash = keyhash(key) % DIR_HASH_BUCKETS;
tn = dh->tab[hash];
if (!tn) return 0;
for (;;) {
if (str_same(tn->name, key)) return 1;
if (!tn->next) return 0;
tn = tn->next;
}
}
ENTRY *hsearch(ENTRY item, ACTION action)
{
size_t hash = keyhash(item.key);
struct entry *e = lookup(item.key, hash);
if (e->item.key)
return &e->item;
if (action == FIND)
return 0;
e->item = item;
e->hash = hash;
if (++used > mask - mask/4) {
if (!resize(2*used)) {
used--;
e->item.key = 0;
return 0;
}
e = lookup(item.key, hash);
}
return &e->item;
}
int
dir_hash_open(struct dir_hash *dh, const char *path)
{
struct dir_array *da;
struct dir_hash_tnode *tn;
struct dir_hash_tnode *tp;
char *name;
unsigned int hash;
da = &dh->da;
if (!dir_array_open(da, path)) return 0;
if (da->n == 0) return 1;
for (;;) {
if (!dir_array_next(da, &name)) break;
hash = keyhash(name) % DIR_HASH_BUCKETS;
tp = dh->tab[hash];
for (;;) {
if (!tp) break;
if (tp->next)
tp = tp->next;
else
break;
}
tn = alloc(sizeof(struct dir_hash_tnode));
if (!tn) {
dir_hash_free(dh);
return 0;
}
tn->name = name;
tn->next = 0;
if (!tp)
dh->tab[hash] = tn;
else
tp->next = tn;
}
dir_array_rewind(da);
return 1;
}
static int open_listener(struct listen_config_t *lc)
{
struct listen_t *l;
int i;
l = listener_alloc();
l->id = lc->id;
l->hidden = lc->hidden;
l->corepeer = lc->corepeer;
l->client_flags = lc->client_flags;
l->clients_max = lc->clients_max;
l->portaccount = port_accounter_alloc();
/* Pick first of the AIs for this listen definition */
l->addr_s = strsockaddr( lc->ai->ai_addr, lc->ai->ai_addrlen );
l->name = hstrdup(lc->name);
l->portnum = lc->portnum;
l->ai_protocol = lc->ai->ai_protocol;
l->listener_id = keyhash(l->addr_s, strlen(l->addr_s), 0);
l->listener_id = keyhash(&lc->ai->ai_socktype, sizeof(lc->ai->ai_socktype), l->listener_id);
l->listener_id = keyhash(&lc->ai->ai_protocol, sizeof(lc->ai->ai_protocol), l->listener_id);
hlog(LOG_DEBUG, "Opening listener %d/%d '%s': %s", lc->id, l->listener_id, lc->name, l->addr_s);
if (lc->ai->ai_socktype == SOCK_DGRAM &&
lc->ai->ai_protocol == IPPROTO_UDP) {
/* UDP listenting is not quite same as TCP listening.. */
i = open_udp_listener(l, lc->ai);
} else if (lc->ai->ai_socktype == SOCK_STREAM && lc->ai->ai_protocol == IPPROTO_TCP) {
/* TCP listenting... */
i = open_tcp_listener(l, lc->ai, "TCP");
#ifdef USE_SCTP
} else if (lc->ai->ai_socktype == SOCK_STREAM &&
lc->ai->ai_protocol == IPPROTO_SCTP) {
i = open_tcp_listener(l, lc->ai, "SCTP");
if (i >= 0)
i = sctp_set_listen_params(l);
#endif
} else {
hlog(LOG_ERR, "Unsupported listener protocol for '%s'", l->name);
listener_free(l);
return -1;
}
if (i < 0) {
hlog(LOG_DEBUG, "... failed");
listener_free(l);
return -1;
}
hlog(LOG_DEBUG, "... ok, bound");
/* Set up an SSL context if necessary */
#ifdef USE_SSL
if (lc->keyfile && lc->certfile) {
l->ssl = ssl_alloc();
if (ssl_create(l->ssl, (void *)l)) {
hlog(LOG_ERR, "Failed to create SSL context for '%s*': %s", lc->name, l->addr_s);
listener_free(l);
return -1;
}
if (ssl_certificate(l->ssl, lc->certfile, lc->keyfile)) {
hlog(LOG_ERR, "Failed to load SSL key and certificates for '%s*': %s", lc->name, l->addr_s);
listener_free(l);
return -1;
}
/* optional client cert validation */
if (lc->cafile) {
if (ssl_ca_certificate(l->ssl, lc->cafile, 2)) {
hlog(LOG_ERR, "Failed to load trusted SSL CA certificates for '%s*': %s", lc->name, l->addr_s);
listener_free(l);
return -1;
}
}
hlog(LOG_INFO, "SSL initialized for '%s': %s%s", lc->name, l->addr_s, (lc->cafile) ? " (client validation enabled)" : "");
}
#endif
/* Copy access lists */
if (lc->acl)
l->acl = acl_dup(lc->acl);
/* Copy filter definitions */
listener_copy_filters(l, lc);
hlog(LOG_DEBUG, "... adding %s to listened sockets", l->addr_s);
// put (first) in the list of listening sockets
l->next = listen_list;
l->prevp = &listen_list;
if (listen_list)
listen_list->prevp = &l->next;
listen_list = l;
return 0;
}
