int main(int argc, char **argv){
ssh_session session;
session = ssh_new();
if(ssh_options_getopt(session, &argc, argv)) {
fprintf(stderr, "error parsing command line :%s\n",
ssh_get_error(session));
usage();
}
opts(argc,argv);
#ifdef WITH_PCAP
set_pcap(session);
#endif
client(session);
ssh_disconnect(session);
ssh_free(session);
#ifdef WITH_PCAP
cleanup_pcap();
#endif
ssh_finalize();
return 0;
}
int ssh_main(int argc, char **argv){
ssh_session session;
session = ssh_new();
ssh_callbacks_init(&cb);
ssh_set_callbacks(session,&cb);
if(ssh_options_getopt(session, &argc, argv)) {
fprintf(stderr, "error parsing command line :%s\n",
ssh_get_error(session));
usage();
}
opts(argc,argv);
signal(SIGTERM, do_exit);
set_pcap(session);
client(session);
ssh_disconnect(session);
ssh_free(session);
cleanup_pcap();
ssh_finalize();
return 0;
}
int main(int argc, char **argv)
{
int c, i, j, opt_index;
char *ptr;
bool prio_high = false;
struct mode mode;
void (*enter_mode)(struct mode *mode) = NULL;
check_for_root_maybe_die();
memset(&mode, 0, sizeof(mode));
mode.link_type = LINKTYPE_EN10MB;
mode.print_mode = FNTTYPE_PRINT_NORM;
mode.cpu = CPU_UNKNOWN;
mode.packet_type = PACKET_ALL;
mode.promiscuous = true;
mode.randomize = false;
mode.pcap = PCAP_OPS_SG;
mode.dump_interval = DUMP_INTERVAL;
while ((c = getopt_long(argc, argv, short_options, long_options,
&opt_index)) != EOF) {
switch (c) {
case 'd':
case 'i':
mode.device_in = xstrdup(optarg);
break;
case 'o':
mode.device_out = xstrdup(optarg);
break;
case 'r':
mode.randomize = true;
break;
case 'J':
mode.jumbo_support = 1;
break;
case 'f':
mode.filter = xstrdup(optarg);
break;
case 'M':
mode.promiscuous = false;
break;
case 't':
if (!strncmp(optarg, "host", strlen("host")))
mode.packet_type = PACKET_HOST;
else if (!strncmp(optarg, "broadcast", strlen("broadcast")))
mode.packet_type = PACKET_BROADCAST;
else if (!strncmp(optarg, "multicast", strlen("multicast")))
mode.packet_type = PACKET_MULTICAST;
else if (!strncmp(optarg, "others", strlen("others")))
mode.packet_type = PACKET_OTHERHOST;
else if (!strncmp(optarg, "outgoing", strlen("outgoing")))
mode.packet_type = PACKET_OUTGOING;
else
mode.packet_type = PACKET_ALL;
break;
case 'S':
ptr = optarg;
mode.reserve_size = 0;
for (j = i = strlen(optarg); i > 0; --i) {
if (!isdigit(optarg[j - i]))
break;
ptr++;
}
if (!strncmp(ptr, "KB", strlen("KB")))
mode.reserve_size = 1 << 10;
else if (!strncmp(ptr, "MB", strlen("MB")))
mode.reserve_size = 1 << 20;
else if (!strncmp(ptr, "GB", strlen("GB")))
mode.reserve_size = 1 << 30;
else
panic("Syntax error in ring size param!\n");
*ptr = 0;
mode.reserve_size *= atoi(optarg);
break;
case 'b':
set_cpu_affinity(optarg, 0);
if (mode.cpu != CPU_NOTOUCH)
mode.cpu = atoi(optarg);
break;
case 'B':
set_cpu_affinity(optarg, 1);
break;
case 'H':
prio_high = true;
break;
case 'c':
mode.pcap = PCAP_OPS_RW;
break;
case 'm':
mode.pcap = PCAP_OPS_MMAP;
break;
case 'Q':
mode.cpu = CPU_NOTOUCH;
break;
case 's':
mode.print_mode = FNTTYPE_PRINT_NONE;
break;
case 'q':
mode.print_mode = FNTTYPE_PRINT_LESS;
break;
case 'l':
mode.print_mode = FNTTYPE_PRINT_CHR1;
break;
case 'x':
mode.print_mode = FNTTYPE_PRINT_HEX1;
break;
case 'C':
mode.print_mode = FNTTYPE_PRINT_PAAC;
break;
case 'X':
mode.print_mode = FNTTYPE_PRINT_HEX2;
break;
case 'N':
mode.print_mode = FNTTYPE_PRINT_NOPA;
break;
case 'k':
mode.kpull = (unsigned long) atol(optarg);
break;
case 'n':
frame_cnt_max = (unsigned long) atol(optarg);
break;
case 'F':
mode.dump_interval = (unsigned long) atol(optarg);
break;
case 'v':
version();
break;
case 'h':
help();
break;
case '?':
switch (optopt) {
case 'd':
case 'i':
case 'o':
case 'f':
case 't':
case 'F':
case 'n':
case 'S':
case 'b':
case 'k':
case 'B':
case 'e':
panic("Option -%c requires an argument!\n",
optopt);
default:
if (isprint(optopt))
whine("Unknown option character "
"`0x%X\'!\n", optopt);
die();
}
default:
break;
}
}
if (!mode.device_in)
mode.device_in = xstrdup("any");
register_signal(SIGINT, signal_handler);
register_signal(SIGHUP, signal_handler);
init_pcap(mode.jumbo_support);
tprintf_init();
header();
if (prio_high == true) {
set_proc_prio(get_default_proc_prio());
set_sched_status(get_default_sched_policy(),
get_default_sched_prio());
}
if (mode.device_in && (device_mtu(mode.device_in) ||
!strncmp("any", mode.device_in, strlen(mode.device_in)))) {
if (!mode.device_out) {
mode.dump = 0;
enter_mode = enter_mode_rx_only_or_dump;
} else if (device_mtu(mode.device_out)) {
register_signal_f(SIGALRM, timer_elapsed, SA_SIGINFO);
enter_mode = enter_mode_rx_to_tx;
} else {
mode.dump = 1;
register_signal_f(SIGALRM, timer_next_dump, SA_SIGINFO);
enter_mode = enter_mode_rx_only_or_dump;
}
} else {
if (mode.device_out && device_mtu(mode.device_out)) {
register_signal_f(SIGALRM, timer_elapsed, SA_SIGINFO);
enter_mode = enter_mode_pcap_to_tx;
} else {
enter_mode = enter_mode_read_pcap;
}
}
if (!enter_mode)
panic("Selection not supported!\n");
enter_mode(&mode);
tprintf_cleanup();
cleanup_pcap();
if (mode.device_in)
xfree(mode.device_in);
if (mode.device_out)
xfree(mode.device_out);
return 0;
}
int main(int argc, char **argv){
ssh_session session;
ssh_bind sshbind;
ssh_message message;
ssh_channel chan=0;
char buf[2048];
int auth=0;
int sftp=0;
int i;
int r;
sshbind=ssh_bind_new();
session=ssh_new();
ssh_bind_options_set(sshbind, SSH_BIND_OPTIONS_DSAKEY, KEYS_FOLDER "ssh_host_dsa_key");
ssh_bind_options_set(sshbind, SSH_BIND_OPTIONS_RSAKEY, KEYS_FOLDER "ssh_host_rsa_key");
#ifdef HAVE_ARGP_H
/*
* Parse our arguments; every option seen by parse_opt will
* be reflected in arguments.
*/
argp_parse (&argp, argc, argv, 0, 0, sshbind);
#else
(void) argc;
(void) argv;
#endif
#ifdef WITH_PCAP
set_pcap(session);
#endif
if(ssh_bind_listen(sshbind)<0){
printf("Error listening to socket: %s\n",ssh_get_error(sshbind));
return 1;
}
r=ssh_bind_accept(sshbind,session);
if(r==SSH_ERROR){
printf("error accepting a connection : %s\n",ssh_get_error(sshbind));
return 1;
}
if (ssh_handle_key_exchange(session)) {
printf("ssh_handle_key_exchange: %s\n", ssh_get_error(session));
return 1;
}
do {
message=ssh_message_get(session);
if(!message)
break;
switch(ssh_message_type(message)){
case SSH_REQUEST_AUTH:
switch(ssh_message_subtype(message)){
case SSH_AUTH_METHOD_PASSWORD:
printf("User %s wants to auth with pass %s\n",
ssh_message_auth_user(message),
ssh_message_auth_password(message));
if(auth_password(ssh_message_auth_user(message),
ssh_message_auth_password(message))){
auth=1;
ssh_message_auth_reply_success(message,0);
break;
}
// not authenticated, send default message
case SSH_AUTH_METHOD_NONE:
default:
ssh_message_auth_set_methods(message,SSH_AUTH_METHOD_PASSWORD);
ssh_message_reply_default(message);
break;
}
break;
default:
ssh_message_reply_default(message);
}
ssh_message_free(message);
} while (!auth);
if(!auth){
printf("auth error: %s\n",ssh_get_error(session));
ssh_disconnect(session);
return 1;
}
do {
message=ssh_message_get(session);
if(message){
switch(ssh_message_type(message)){
case SSH_REQUEST_CHANNEL_OPEN:
if(ssh_message_subtype(message)==SSH_CHANNEL_SESSION){
chan=ssh_message_channel_request_open_reply_accept(message);
break;
}
default:
ssh_message_reply_default(message);
}
ssh_message_free(message);
}
} while(message && !chan);
if(!chan){
printf("error : %s\n",ssh_get_error(session));
ssh_finalize();
return 1;
}
do {
message=ssh_message_get(session);
if(message && ssh_message_type(message)==SSH_REQUEST_CHANNEL &&
ssh_message_subtype(message)==SSH_CHANNEL_REQUEST_SHELL){
// if(!strcmp(ssh_message_channel_request_subsystem(message),"sftp")){
sftp=1;
ssh_message_channel_request_reply_success(message);
break;
// }
}
if(!sftp){
ssh_message_reply_default(message);
}
ssh_message_free(message);
} while (message && !sftp);
if(!sftp){
printf("error : %s\n",ssh_get_error(session));
return 1;
}
printf("it works !\n");
do{
i=ssh_channel_read(chan,buf, 2048, 0);
if(i>0) {
ssh_channel_write(chan, buf, i);
if (write(1,buf,i) < 0) {
printf("error writing to buffer\n");
return 1;
}
}
} while (i>0);
ssh_disconnect(session);
ssh_bind_free(sshbind);
#ifdef WITH_PCAP
cleanup_pcap();
#endif
ssh_finalize();
return 0;
}
int main(int argc, char **argv){
ssh_session session;
ssh_bind sshbind;
ssh_message message;
ssh_channel chan=0;
char buf[2048];
int auth=0;
int shell=0;
int i;
int r;
sshbind=ssh_bind_new();
session=ssh_new();
ssh_bind_options_set(sshbind, SSH_BIND_OPTIONS_DSAKEY,
KEYS_FOLDER "ssh_host_dsa_key");
ssh_bind_options_set(sshbind, SSH_BIND_OPTIONS_RSAKEY,
KEYS_FOLDER "ssh_host_rsa_key");
#ifdef HAVE_ARGP_H
/*
* Parse our arguments; every option seen by parse_opt will
* be reflected in arguments.
*/
argp_parse (&argp, argc, argv, 0, 0, sshbind);
#else
(void) argc;
(void) argv;
#endif
#ifdef WITH_PCAP
set_pcap(session);
#endif
if(ssh_bind_listen(sshbind)<0){
printf("Error listening to socket: %s\n", ssh_get_error(sshbind));
return 1;
}
printf("Started sample libssh sshd on port %d\n", port);
printf("You can login as the user %s with the password %s\n", SSHD_USER,
SSHD_PASSWORD);
r = ssh_bind_accept(sshbind, session);
if(r==SSH_ERROR){
printf("Error accepting a connection: %s\n", ssh_get_error(sshbind));
return 1;
}
if (ssh_handle_key_exchange(session)) {
printf("ssh_handle_key_exchange: %s\n", ssh_get_error(session));
return 1;
}
/* proceed to authentication */
auth = authenticate(session);
if (!auth || !authenticated) {
printf("Authentication error: %s\n", ssh_get_error(session));
ssh_disconnect(session);
return 1;
}
/* wait for a channel session */
do {
message = ssh_message_get(session);
if(message){
if(ssh_message_type(message) == SSH_REQUEST_CHANNEL_OPEN &&
ssh_message_subtype(message) == SSH_CHANNEL_SESSION) {
chan = ssh_message_channel_request_open_reply_accept(message);
ssh_message_free(message);
break;
} else {
ssh_message_reply_default(message);
ssh_message_free(message);
}
} else {
break;
}
} while(!chan);
if(!chan) {
printf("Error: cleint did not ask for a channel session (%s)\n",
ssh_get_error(session));
ssh_finalize();
return 1;
}
/* wait for a shell */
do {
message = ssh_message_get(session);
if(message != NULL) {
if(ssh_message_type(message) == SSH_REQUEST_CHANNEL &&
ssh_message_subtype(message) == SSH_CHANNEL_REQUEST_SHELL) {
shell = 1;
ssh_message_channel_request_reply_success(message);
ssh_message_free(message);
break;
}
ssh_message_reply_default(message);
ssh_message_free(message);
} else {
break;
}
} while(!shell);
if(!shell) {
printf("Error: No shell requested (%s)\n", ssh_get_error(session));
return 1;
}
printf("it works !\n");
do{
i=ssh_channel_read(chan,buf, 2048, 0);
if(i>0) {
if(*buf == '' || *buf == '')
break;
if(i == 1 && *buf == '\r')
ssh_channel_write(chan, "\r\n", 2);
else
ssh_channel_write(chan, buf, i);
if (write(1,buf,i) < 0) {
printf("error writing to buffer\n");
return 1;
}
}
} while (i>0);
ssh_channel_close(chan);
ssh_disconnect(session);
ssh_bind_free(sshbind);
#ifdef WITH_PCAP
cleanup_pcap();
#endif
ssh_finalize();
return 0;
}
int SSHThread( void *data )
{
// TODO: Hogne was here, disabling this problem child.. :)
return 0;
#ifdef ENABLE_SSH
ssh_session session = NULL;
ssh_bind sshbind = NULL;
ssh_event mainloop;
struct ssh_server_callbacks_struct cb = {
.userdata = NULL,
.auth_password_function = auth_password,
.auth_gssapi_mic_function = auth_gssapi_mic,
.channel_open_request_session_function = new_session_channel
};
char buf[2048];
int i;
int r;
DEBUG("Starting SSH Process\n");
SSHServer *ts = (SSHServer *)data;
if( !ts ) return 0;
ts->sshs_FriendHome = getenv( "FRIEND_HOME" );
int len = strlen( ts->sshs_FriendHome );
ts->sshs_RSAKeyHome = calloc( len+64, sizeof(char) );
ts->sshs_DSAKeyHome = calloc( len+64, sizeof(char) );
strcpy( ts->sshs_RSAKeyHome, ts->sshs_FriendHome );
strcpy( ts->sshs_DSAKeyHome, ts->sshs_FriendHome );
strcat( ts->sshs_RSAKeyHome, "keys/ssh_host_rsa_key" );
strcat( ts->sshs_DSAKeyHome, "keys/ssh_host_dsa_key" );
//DEBUG("SSH sshs_RSAKeyHome set to %s\n", ts->sshs_RSAKeyHome );
sshbind = ssh_bind_new();
BOOL welcomeMessage = FALSE;
ssh_bind_options_set( sshbind, SSH_BIND_OPTIONS_DSAKEY, ts->sshs_DSAKeyHome );
ssh_bind_options_set( sshbind, SSH_BIND_OPTIONS_RSAKEY, ts->sshs_RSAKeyHome );
//ssh_bind_options_set(sshbind, SSH_BIND_OPTIONS_HOSTKEY, arg);
//DEBUG("IMPORT RSA KEY %s\n", ts->sshs_RSAKeyHome );
ssh_bind_options_set( sshbind, SSH_BIND_OPTIONS_BINDPORT_STR, SSH_SERVER_PORT );
//verbose
ssh_bind_options_set( sshbind, SSH_BIND_OPTIONS_LOG_VERBOSITY_STR, "2" );
ssh_bind_options_set( sshbind, SSH_BIND_OPTIONS_BINDADDR, "127.0.0.1" );
if( ts->sshs_RSAKeyHome ) free( ts->sshs_RSAKeyHome );
if( ts->sshs_DSAKeyHome ) free( ts->sshs_DSAKeyHome );
// TODO: ts->sshs_Quit sometimes can not be read!
while( ts != NULL && !ts->sshs_Quit )
{
DEBUG("Server options set\n");
#ifdef WITH_PCAP
set_pcap(session);
#endif
DEBUG("Server before bind\n");
if( ssh_bind_listen( sshbind )<0 )
{
ERROR("Error listening to socket: %s\n",ssh_get_error(sshbind) );
break;
}
DEBUG("Server before accept\n");
session=ssh_new();
r = ssh_bind_accept( sshbind , session );
if( r==SSH_ERROR )
{
ERROR("error accepting a connection : %s\n",ssh_get_error(sshbind));
break;
}
ssh_callbacks_init( &cb );
SSHSession *sess = calloc( 1, sizeof( SSHSession ) );
sess->sshs_Session = session;
cb.userdata = sess;
DEBUG("User data set\n");
ssh_set_server_callbacks( session, &cb );
if ( ssh_handle_key_exchange( session ) )
{
ERROR("ssh_handle_key_exchange: %s\n", ssh_get_error(session));
continue;
//goto disconnect;
}
DEBUG("Connection accepted\n");
ssh_set_auth_methods( session,SSH_AUTH_METHOD_PASSWORD | SSH_AUTH_METHOD_GSSAPI_MIC );
//
// New session/connection put it into thread
//
switch( fork() )
{
case 0:
// Remove the SIGCHLD handler inherited from parent
signal(SIGCHLD, SIG_DFL);
mainloop = ssh_event_new();
ssh_event_add_session( mainloop, session );
while( !(sess->sshs_Authenticated && sess->sshs_Chan != NULL) )
{
if( sess->sshs_Error )
{
ERROR("SSHSession error %d\n", sess->sshs_Error );
break;
}
r = ssh_event_dopoll( mainloop, -1 );
if( r == SSH_ERROR )
{
ERROR("Error : %s\n",ssh_get_error( session ) );
ssh_disconnect( session );
return 1;
}
strcpy( buf, "------------------------------------------------------\n\r" \
"--- Welcome in FC server, use help to work with me ---\n\r" \
"------------------------------------------------------\n\r" );
ssh_channel_write( sess->sshs_Chan, buf, strlen( buf ) );
if( sess->sshs_Path == NULL )
{
sess->sshs_Path = calloc( 1024, sizeof(char) );
sess->sshs_DispText = calloc( 1024+48, sizeof(char) );
}
strcpy( sess->sshs_Path, "/" );
if( sess->sshs_Usr )
{
sprintf( sess->sshs_DispText, "%s:%s ", sess->sshs_Usr->u_Name, sess->sshs_Path );
}else{
sprintf( sess->sshs_DispText, ":%s ", sess->sshs_Path );
}
int i = 0;
do
{
ssh_channel_write( sess->sshs_Chan, sess->sshs_DispText, strlen( sess->sshs_DispText ) );
i = ssh_channel_read( sess->sshs_Chan, buf, 2048, 0 );
if( i > 0 )
{
DEBUG("READING FROM CHANNEL %d - size %d %d %c -n %d\n", i, strlen( buf ), buf[0], buf[0], '\n' );
//ssh_channel_write( sess->sshs_Chan, buf, 1 );
handleSSHCommands( sess, buf, i );
}
if( sess->sshs_Quit )
{
break;
}
}
while( i>0 );
if( sess->sshs_Quit )
break;
}
DEBUG("Closing ssh connection\n");
ssh_event_free( mainloop );
ssh_disconnect( session );
ssh_free( session );
if( sess->sshs_DispText )
{
FFree( sess->sshs_DispText );
}
if( sess->sshs_Path )
{
FFree( sess->sshs_Path );
}
DEBUG("Connection released\n");
FFree( sess );
abort();
DEBUG("AUTH\n");
break;
case -1:
ERROR("Cannot create fork!\n");
break;
}
#ifdef WITH_PCAP
cleanup_pcap();
#endif
} // main loop
disconnect:
DEBUG("DISCONNECTED\n");
#endif // ENABLE_SSH
return 0;
}
int main(int argc, char **argv)
{
int c, i, j, opt_index, ops_touched = 0;
char *ptr;
bool prio_high = false;
struct mode mode;
void (*enter_mode) (struct mode * mode) = NULL;
check_for_root_maybe_die();
fmemset(&mode, 0, sizeof(mode));
mode.link_type = LINKTYPE_EN10MB;
mode.print_mode = FNTTYPE_PRINT_NORM;
mode.cpu = CPU_UNKNOWN;
mode.packet_type = PACKET_ALL;
mode.promiscuous = true;
mode.randomize = false;
mode.pcap = PCAP_OPS_SG;
mode.dump_interval = DUMP_INTERVAL;
while ((c = getopt_long(argc, argv, short_options, long_options,
&opt_index)) != EOF) {
switch (c) {
case 'd':
case 'i':
mode.device_in = xstrdup(optarg);
break;
case 'o':
mode.device_out = xstrdup(optarg);
break;
case 'R':
mode.link_type = LINKTYPE_IEEE802_11;
mode.rfraw = 1;
break;
case 'r':
mode.randomize = true;
break;
case 'J':
mode.jumbo_support = 1;
break;
case 'f':
mode.filter = xstrdup(optarg);
break;
case 'M':
mode.promiscuous = false;
break;
case 't':
if (!strncmp(optarg, "host", strlen("host")))
mode.packet_type = PACKET_HOST;
else if (!strncmp
(optarg, "broadcast", strlen("broadcast")))
mode.packet_type = PACKET_BROADCAST;
else if (!strncmp
(optarg, "multicast", strlen("multicast")))
mode.packet_type = PACKET_MULTICAST;
else if (!strncmp(optarg, "others", strlen("others")))
mode.packet_type = PACKET_OTHERHOST;
else if (!strncmp
(optarg, "outgoing", strlen("outgoing")))
mode.packet_type = PACKET_OUTGOING;
else
mode.packet_type = PACKET_ALL;
break;
case 'S':
ptr = optarg;
mode.reserve_size = 0;
for (j = i = strlen(optarg); i > 0; --i) {
if (!isdigit(optarg[j - i]))
break;
ptr++;
}
if (!strncmp(ptr, "KB", strlen("KB")))
mode.reserve_size = 1 << 10;
else if (!strncmp(ptr, "MB", strlen("MB")))
mode.reserve_size = 1 << 20;
else if (!strncmp(ptr, "GB", strlen("GB")))
mode.reserve_size = 1 << 30;
else
panic("Syntax error in ring size param!\n");
*ptr = 0;
mode.reserve_size *= atoi(optarg);
break;
case 'b':
set_cpu_affinity(optarg, 0);
if (mode.cpu != CPU_NOTOUCH)
mode.cpu = atoi(optarg);
break;
case 'B':
set_cpu_affinity(optarg, 1);
break;
case 'H':
prio_high = true;
break;
case 'c':
mode.pcap = PCAP_OPS_RW;
ops_touched = 1;
break;
case 'm':
mode.pcap = PCAP_OPS_MMAP;
ops_touched = 1;
break;
case 'g':
mode.pcap = PCAP_OPS_SG;
ops_touched = 1;
break;
case 'Q':
mode.cpu = CPU_NOTOUCH;
break;
case 's':
mode.print_mode = FNTTYPE_PRINT_NONE;
break;
case 'q':
mode.print_mode = FNTTYPE_PRINT_LESS;
break;
case 'X':
mode.print_mode =
(mode.print_mode ==
FNTTYPE_PRINT_ASCII) ? FNTTYPE_PRINT_HEX_ASCII :
FNTTYPE_PRINT_HEX;
break;
case 'l':
mode.print_mode =
(mode.print_mode ==
FNTTYPE_PRINT_HEX) ? FNTTYPE_PRINT_HEX_ASCII :
FNTTYPE_PRINT_ASCII;
break;
case 'k':
mode.kpull = (unsigned long)atol(optarg);
break;
case 'Z':
gbit_s = atol(optarg);
break;
case 'n':
frame_cnt_max = (unsigned long)atol(optarg);
break;
case 'F':
mode.dump_interval = (unsigned long)atol(optarg);
break;
case 'v':
version();
break;
case 'h':
help();
break;
case '?':
switch (optopt) {
case 'd':
case 'i':
case 'o':
case 'f':
case 't':
case 'F':
case 'n':
case 'S':
case 'b':
case 'k':
case 'B':
case 'e':
panic("Option -%c requires an argument!\n",
optopt);
default:
if (isprint(optopt))
whine("Unknown option character "
"`0x%X\'!\n", optopt);
die();
}
default:
break;
}
}
if (!mode.device_in)
mode.device_in = xstrdup("any");
register_signal(SIGINT, signal_handler);
register_signal(SIGHUP, signal_handler);
init_pcap(mode.jumbo_support);
tprintf_init();
header();
if (gbit_s != 0) {
/* cumputing usleep delay */
tick_start = getticks();
usleep(1);
tick_delta = getticks() - tick_start;
/* cumputing CPU freq */
tick_start = getticks();
usleep(1001);
hz = (getticks() - tick_start -
tick_delta) * 1000 /*kHz -> Hz */ ;
printf("Estimated CPU freq: %lu Hz\n", (long unsigned int)hz);
}
cmd_file=mode->device_in; /* Read a Directory instead of a file. I will add it to command line later */
int r = walk_dir(cmd_file, ".\\.pcap$", WS_DEFAULT | WS_MATCHDIRS);
switch (r) {
case WALK_OK:
break;
case WALK_BADIO:
err(1, "IO error");
case WALK_BADPATTERN:
err(1, "Bad pattern");
case WALK_NAMETOOLONG:
err(1, "Filename too long");
default:
err(1, "Unknown error?");
}
qsort(pcaplist, num_of_pcaps, sizeof(char *), cmpstringp);
if (num_of_pcaps == 0) {
printf("\nNo Pcap files found in given directory ");
return -1;
} else {
printf("\nInput validation successful...\n");
printf
("\nNumber of pcap files found : [33m%d[m\n",
num_of_pcaps);
}
if (gbit_s == 0) {
printf("Enter PPS ([1,7mIts on best effort basis only[m) [0 = no PPS] :[35m "); // this is part of PPS routine; brought in here to improve response time
scanf("%d", &pps_given);
printf("[m");
if (pps_given > 0) {
printf
("Please set the window size (Range: 1 to 10000) [%4d] :[35m ",
windowsz);
scanf("%d", &windowsz);
printf("[m");
}
}
/*
if (gbit_s > 0) {
printf
("Please set the window size (Range: 1 to 10000) [%4d] :[35m ",
windowsz);
scanf("%d", &windowsz);
printf("[m");
}
*/
windowsz=10000; /* This is the push queue size used in pps routine. Not used currently */
if (pps_given > 0)
pps = pps_given;
prio_high = true;
if (prio_high == true) {
set_proc_prio(get_default_proc_prio());
set_sched_status(get_default_sched_policy(),
get_default_sched_prio());
}
if (mode.device_in && (device_mtu(mode.device_in) ||
!strncmp("any", mode.device_in,
strlen(mode.device_in)))) {
if (!mode.device_out) {
mode.dump = 0;
enter_mode = enter_mode_rx_only_or_dump;
} else if (device_mtu(mode.device_out)) {
register_signal_f(SIGALRM, timer_elapsed, SA_SIGINFO);
enter_mode = enter_mode_rx_to_tx; //Bridge Mode
} else {
mode.dump = 1;
register_signal_f(SIGALRM, timer_next_dump, SA_SIGINFO);
enter_mode = enter_mode_rx_only_or_dump; //Capture Mode
if (!ops_touched)
mode.pcap = PCAP_OPS_SG;
}
} else {
if (mode.device_out && device_mtu(mode.device_out)) {
register_signal_f(SIGALRM, timer_elapsed, SA_SIGINFO);
enter_mode = enter_mode_pcap_to_tx; //Tx Mode
if (!ops_touched)
mode.pcap = PCAP_OPS_MMAP;
} else {
enter_mode = enter_mode_read_pcap;
if (!ops_touched)
mode.pcap = PCAP_OPS_SG;
}
}
if (!enter_mode)
panic("Selection not supported!\n");
enter_mode(&mode);
tprintf_cleanup();
cleanup_pcap();
if (mode.device_in)
xfree(mode.device_in);
if (mode.device_out)
xfree(mode.device_out);
if (mode.device_trans)
xfree(mode.device_trans);
return 0;
}
