void run_and_record_output(pcap_list_t *pkt_list, char *pcap_base, uint16_t num_pcaps, int debug) {
int *sockfds = init_sockets(pcap_base, num_pcaps);
feed_packets(sockfds, pkt_list);
close_sockets(sockfds, num_pcaps);
/* Sleep a bit to allow the remaining processes to finish */
sleep(2);
}
int main(int argc, char **argv){
if (argc != 5){
printf("Wrong args\n");
exit(0);
}
fd = open(argv[4], O_WRONLY|O_CREAT);
if (fd == -1){
printf("Error opening log file\n");
exit(1);
}
connected = 0;
all_get = 0;
start_seq_num = (unsigned int)rand();
expected_seq = 0;
last_seq = 0;
passive_fin = 0;
create_sockets();
ini_send_addr(argv[2]);
int recv_port = ini_recv_addr();
conn_server(argv[1], argv[2], argv[3], recv_port);
printf("Connection established!\n");
receive_data(argv[1], argv[2], argv[3], recv_port);
disconnect(argv[1], argv[2], argv[3], recv_port);
close_sockets();
close(fd);
return 0;
}
BOOL
send_null_session_msg (int fd)
{
ssize_t ret;
uint32 blank = 0;
size_t len = 4;
size_t nwritten = 0;
char *buffer = (char *) ␣
while (nwritten < len)
{
ret = write_socket (fd, buffer + nwritten, len - nwritten);
if (ret <= 0)
{
DEBUG (0,
("send_null_session_msg: Error writing %d bytes to client. %d. Exiting\n",
(int) len, (int) ret));
close_sockets ();
exit (1);
}
nwritten += ret;
}
DEBUG (10, ("send_null_session_msg: sent 4 null bytes to client.\n"));
return True;
}
void exit_func ()
{
pthread_join (node_send_thread, NULL);
close_sockets ();
cout << "Total host entries freed: " << hosts.free_list() << endl;
cout << "Total port entries freed: " << ports.free_list() << endl;
cout << "Total links entries freed: " << links.free_list() << endl;
cout << "Total reply entries freed: " << sw_replys.free_list() << endl;
}
/* clear all status and exit program. */
static void
close_session()
{
flushph1();
close_sockets();
backupsa_clean();
plog(LLV_INFO, LOCATION, NULL, "racoon shutdown\n");
exit(0);
}
void main_err(char *message)
{
fprintf(stderr,"%s\n",message);
if( errno )
perror(NULL);
close_sockets();
exit(1);
}
void signal_fatal(int sig)
{
signal(sig,SIG_DFL);
nlog("A fatal signal (%d) was caught.", sig);
if(crash_save){
close_sockets(0);
nlog("All sockets were closed.");
kill(getpid(),SIGABRT);
}
/*return SIG_RET_VAL;*/
}
int receiver(McastResult** test_results, int n_addr, int n_stream, int test_inc, char *start_addr, int start_port, int buf_len, int mbps, int timeout, int verbose){
// test_inc = 0, just do one test
// test_inc = n, test 1,1+n, 1+2n... n_addr addresses.
int n_tests;
n_tests = 3 + n_addr/(test_inc);
sockets = malloc(sizeof(int) * n_addr * n_stream + sizeof(int));
sockets[n_addr * n_stream] = -1;
int j, ind = 0;
open_sockets(n_addr, n_stream,start_port, start_addr);
j = 1;
//test level.
n_tests = 0;
int jitterSize = 0;
while(j <= n_addr ){
/* hack needed for vms... */
if (n_tests > 0 && n_tests % 15 == 0){
close_sockets();
open_sockets(n_addr, n_stream,start_port, start_addr);
}
int tout = timeout;
if (n_tests == 0 && restarted == 0) tout = 300;
test_results[ind] = run_tests(j, n_stream, start_addr, start_port, buf_len, &jitterSize, tout,verbose);
if (test_results[ind] == NULL){
break;
}
if (verbose == 1) disp_results(test_results[ind]);
n_tests++;
ind++;
if (j == n_addr) break;
if (j == 1 && test_inc != 1) j = 0;
j += test_inc;
if (j > n_addr) j = n_addr;
}
close_sockets();
free(sockets);
restarted = 1;
return n_tests;
}
// Main function here.
int main() {
putchar('\n');
printf("The Server %c is up and running.\n", SERVER_NAME_CHAR);
set_up_UDP_socket();
read_file();
set_up_TCP_socket();
connect_to_client_over_TCP();
send_neighbor_info_over_TCP();
receive_network_topology_over_UDP();
close_sockets();
return 0;
}
/* clear all status and exit program. */
static void
close_session()
{
#ifdef ENABLE_FASTQUIT
flushph2();
#endif
flushph1();
close_sockets();
backupsa_clean();
plog(LLV_INFO, LOCATION, NULL, "racoon shutdown\n");
exit(0);
}
void fatal_error(char *message)
{
fprintf(stderr,"%s\n",message);
if( errno )
perror(NULL);
fflush(stderr);
close(client_socket);
if( !will_fork ) {
close_sockets();
abort();
} else
exit(-1);
}
BOOL send_smb(int fd,char *buffer)
{
size_t len;
size_t nwritten=0;
ssize_t ret;
len = smb_len(buffer) + 4;
while (nwritten < len)
{
ret = write_socket(fd,buffer+nwritten,len - nwritten);
if (ret <= 0)
{
DEBUG(0,("Error writing %d bytes to client. %d. Exiting\n",(int)len,(int)ret));
close_sockets();
exit(1);
}
nwritten += ret;
}
return True;
}
void
prim_armageddon(PRIM_PROTOTYPE)
{
char buf[BUFFER_LEN];
/* ( s<message> -- ) */
CHECKOP(1);
oper1 = POP();
if (mlev < LBOY)
abort_interp("W4 primitive.");
if (oper1->type != PROG_STRING)
abort_interp("String expected.");
sprintf(buf, "\r\nImmediate shutdown by %s.\r\n", NAME(PSafe));
if (oper1->data.string) {
strcat(buf, SYSWHITE MARK SYSNORMAL);
strcat(buf, oper1->data.string->data);
strcat(buf, "\r\n");
}
CLEAR(oper1);
log_status("DDAY(MUF: %d): by %s(%d)\n", program,
OkObj(player) ? NAME(player) : "(login)", player);
fprintf(stderr, "DDAY(MUF: %d): by %s(%d)\n", program,
OkObj(player) ? NAME(player) : "(login)", player);
close_sockets(buf);
#ifdef SPAWN_HOST_RESOLVER
kill_resolver();
#endif
#ifdef USE_RESLVD
reslvd_close();
#endif
exit(1);
}
/** Connect to another talk client. */
int TalkConnection::connect()
{
ktalk_debug("Waiting to connect");
do {
errno = 0;
if (::connect(sockt, (const sockaddr *)(&lookup_addr), sizeof (struct talk_addr)) != -1)
return 1;
} while (errno == EINTR);
if (errno == ECONNREFUSED) {
/*
* The caller gave up, but his invitation somehow
* was not cleared. Clear it and initiate an
* invitation. (We know there are no newer invitations,
* the talkd works LIFO.)
*/
ktalk_debug("ECONNREFUSED");
ctl_transact(DELETE, 0);
close_sockets();
return 0;
}
p_error("Unable to connect with initiator");
/*NOTREACHED*/
return 0;
}
static void lock_cachefile(int cachefile, int type)
{
struct flock fl = {
.l_len = 0,
.l_start = 0,
.l_whence = SEEK_SET,
};
fl.l_pid = getpid();
fl.l_type = type;
if (verbose)
output(2, "waiting on lock for cachefile\n");
if (fcntl(cachefile, F_SETLKW, &fl) == -1) {
perror("fcntl F_SETLKW");
exit(1);
}
if (verbose)
output(2, "took lock for cachefile\n");
}
static void unlock_cachefile(int cachefile)
{
struct flock fl = {
.l_len = 0,
.l_start = 0,
.l_whence = SEEK_SET,
};
fl.l_pid = getpid();
fl.l_type = F_UNLCK;
if (fcntl(cachefile, F_SETLK, &fl) == -1) {
perror("fcntl F_UNLCK F_SETLK ");
exit(1);
}
if (verbose)
output(2, "dropped lock for cachefile\n");
}
static void generate_sockets(void)
{
int fd, n;
int cachefile;
unsigned int nr_to_create = NR_SOCKET_FDS;
unsigned int buffer[3];
cachefile = creat(cachefilename, S_IWUSR|S_IRUSR);
if (cachefile < 0) {
outputerr("Couldn't open cachefile for writing! (%s)\n",
strerror(errno));
exit(EXIT_FAILURE);
}
lock_cachefile(cachefile, F_WRLCK);
/*
* Don't loop forever if all protos all are disabled.
*/
if (!do_specific_proto) {
for (n = 0; n < (int)ARRAY_SIZE(no_protos); n++) {
if (!no_protos[n])
break;
}
if (n >= (int)ARRAY_SIZE(no_protos))
nr_to_create = 0;
}
while (nr_to_create > 0) {
struct socket_triplet st;
if (shm->exit_reason != STILL_RUNNING) {
close(cachefile);
return;
}
for (st.family = 0; st.family < TRINITY_PF_MAX; st.family++) {
if (do_specific_proto == TRUE)
st.family = specific_proto;
if (get_proto_name(st.family) == NULL)
goto skip;
BUG_ON(st.family >= ARRAY_SIZE(no_protos));
if (no_protos[st.family])
goto skip;
if (sanitise_socket_triplet(&st) == -1)
rand_proto_type(&st);
fd = open_socket(st.family, st.type, st.protocol);
if (fd > -1) {
nr_to_create--;
buffer[0] = st.family;
buffer[1] = st.type;
buffer[2] = st.protocol;
n = write(cachefile, &buffer, sizeof(int) * 3);
if (n == -1) {
outputerr("something went wrong writing the cachefile!\n");
exit(EXIT_FAILURE);
}
if (nr_to_create == 0)
goto done;
} else {
//outputerr("Couldn't open family:%d (%s)\n", st.family, get_proto_name(st.family));
}
skip:
/* check for ctrl-c */
if (shm->exit_reason != STILL_RUNNING)
return;
//FIXME: If we've passed -P and we're spinning here without making progress
// then we should abort after a few hundred loops.
}
}
done:
unlock_cachefile(cachefile);
output(1, "created %d sockets\n", nr_sockets);
close(cachefile);
}
void close_sockets(void)
{
unsigned int i;
int fd;
int r = 0;
struct linger ling = { .l_onoff = FALSE, .l_linger = 0 };
for (i = 0; i < nr_sockets; i++) {
//FIXME: This is a workaround for a weird bug where we hang forevre
// waiting for bluetooth sockets when we setsockopt.
// Hopefully at some point we can remove this when someone figures out what's going on.
if (shm->sockets[i].triplet.family == PF_BLUETOOTH)
continue;
/* Grab an fd, and nuke it before someone else uses it. */
fd = shm->sockets[i].fd;
shm->sockets[i].fd = 0;
/* disable linger */
r = setsockopt(fd, SOL_SOCKET, SO_LINGER, &ling, sizeof(struct linger));
if (r)
perror("setsockopt");
r = shutdown(fd, SHUT_RDWR);
if (r)
perror("shutdown");
if (close(fd) != 0)
output(1, "failed to close socket [%d:%d:%d].(%s)\n",
shm->sockets[i].triplet.family,
shm->sockets[i].triplet.type,
shm->sockets[i].triplet.protocol,
strerror(errno));
}
nr_sockets = 0;
}
void open_sockets(void)
{
int cachefile;
unsigned int domain, type, protocol;
unsigned int buffer[3];
int bytesread=-1;
int fd;
cachefile = open(cachefilename, O_RDONLY);
if (cachefile < 0) {
output(1, "Couldn't find socket cachefile. Regenerating.\n");
generate_sockets();
return;
}
lock_cachefile(cachefile, F_RDLCK);
while (bytesread != 0) {
bytesread = read(cachefile, buffer, sizeof(int) * 3);
if (bytesread == 0)
break;
domain = buffer[0];
type = buffer[1];
protocol = buffer[2];
if ((do_specific_proto == TRUE && domain != specific_proto) ||
(domain < ARRAY_SIZE(no_protos) && no_protos[domain] == TRUE)) {
output(1, "ignoring socket cachefile due to specific "
"protocol request (or protocol disabled), "
"and stale data in cachefile.\n");
regenerate:
unlock_cachefile(cachefile); /* drop the reader lock. */
close(cachefile);
unlink(cachefilename);
generate_sockets();
return;
}
fd = open_socket(domain, type, protocol);
if (fd < 0) {
output(1, "Cachefile is stale. Need to regenerate.\n");
close_sockets();
goto regenerate;
}
/* check for ctrl-c */
if (shm->exit_reason != STILL_RUNNING) {
close(cachefile);
return;
}
}
if (nr_sockets < NR_SOCKET_FDS) {
output(1, "Insufficient sockets in cachefile (%d). Regenerating.\n", nr_sockets);
goto regenerate;
}
output(1, "%d sockets created based on info from socket cachefile.\n", nr_sockets);
unlock_cachefile(cachefile);
close(cachefile);
}
/****************************************************************************
main program
****************************************************************************/
int main(int argc,char *argv[])
{
fstring base_directory;
char *pname = argv[0];
int opt;
extern FILE *dbf;
extern char *optarg;
extern int optind;
pstring query_host;
BOOL nt_domain_logon = False;
static pstring servicesf = CONFIGFILE;
pstring term_code;
char *p;
#ifdef KANJI
pstrcpy(term_code, KANJI);
#else /* KANJI */
*term_code = 0;
#endif /* KANJI */
*query_host = 0;
*base_directory = 0;
DEBUGLEVEL = 2;
setup_logging(pname,True);
TimeInit();
charset_initialise();
pid = getpid();
uid = getuid();
gid = getgid();
mid = pid + 100;
myumask = umask(0);
umask(myumask);
if (getenv("USER"))
{
pstrcpy(username,getenv("USER"));
/* modification to support userid%passwd syntax in the USER var
25.Aug.97, [email protected] */
if ((p=strchr(username,'%')))
{
*p = 0;
pstrcpy(password,p+1);
got_pass = True;
memset(strchr(getenv("USER"),'%')+1,'X',strlen(password));
}
strupper(username);
}
/* modification to support PASSWD environmental var
25.Aug.97, [email protected] */
if (getenv("PASSWD"))
pstrcpy(password,getenv("PASSWD"));
if (*username == 0 && getenv("LOGNAME"))
{
pstrcpy(username,getenv("LOGNAME"));
strupper(username);
}
if (argc < 2)
{
usage(pname);
exit(1);
}
if (*argv[1] != '-')
{
pstrcpy(service, argv[1]);
/* Convert any '/' characters in the service name to '\' characters */
string_replace( service, '/','\\');
argc--;
argv++;
if (count_chars(service,'\\') < 3)
{
usage(pname);
printf("\n%s: Not enough '\\' characters in service\n",service);
exit(1);
}
if (argc > 1 && (*argv[1] != '-'))
{
got_pass = True;
pstrcpy(password,argv[1]);
memset(argv[1],'X',strlen(argv[1]));
argc--;
argv++;
}
}
while ((opt =
getopt(argc, argv,"s:B:O:M:S:i:Nn:d:Pp:l:hI:EB:U:L:t:m:W:T:D:c:")) != EOF)
switch (opt)
{
case 'm':
max_protocol = interpret_protocol(optarg,max_protocol);
break;
case 'O':
pstrcpy(user_socket_options,optarg);
break;
case 'S':
pstrcpy(desthost,optarg);
strupper(desthost);
nt_domain_logon = True;
break;
case 'B':
iface_set_default(NULL,optarg,NULL);
break;
case 'D':
pstrcpy(base_directory,optarg);
break;
case 'i':
pstrcpy(scope,optarg);
break;
case 'U':
{
char *lp;
pstrcpy(username,optarg);
if ((lp=strchr(username,'%')))
{
*lp = 0;
pstrcpy(password,lp+1);
got_pass = True;
memset(strchr(optarg,'%')+1,'X',strlen(password));
}
}
break;
case 'W':
pstrcpy(workgroup,optarg);
break;
case 'E':
dbf = stderr;
break;
case 'I':
{
dest_ip = *interpret_addr2(optarg);
if (zero_ip(dest_ip)) exit(1);
have_ip = True;
}
break;
case 'n':
pstrcpy(myname,optarg);
break;
case 'N':
got_pass = True;
break;
case 'd':
if (*optarg == 'A')
DEBUGLEVEL = 10000;
else
DEBUGLEVEL = atoi(optarg);
break;
case 'l':
slprintf(debugf,sizeof(debugf)-1,"%s.client",optarg);
break;
case 'p':
port = atoi(optarg);
break;
case 'c':
cmdstr = optarg;
got_pass = True;
break;
case 'h':
usage(pname);
exit(0);
break;
case 's':
pstrcpy(servicesf, optarg);
break;
case 't':
pstrcpy(term_code, optarg);
break;
default:
usage(pname);
exit(1);
}
if (!*query_host && !*service)
{
usage(pname);
exit(1);
}
DEBUG(3,("%s client started (version %s)\n",timestring(),VERSION));
if(!get_myname(myhostname,NULL))
{
DEBUG(0,("Failed to get my hostname.\n"));
}
if (!lp_load(servicesf,True)) {
fprintf(stderr, "Can't load %s - run testparm to debug it\n", servicesf);
}
codepage_initialise(lp_client_code_page());
interpret_coding_system(term_code);
if (*workgroup == 0)
pstrcpy(workgroup,lp_workgroup());
load_interfaces();
get_myname((*myname)?NULL:myname,NULL);
strupper(myname);
#ifdef NTDOMAIN
if (nt_domain_logon)
{
int ret = 0;
slprintf(service,sizeof(service), "\\\\%s\\IPC$",query_host);
strupper(service);
connect_as_ipc = True;
DEBUG(5,("NT Domain Logon. Service: %s\n", service));
if (cli_open_sockets(port))
{
if (!cli_send_login(NULL,NULL,True,True,NULL)) return(1);
do_nt_login(desthost, myhostname, Client, cnum);
cli_send_logout();
close_sockets();
}
return(ret);
}
#endif
if (cli_open_sockets(port))
{
if (!process(base_directory))
{
close_sockets();
return(1);
}
close_sockets();
}
else
return(1);
return(0);
}
/*
* Call the smbfs ioctl to install a connection socket,
* then wait for a signal to reconnect. Note that we do
* not exit after open_sockets() or send_login() errors,
* as the smbfs mount would then have no way to recover.
*/
static void
send_fs_socket(char *mount_point, char *inbuf, char *outbuf)
{
int fd, closed = 0, res = 1;
while (1)
{
if ((fd = open(mount_point, O_RDONLY)) < 0)
{
DEBUG(0, ("smbmount: can't open %s\n", mount_point));
break;
}
/*
* Call the ioctl even if we couldn't get a socket ...
* there's no point in making smbfs wait for a timeout.
*/
conn_options.fd = -1;
if (res)
conn_options.fd = Client;
res = ioctl(fd, SMB_IOC_NEWCONN, &conn_options);
if (res != 0)
{
DEBUG(0, ("smbmount: ioctl failed, res=%d\n", res));
}
close_sockets();
close(fd);
/*
* Close all open files if we haven't done so yet.
*/
#ifndef SMBFS_DEBUG
if (!closed)
{
closed = 1;
close_our_files();
}
#endif
/*
* Wait for a signal from smbfs ...
*/
signal(SIGUSR1, &usr1_handler);
pause();
DEBUG(0, ("smbmount: got signal, getting new socket\n"));
res = cli_open_sockets(port);
if (!res)
{
DEBUG(0, ("smbmount: can't open sockets\n"));
continue;
}
res = mount_send_login(inbuf, outbuf);
if (!res)
{
DEBUG(0, ("smbmount: login failed\n"));
}
}
DEBUG(0, ("smbmount: exit\n"));
exit(1);
}
int main(int argc, char* argv[])
{
int ret = EXIT_SUCCESS;
int childstatus;
pid_t pid;
const char taskname[13]="trinity-main";
outputstd("Trinity " VERSION " Dave Jones <*****@*****.**>\n");
progname = argv[0];
initpid = getpid();
page_size = getpagesize();
num_online_cpus = sysconf(_SC_NPROCESSORS_ONLN);
max_children = num_online_cpus; /* possibly overridden in params. */
if (init_random() == FALSE)
exit(EXIT_FAILURE);
set_seed(0);
select_syscall_tables();
create_shm();
/* We do this before the parse_args because --fds will need to
* operate on it when implemented.
*/
setup_fd_providers();
parse_args(argc, argv);
init_uids();
change_tmp_dir();
init_logging();
init_shm();
kernel_taint_initial = check_tainted();
if (kernel_taint_initial != 0)
output(0, "Kernel was tainted on startup. Will ignore flags that are already set.\n");
if (munge_tables() == FALSE) {
ret = EXIT_FAILURE;
goto out;
}
if (show_syscall_list == TRUE) {
dump_syscall_tables();
goto out;
}
init_syscalls();
if (show_ioctl_list == TRUE) {
dump_ioctls();
goto out;
}
do_uid0_check();
if (do_specific_domain == TRUE)
find_specific_domain(specific_domain_optarg);
setup_initial_mappings();
parse_devices();
pids_init();
setup_main_signals();
/* check if we ctrl'c or something went wrong during init. */
if (shm->exit_reason != STILL_RUNNING)
goto cleanup_fds;
init_watchdog();
/* do an extra fork so that the watchdog and the children don't share a common parent */
fflush(stdout);
pid = fork();
if (pid == 0) {
shm->mainpid = getpid();
setup_main_signals();
no_bind_to_cpu = RAND_BOOL();
output(0, "Main thread is alive.\n");
prctl(PR_SET_NAME, (unsigned long) &taskname);
set_seed(0);
if (open_fds() == FALSE) {
if (shm->exit_reason != STILL_RUNNING)
panic(EXIT_FD_INIT_FAILURE); // FIXME: Later, push this down to multiple EXIT's.
exit_main_fail();
}
if (dropprivs == TRUE) //FIXME: Push down into child processes later.
drop_privs();
main_loop();
shm->mainpid = 0;
_exit(EXIT_SUCCESS);
}
/* wait for main loop process to exit. */
(void)waitpid(pid, &childstatus, 0);
/* wait for watchdog to exit. */
waitpid(watchdog_pid, &childstatus, 0);
output(0, "Ran %ld syscalls. Successes: %ld Failures: %ld\n",
shm->stats.total_syscalls_done - 1, shm->stats.successes, shm->stats.failures);
cleanup_fds:
close_sockets();
destroy_initial_mappings();
shutdown_logging();
ret = set_exit_code(shm->exit_reason);
out:
exit(ret);
}
void server_shutdown(int signal)
{
fprintf(stderr,"Caught signal %d.\n", signal);
close_sockets();
exit(0);
}
int main(int argc, char* argv[])
{
int ret = EXIT_SUCCESS;
int childstatus;
unsigned int i;
outputstd("Trinity v" __stringify(VERSION) " Dave Jones <*****@*****.**>\n");
progname = argv[0];
initpid = getpid();
page_size = getpagesize();
num_online_cpus = sysconf(_SC_NPROCESSORS_ONLN);
select_syscall_tables();
if (create_shm())
exit(EXIT_FAILURE);
parse_args(argc, argv);
outputstd("Done parsing arguments.\n");
if (kernel_taint_mask != (int)0xFFFFFFFF) {
outputstd("Custom kernel taint mask has been specified: 0x%08x (%d).\n", kernel_taint_mask, kernel_taint_mask);
}
if (user_specified_children != 0)
max_children = user_specified_children;
else
max_children = sysconf(_SC_NPROCESSORS_ONLN);
if (max_children > MAX_NR_CHILDREN) {
outputerr("Increase MAX_NR_CHILDREN!\n");
exit(EXIT_FAILURE);
}
setup_shm_postargs();
if (logging == TRUE)
open_logfiles();
if (munge_tables() == FALSE) {
ret = EXIT_FAILURE;
goto out;
}
if (show_syscall_list == TRUE) {
dump_syscall_tables();
goto out;
}
init_syscalls();
if (show_ioctl_list == TRUE) {
dump_ioctls();
goto out;
}
if (getuid() == 0) {
if (dangerous == TRUE) {
outputstd("DANGER: RUNNING AS ROOT.\n");
outputstd("Unless you are running in a virtual machine, this could cause serious problems such as overwriting CMOS\n");
outputstd("or similar which could potentially make this machine unbootable without a firmware reset.\n\n");
outputstd("ctrl-c now unless you really know what you are doing.\n");
for (i = 10; i > 0; i--) {
outputstd("Continuing in %d seconds.\r", i);
(void)fflush(stdout);
sleep(1);
}
} else {
outputstd("Don't run as root (or pass --dangerous if you know what you are doing).\n");
exit(EXIT_FAILURE);
}
}
if (do_specific_proto == TRUE)
find_specific_proto(specific_proto_optarg);
init_buffers();
parse_devices();
pids_init();
setup_main_signals();
kernel_taint_initial = check_tainted();
if (kernel_taint_initial != 0) {
output(0, "Kernel was tainted on startup. Will ignore flags that are already set.\n");
}
change_tmp_dir();
/* check if we ctrl'c or something went wrong during init. */
if (shm->exit_reason != STILL_RUNNING)
goto cleanup_fds;
init_watchdog();
do_main_loop();
/* Shutting down. */
waitpid(watchdog_pid, &childstatus, 0);
output(0, "\nRan %ld syscalls. Successes: %ld Failures: %ld\n",
shm->total_syscalls_done - 1, shm->successes, shm->failures);
ret = EXIT_SUCCESS;
cleanup_fds:
close_sockets();
destroy_global_mappings();
if (logging == TRUE)
close_logfiles();
out:
exit(ret);
}
TalkConnection::~TalkConnection()
{
close_sockets();
}
static void lock_cachefile(int cachefile, int type)
{
struct flock fl = {
.l_len = 0,
.l_start = 0,
.l_whence = SEEK_SET,
};
fl.l_pid = getpid();
fl.l_type = type;
if (verbose)
output(2, "waiting on lock for cachefile\n");
if (fcntl(cachefile, F_SETLKW, &fl) == -1) {
perror("fcntl F_SETLKW");
exit_main_fail();
}
if (verbose)
output(2, "took lock for cachefile\n");
}
static void unlock_cachefile(int cachefile)
{
struct flock fl = {
.l_len = 0,
.l_start = 0,
.l_whence = SEEK_SET,
};
fl.l_pid = getpid();
fl.l_type = F_UNLCK;
if (fcntl(cachefile, F_SETLK, &fl) == -1) {
perror("fcntl F_UNLCK F_SETLK ");
exit_main_fail();
}
if (verbose)
output(2, "dropped lock for cachefile\n");
}
static unsigned int valid_proto(unsigned int family)
{
const char *famstr;
famstr = get_proto_name(family);
/* Not used for creating sockets. */
if (strncmp(famstr, "PF_UNSPEC", 9) == 0)
return FALSE;
if (strncmp(famstr, "PF_BRIDGE", 9) == 0)
return FALSE;
if (strncmp(famstr, "PF_SECURITY", 11) == 0)
return FALSE;
/* Not actually implemented (or now removed). */
if (strncmp(famstr, "PF_NETBEUI", 10) == 0)
return FALSE;
if (strncmp(famstr, "PF_ASH", 6) == 0)
return FALSE;
if (strncmp(famstr, "PF_ECONET", 9) == 0)
return FALSE;
if (strncmp(famstr, "PF_SNA", 6) == 0)
return FALSE;
if (strncmp(famstr, "PF_WANPIPE", 10) == 0)
return FALSE;
/* Needs root. */
if (orig_uid != 0) {
if (strncmp(famstr, "PF_KEY", 6) == 0)
return FALSE;
if (strncmp(famstr, "PF_PACKET", 9) == 0)
return FALSE;
if (strncmp(famstr, "PF_LLC", 6) == 0)
return FALSE;
}
return TRUE;
}
static int generate_sockets(void)
{
int fd, n, ret = FALSE;
int cachefile;
unsigned int nr_to_create = NR_SOCKET_FDS;
unsigned int buffer[3];
cachefile = creat(cachefilename, S_IWUSR|S_IRUSR);
if (cachefile == -1)
outputerr("Couldn't open cachefile for writing! (%s)\n", strerror(errno));
else
lock_cachefile(cachefile, F_WRLCK);
/*
* Don't loop forever if all protos all are disabled.
*/
if (!do_specific_proto) {
for (n = 0; n < (int)ARRAY_SIZE(no_protos); n++) {
if (!no_protos[n])
break;
}
if (n >= (int)ARRAY_SIZE(no_protos))
nr_to_create = 0;
}
while (nr_to_create > 0) {
struct socket_triplet st;
for (st.family = 0; st.family < TRINITY_PF_MAX; st.family++) {
/* check for ctrl-c again. */
if (shm->exit_reason != STILL_RUNNING)
goto out_unlock;
if (do_specific_proto == TRUE) {
st.family = specific_proto;
//FIXME: If we've passed -P and we're spinning here without making progress
// then we should abort after a few hundred loops.
}
if (get_proto_name(st.family) == NULL)
continue;
if (valid_proto(st.family) == FALSE) {
if (do_specific_proto == TRUE) {
outputerr("Can't do protocol %s\n", get_proto_name(st.family));
goto out_unlock;
} else {
continue;
}
}
BUG_ON(st.family >= ARRAY_SIZE(no_protos));
if (no_protos[st.family])
continue;
if (sanitise_socket_triplet(&st) == -1)
rand_proto_type(&st);
fd = open_socket(st.family, st.type, st.protocol);
if (fd > -1) {
nr_to_create--;
if (cachefile != -1) {
buffer[0] = st.family;
buffer[1] = st.type;
buffer[2] = st.protocol;
n = write(cachefile, &buffer, sizeof(int) * 3);
if (n == -1) {
outputerr("something went wrong writing the cachefile!\n");
goto out_unlock;
}
}
if (nr_to_create == 0)
goto done;
} else {
//outputerr("Couldn't open family:%d (%s)\n", st.family, get_proto_name(st.family));
}
}
}
done:
ret = TRUE;
output(1, "created %d sockets\n", nr_sockets);
out_unlock:
if (cachefile != -1) {
unlock_cachefile(cachefile);
close(cachefile);
}
return ret;
}
void close_sockets(void)
{
unsigned int i;
int fd;
struct linger ling = { .l_onoff = FALSE, .l_linger = 0 };
for (i = 0; i < nr_sockets; i++) {
//FIXME: This is a workaround for a weird bug where we hang forevre
// waiting for bluetooth sockets when we setsockopt.
// Hopefully at some point we can remove this when someone figures out what's going on.
if (shm->sockets[i].triplet.family == PF_BLUETOOTH)
continue;
/* Grab an fd, and nuke it before someone else uses it. */
fd = shm->sockets[i].fd;
shm->sockets[i].fd = 0;
/* disable linger */
(void) setsockopt(fd, SOL_SOCKET, SO_LINGER, &ling, sizeof(struct linger));
(void) shutdown(fd, SHUT_RDWR);
if (close(fd) != 0)
output(1, "failed to close socket [%d:%d:%d].(%s)\n",
shm->sockets[i].triplet.family,
shm->sockets[i].triplet.type,
shm->sockets[i].triplet.protocol,
strerror(errno));
}
nr_sockets = 0;
}
static int open_sockets(void)
{
int cachefile;
unsigned int domain, type, protocol;
unsigned int buffer[3];
int bytesread = -1;
int fd;
int ret;
/* If we're doing victim files we probably don't care about sockets. */
//FIXME: Is this really true ? We might want to sendfile for eg
if (victim_path != NULL)
return TRUE;
cachefile = open(cachefilename, O_RDONLY);
if (cachefile < 0) {
output(1, "Couldn't find socket cachefile. Regenerating.\n");
ret = generate_sockets();
return ret;
}
lock_cachefile(cachefile, F_RDLCK);
while (bytesread != 0) {
bytesread = read(cachefile, buffer, sizeof(int) * 3);
if (bytesread == 0)
break;
domain = buffer[0];
type = buffer[1];
protocol = buffer[2];
if ((do_specific_proto == TRUE && domain != specific_proto) ||
(domain < ARRAY_SIZE(no_protos) && no_protos[domain] == TRUE)) {
output(1, "ignoring socket cachefile due to specific "
"protocol request (or protocol disabled), "
"and stale data in cachefile.\n");
regenerate:
unlock_cachefile(cachefile); /* drop the reader lock. */
close(cachefile);
unlink(cachefilename);
close_sockets();
ret = generate_sockets();
return ret;
}
fd = open_socket(domain, type, protocol);
if (fd < 0) {
output(1, "Cachefile is stale. Need to regenerate.\n");
goto regenerate;
}
/* check for ctrl-c */
if (shm->exit_reason != STILL_RUNNING) {
close(cachefile);
return FALSE;
}
}
if (nr_sockets < NR_SOCKET_FDS) {
output(1, "Insufficient sockets in cachefile (%d). Regenerating.\n", nr_sockets);
goto regenerate;
}
output(1, "%d sockets created based on info from socket cachefile.\n", nr_sockets);
unlock_cachefile(cachefile);
close(cachefile);
return TRUE;
}
void open_sockets(void)
{
struct flock fl = {
.l_type = F_WRLCK,
.l_whence = SEEK_SET,
};
int cachefile;
unsigned int domain, type, protocol;
unsigned int buffer[3];
int bytesread=-1;
int fd;
/* If we have victim files, don't worry about sockets. */
if (victim_path != NULL)
return;
cachefile = open(cachefilename, O_RDONLY);
if (cachefile < 0) {
printf("Couldn't find socket cachefile. Regenerating.\n");
generate_sockets();
return;
}
if (verbose)
output(2, "taking reader lock for cachefile\n");
fl.l_pid = getpid();
fl.l_type = F_RDLCK;
if (fcntl(cachefile, F_SETLKW, &fl) == -1) {
perror("fcntl F_RDLCK F_SETLKW");
exit(1);
}
if (verbose)
output(2, "took reader lock for cachefile\n");
while (bytesread != 0) {
bytesread = read(cachefile, buffer, sizeof(int) * 3);
if (bytesread == 0)
break;
domain = buffer[0];
type = buffer[1];
protocol = buffer[2];
if (do_specific_proto == TRUE) {
if (domain != specific_proto) {
printf("ignoring socket cachefile due to specific protocol request, and stale data in cachefile.\n");
generate_sockets();
return;
}
}
fd = open_socket(domain, type, protocol);
if (fd < 0) {
printf("Cachefile is stale. Need to regenerate.\n");
regenerate:
close(cachefile);
unlink(cachefilename);
close_sockets();
generate_sockets();
return;
}
/* check for ctrl-c */
if (shm->exit_reason != STILL_RUNNING)
return;
}
if (nr_sockets < NR_SOCKET_FDS) {
printf("Insufficient sockets in cachefile (%d). Regenerating.\n", nr_sockets);
goto regenerate;
}
output(1, "%d sockets created based on info from socket cachefile.\n", nr_sockets);
fl.l_pid = getpid();
fl.l_type = F_UNLCK;
if (fcntl(cachefile, F_SETLK, &fl) == -1) {
perror("fcntl F_UNLCK F_SETLK ");
exit(1);
}
if (verbose)
output(2, "dropped reader lock for cachefile\n");
close(cachefile);
}
int main (int argc, char *argv[])
{
int opt;
const char *short_options = "p:qcvh";
const struct option long_options [] = {
{"port", 1, NULL, 'p'},
{"quite", 0, NULL, 'q'},
{"cbench", 0, NULL, 'c'},
{"version", 0, NULL, 'v'},
{"help", 0, NULL, 'h'},
{NULL, 0, NULL, 0}
};
while ((opt = getopt_long(argc, argv, short_options, long_options, NULL)) != -1) {
switch (opt) {
case 'p':
ani_port = atoi (optarg);
break;
case 'q':
verbose = 0;
break;
case 'c':
cbench = 1;
break;
case 'h':
cout << "Usage:\n" << "\t-p, --port controller port e.g. -p 2000" << endl
<< "\t-q, --quite turn off verbose mode" << endl
<< "\t-c, --cbench Cbench benchmarking mode" << endl
<< "\t-v, --version show ANI version" << endl
<< "\t-h, --help show this help" << endl;
exit (EXIT_SUCCESS);
case 'v':
cout << "ANI OpenFlow Controller" << endl
<< "Compiled on " << __DATE__ << ' ' << __TIME__ << endl
<< "version " << ANI_VERSION << endl;
exit (EXIT_SUCCESS);
default:
break;
}
}
if (atexit (exit_func) != 0) {
cerr << "Error: can not set exit function" << endl;
exit (EXIT_FAILURE);
}
cout << "Info: creating ANI socket..." << endl;
if (create_ani_socket () == -1) {
cerr << "Error: can not create ANI socket" << endl << "Exiting..." << endl;
close_sockets ();
exit (EXIT_FAILURE);
}
cout << "Info: established ANI server!" << endl;
cout << "Info: waiting for the switch connection..." << endl;
if (create_switch_socket () == -1) {
cerr << "Error: can not connect to the switch" << endl << "Exiting..." << endl;
close_sockets ();
exit (EXIT_FAILURE);
}
cout << "Info: connected to the switch!" << endl;
memset (&sigIntHandler, '\0', sizeof (sigIntHandler));
sigIntHandler.sa_handler = SIG_IGN;
sigaction (SIGINT, &sigIntHandler, NULL);
memset (&sigIntHandler, '\0', sizeof (sigIntHandler));
sigIntHandler.sa_handler = &exit_handler;
sigaction (SIGINT, &sigIntHandler, NULL);
memset (&sigIntHandler, '\0', sizeof (sigIntHandler));
sigIntHandler.sa_handler = &exit_handler;
sigaction (SIGTERM, &sigIntHandler, NULL);
hosts.set_object_size (sizeof(struct switch_host));
ports.set_object_size (sizeof(struct switch_port));
links.set_object_size (sizeof(struct switch_link));
sw_replys.set_object_size(sizeof(struct switch_reply));
while (1) {
if (communicate_with_switch () == -1) {
cerr << "Error: can not communicate with the switch" << endl;
exit (EXIT_FAILURE);
}
}
return EXIT_SUCCESS;
}
void open_sockets(void)
{
struct flock fl = {
.l_type = F_WRLCK,
.l_whence = SEEK_SET,
};
int cachefile;
unsigned int domain, type, protocol;
unsigned int buffer[3];
int bytesread=-1;
int fd;
cachefile = open(cachefilename, O_RDONLY);
if (cachefile < 0) {
printf("Couldn't find socket cachefile. Regenerating.\n");
generate_sockets();
return;
}
output(2, "taking reader lock for cachefile\n");
fl.l_pid = getpid();
fl.l_type = F_RDLCK;
if (fcntl(cachefile, F_SETLKW, &fl) == -1) {
perror("fcntl F_RDLCK F_SETLKW");
exit(1);
}
output(2, "took reader lock for cachefile\n");
while (bytesread != 0) {
bytesread = read(cachefile, buffer, sizeof(int) * 3);
if (bytesread == 0)
break;
domain = buffer[0];
type = buffer[1];
protocol = buffer[2];
if (do_specific_proto == TRUE) {
if (domain != specific_proto) {
printf("ignoring socket cachefile due to specific protocol request, and stale data in cachefile.\n");
generate_sockets();
return;
}
}
fd = socket(domain, type, protocol);
if (fd < 0) {
printf("Cachefile is stale. Need to regenerate.\n");
regenerate:
close(cachefile);
unlink(cachefilename);
close_sockets();
generate_sockets();
return;
}
shm->socket_fds[nr_sockets] = fd;
output(2, "fd[%i] = domain:%i type:0x%x protocol:%i\n",
fd, domain, type, protocol);
nr_sockets++;
}
if (nr_sockets < NR_SOCKET_FDS) {
printf("Insufficient sockets in cachefile (%d). Regenerating.\n", nr_sockets);
goto regenerate;
}
output(1, "%d sockets created based on info from socket cachefile.\n", nr_sockets);
fl.l_pid = getpid();
fl.l_type = F_UNLCK;
if (fcntl(cachefile, F_SETLK, &fl) == -1) {
perror("fcntl F_UNLCK F_SETLK ");
exit(1);
}
output(2, "dropped reader lock for cachefile\n");
close(cachefile);
}
