int init_capture_device(struct in_addr src, struct in_addr dst, char * filter)
{
int ret = -1;
char * dev_interface = NULL;
char * a_dst, *a_src;
char errbuf[PCAP_ERRBUF_SIZE];
int free_filter = 0;
a_src = estrdup(inet_ntoa(src));
a_dst = estrdup(inet_ntoa(dst));
if((filter == NULL) || (filter[0]=='\0') || (filter[0]=='0'))
{
filter = emalloc(256);
free_filter = 1;
if(islocalhost(&src) == 0)
snprintf(filter, 256-1, "ip and (src host %s and dst host %s)",
a_src, a_dst);
}
else {
if(islocalhost(&src) == 0)filter = estrdup(filter);
else filter = emalloc(1);
free_filter = 1;
}
efree(&a_dst);
efree(&a_src);
if (if_default && strlen(if_default))
ret = bpf_open_live(if_default, filter);
else if (setif(100)) {
ret = bpf_open_live(if_default, filter);
}
else {
dev_interface = pcap_lookupdev(errbuf);
sprintf(dev_interface, "%S", dev_interface);
ret = bpf_open_live(dev_interface, filter);
}
if(free_filter != 0)efree(&filter);
return ret;
}
tree_cell * nasl_islocalhost(lex_ctxt * lexic)
{
struct arglist * script_infos = lexic->script_infos;
struct in_addr * dst = plug_get_host_ip(script_infos);
tree_cell * retc;
retc = alloc_tree_cell(0, NULL);
retc->type = CONST_INT;
retc->x.i_val = islocalhost(dst);
return retc;
}
tree_cell * nasl_this_host(lex_ctxt * lexic)
{
struct arglist * script_infos = lexic->script_infos;
tree_cell * retc;
struct in_addr addr;
char hostname[255];
char * ret;
struct in_addr * ia = plug_get_host_ip(script_infos);
struct in_addr src;
retc = alloc_tree_cell(0, NULL);
retc->type = CONST_DATA;
addr = socket_get_next_source_addr(arg_get_value(script_infos, "globals"));
if ( addr.s_addr != INADDR_ANY )
{
retc->x.str_val = estrdup(inet_ntoa(addr));
retc->size = strlen(retc->x.str_val);
return retc;
}
src.s_addr = 0;
if(ia)
{
if(islocalhost(ia))
src.s_addr = ia->s_addr;
else
(void)routethrough(ia, &src);
if(src.s_addr) {
char * ret;
ret = estrdup(inet_ntoa(src));
retc->x.str_val = ret;
retc->size = strlen(ret);
return retc;
}
hostname[sizeof(hostname) - 1] = '\0';
gethostname(hostname, sizeof(hostname) - 1);
addr = nn_resolve(hostname);
ret = estrdup(inet_ntoa(addr));
retc->x.str_val = ret;
retc->size = strlen(ret);
}
return retc;
}
static void
dispatch(struct lock_msg *mp, daemonaddr_t *host)
{
int message = mp->message;
int localhost;
localhost = islocalhost(host);
if (msgtrace && debugfile) {
time_t t = time(0);
if (localhost) {
(void) fprintf(debugfile,
"%19.19s recv %-9.9s from %s (%ld)\n", ctime(&t),
lockd_msg(message), dp_addr(host), mp->pid);
} else {
(void) fprintf(debugfile,
"%19.19s recv %-9.9s from %s order %d (%ld)\n",
ctime(&t), lockd_msg(message), dp_addr(host),
mp->order, mp->pid);
}
}
DPF((stderr, "received message %d\n", message));
DPF((stderr, "from %s port %hu\n", dp_addr(host), host->sin_port));
if (!localhost)
daemon_alive(host, mp->order);
else
mp->order = order;
switch (message) {
case ALIVE:
DPF((stderr, "received ALIVE %s\n", dp_addr(host)));
/* do nothing, general "not localhost" code above does this */
break;
case UNLOCK:
DPF((stderr, "received UNLOCK\n"));
remote_unlock(mp->order, host);
break;
case GRANTED:
DPF((stderr, "received GRANTED\n"));
lock_granted(host);
break;
case WRITE_LOCK:
DPF((stderr, "received WRITE_LOCK\n"));
assert(!localhost);
remote_lock(host, mp);
break;
case READ_LOCK:
case LOCK_READ:
DPF((stderr, "received READ_LOCK\n"));
assert(localhost);
local_lock(LOCK_READ, mp, host);
break;
case LOCK_WRITE:
DPF((stderr, "received LOCK_WRITE\n"));
assert(localhost);
local_lock(LOCK_WRITE, mp, host);
break;
case LOCK_NOTLOCKED:
DPF((stderr, "received LOCK_NOTLOCKED\n"));
send_lockmsg(LOCK_ACK, (pid_t)0, host, mp->seq);
if (the_lock.type != LOCK_NOTLOCKED) {
local_unlock(mp->pid, mp->seq, NORMAL_UNLOCK);
}
break;
case LOCK_LOCKEDBY:
lockedby(host, mp->seq);
break;
case LOCK_STAT:
lock_stat();
break;
case LOCK_ACK:
/* throw message away -- this is an error to receive */
break;
}
}
static int
try_lock()
{
struct lockdaemon *ldp;
int i;
switch (the_lock.type) {
case LOCK_READ:
if (lock_wanted.type == LOCK_READ) {
i = the_lock.nholders++;
the_lock.holding_pid[i] = lock_wanted.pid;
the_lock.state = STATE_CLEAR;
DPF((stderr, "increment read lockers to %d\n",
the_lock.nholders));
take_lock(LOCK_LOCKED);
break;
}
/* write lock has to wait */
break;
case LOCK_WRITE:
/* lock has to wait until write lock is cleared */
break;
case LOCK_NOTLOCKED:
if (lock_wanted.type == LOCK_READ) {
DPF((stderr, "local locker, 1 lock holder\n"));
the_lock.holding_pid[0] = lock_wanted.pid;
the_lock.nholders = 1;
the_lock.type = LOCK_READ;
the_lock.state = STATE_CLEAR;
the_lock.remote_daemon = NULL;
take_lock(LOCK_LOCKED);
return (1);
}
if (islocalhost(&lock_wanted.remote)) {
DPF((stderr, "local locker, take write lock\n"));
/* tell everyone I'm locking */
if (lock_wanted.state != STATE_ASKED) {
for (i = 0, ldp = daemon_list; i < MAX_DAEMONS;
i++, ldp++) {
if (ldp->inuse == 0)
break;
ldp->state = STATE_ASKED;
send_lockmsg(WRITE_LOCK, (pid_t)0,
&(ldp->host), 0);
}
}
lock_wanted.state = STATE_ASKED;
check_for_write_lock();
the_lock.remote_daemon = NULL;
the_lock.state = STATE_ASKED;
return (0);
} else {
DPF((stderr, "remote locker, take write lock\n"));
the_lock.type = LOCK_WRITE;
the_lock.holder = lock_wanted.remote;
the_lock.nholders = 1;
the_lock.remote_daemon =
find_lockdaemon(&the_lock.holder);
the_lock.state = STATE_CLEAR;
/* okay to remote */
take_lock(GRANTED);
}
break;
default:
DPF((stderr, "weird lock type held - %d\n", the_lock.type));
the_lock.type = LOCK_NOTLOCKED;
break;
}
return (0);
}
static void
build_daemon_list(char *cf_file, int exe)
{
FILE *fp;
char host[1024];
int port;
int i;
struct hostent *hp;
struct lockdaemon *ldp;
if ((hp = gethostbyname("localhost")) == NULL) {
(void) fprintf(stderr, "%s: Can't find hostent for %s\n",
program, "localhost");
spcs_log("cfglockd", NULL, "couldn't find localhost");
exit(1);
}
(void) memcpy(&(localhost.sin_addr.s_addr), *(hp->h_addr_list),
sizeof (localhost.sin_addr));
if (cf_file == NULL) {
(void) endhostent();
return;
}
if (exe) {
if ((fp = popen(cf_file, "r")) == NULL) {
perror(cf_file);
(void) fprintf(stderr,
"%s: Can't open config program\n", program);
spcs_log("cfglockd", NULL, "couldn't read config");
exit(1);
}
} else {
if ((fp = fopen(cf_file, "r")) == NULL) {
perror(cf_file);
(void) fprintf(stderr, "%s: Can't open config file\n",
program);
spcs_log("cfglockd", NULL, "couldn't read config");
exit(1);
}
}
ldp = daemon_list;
while ((i = fscanf(fp, "%s %d\n", host, &port)) != EOF) {
if (host[0] == '#') /* line starting with # are comments */
continue;
if (i == 1) {
port = lock_port;
} else {
if (strcmp(host, "localhost") == 0) {
lock_port = port;
continue;
}
}
if ((hp = gethostbyname(host)) == NULL) {
(void) fprintf(stderr,
"%s: Can't find hostent for %s\n", program, host);
continue;
}
(void) memcpy(&(ldp->host.sin_addr.s_addr), *(hp->h_addr_list),
sizeof (ldp->host.sin_addr));
DPF((stderr, "daemon: %s\t%s\n",
inet_ntoa(ldp->host.sin_addr), hp->h_name));
if (islocalhost(&(ldp->host))) {
DPF((stderr, "is an alias for this host, skipping\n"));
continue;
}
ldp->host.sin_port = htons((short)port);
ldp->host.sin_family = hp->h_addrtype;
ldp->inuse = 1;
ldp->up = 1;
ldp++;
}
if (exe)
(void) pclose(fp);
else
(void) fclose(fp);
(void) endhostent();
}
