开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 网络截获/分析 > 查看源码
ec_interface_sniff.c
资源名称：ettercap-0.4.0.tar.gz　[点击查看]
上传用户：nilegod
上传日期：2007-01-08
资源大小：220k
文件大小：21k
源码类别：

网络截获/分析

开发平台：

C/C++

ec_interface_sniff.c：源码内容
  1. /*
  2.     ettercap -- ncurses interface for connection list
  4.     Copyright (C) 2001  ALoR <alor@users.sourceforge.net>, NaGA <crwm@freemail.it>
  6.     This program is free software; you can redistribute it and/or modify
  7.     it under the terms of the GNU General Public License as published by
  8.     the Free Software Foundation; either version 2 of the License, or
  9.     (at your option) any later version.
  11.     This program is distributed in the hope that it will be useful,
  12.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.     GNU General Public License for more details.
  16.     You should have received a copy of the GNU General Public License
  17.     along with this program; if not, write to the Free Software
  18.     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  19. */
  21. #include "include/ec_main.h"
  23. #ifdef HAVE_NCURSES  // don't compile if ncurses interface is not supported
  25. #include <string.h>
  26. #include <ncurses.h>
  27. #include <unistd.h>
  28. #include <signal.h>
  29. #include <sys/time.h>
  31. #include "include/ec_interface.h"
  32. #include "include/ec_interface_sniff_data.h"
  33. #include "include/ec_decodedata.h"
  34. #include "include/ec_illithid.h"
  35. #include "include/ec_doppleganger.h"
  36. #include "include/ec_inet.h"
  37. #include "include/ec_inet_forge.h"
  38. #include "include/ec_inet_structures.h"
  39. #include "include/ec_buffer.h"
  41. #ifdef DEBUG
  42.    #include "include/ec_debug.h"
  43. #endif
  46. #define BOTTOM_COLOR 1        // color schemes
  47. #define TITLE_COLOR  2
  48. #define MAIN_COLOR   3
  49. #define POINT_COLOR  4
  50. #define SEL_COLOR    5
  51. #define HELP_COLOR   6
  52. #define SNIFF_COLOR  7
  54. #define KEY_RETURN   10       // they aren't defined in ncurses.h :(
  55. #define KEY_CTRL_L   12
  58. // protos...
  59. void Interface_Sniff_Run(short mode);
  60. void Interface_Sniff_PointItem(char direction);
  61. void Interface_Sniff_InitList(void);
  62. void Interface_Sniff_RefreshList(void);
  63. void Interface_Sniff_KillConn(void);
  64. void Interface_Sniff_ActiveDissecor(short mode);
  66. // global variables
  68. extern WINDOW *main_window, *bottom_window, *top_window;
  70. extern int W_MAINX1, W_MAINY1, W_MAINX2, W_MAINY2;
  71. extern int W_BOTTOMX1, W_BOTTOMY1, W_BOTTOMX2, W_BOTTOMY2;
  72. extern int W_SELECTCONN;
  74. short LeftMargin = 0;
  76. int Conn_Base_Pointer = 0;
  77. int Conn_Pointer = 0;
  78. extern int Sel_Number;
  81. //---------------------------
  84. void Interface_Sniff_InitList(void)
  85. {
  86.    int j;
  87.    int Conn_Top_Pointer;
  88.    char info[100];
  90. //#ifdef DEBUG
  91. // Debug_msg("Interface_Sniff_InitList");
  92. //#endif
  94.    if (has_colors())
  95.       wbkgdset(main_window, COLOR_PAIR(MAIN_COLOR));
  96.    else
  97.       wattroff(main_window,A_REVERSE);
  99.    werase(main_window);
  101.    if (number_of_connections == 0)     // no connection... no action... ;)
  102.    {
  103.       wnoutrefresh(main_window);
  104.       doupdate();
  105.       return;
  106.    }
  108.    Conn_Top_Pointer = (Conn_Base_Pointer+Sel_Number < number_of_connections) ? Conn_Base_Pointer + Sel_Number : number_of_connections ;
  110.    for(j=Conn_Base_Pointer; j<Conn_Top_Pointer; j++)     // prints connections within the main_window height
  111.    {
  112.       wmove(main_window, j-Conn_Base_Pointer, LeftMargin );
  113.       wprintw(main_window, "%3d) %15s:%d", j+1, Conn_Between_Hosts[j].ip_source, Conn_Between_Hosts[j].source_port);
  114.       mvwprintw(main_window, j-Conn_Base_Pointer, 28," <--> %15s:%d", Conn_Between_Hosts[j].ip_dest , Conn_Between_Hosts[j].dest_port);
  115.       wmove(main_window, j-Conn_Base_Pointer, LeftMargin + 56);  waddch(main_window, ACS_VLINE);
  116.       wprintw(main_window, " %s", Conn_Between_Hosts[j].status);
  117.       wmove(main_window, j-Conn_Base_Pointer, LeftMargin + 65);  waddch(main_window, ACS_VLINE);
  118.       wprintw(main_window, " %s", Conn_Between_Hosts[j].type);
  119.    }
  121.    if (has_colors())
  122.       wbkgdset(main_window, COLOR_PAIR(POINT_COLOR));
  123.    else
  124.       wattron(main_window,A_REVERSE);
  127.    wmove(main_window, Conn_Pointer - Conn_Base_Pointer, LeftMargin );
  128.    whline(main_window, ' ', W_SELECTCONN);
  129.    wprintw(main_window, "%3d) %15s:%d", Conn_Pointer+1, Conn_Between_Hosts[Conn_Pointer].ip_source, Conn_Between_Hosts[Conn_Pointer].source_port);
  130.    mvwprintw(main_window, Conn_Pointer-Conn_Base_Pointer, 28," <--> %15s:%d", Conn_Between_Hosts[Conn_Pointer].ip_dest , Conn_Between_Hosts[Conn_Pointer].dest_port);
  131.    wmove(main_window, Conn_Pointer-Conn_Base_Pointer, LeftMargin + 56);  waddch(main_window, ACS_VLINE);
  132.    wprintw(main_window, " %s", Conn_Between_Hosts[Conn_Pointer].status);
  133.    wmove(main_window, Conn_Pointer - Conn_Base_Pointer, LeftMargin + 65); waddch(main_window, ACS_VLINE);
  134.    wprintw(main_window, " %s", Conn_Between_Hosts[Conn_Pointer].type);
  136.    werase(bottom_window);
  137.    mvwprintw(bottom_window, 0, 1, " %s", Conn_Between_Hosts[Conn_Pointer].user);
  138.    mvwprintw(bottom_window, 1, 1, " %s", Conn_Between_Hosts[Conn_Pointer].pass);
  139.    snprintf(info, W_MAINX2 - 23, "%s", Conn_Between_Hosts[Conn_Pointer].info);
  140.    mvwprintw(bottom_window, 1, 25, " %s", info);
  142.    wnoutrefresh(bottom_window);
  143.    wnoutrefresh(main_window);
  144.    doupdate();
  145. }
  149. void Interface_Sniff_PointItem(char direction)
  150. {
  152.    int Old_Conn_Pointer;
  153.    char info[100];
  155.    if (number_of_connections == 0) return;   // no connection... no action... ;)
  157.    Old_Conn_Pointer = Conn_Pointer;
  159.    Conn_Pointer += direction;
  161.    if (Conn_Pointer > number_of_connections -1 ) Conn_Pointer = number_of_connections - 1;
  162.    if (Conn_Pointer < 0) Conn_Pointer = 0;
  165.    if ( (Conn_Pointer - Conn_Base_Pointer + direction  >= Sel_Number) && (direction > 0) )      // scroll down
  166.    {
  167.       if (Conn_Base_Pointer + Sel_Number <= number_of_connections)
  168.          Conn_Base_Pointer = (Conn_Base_Pointer + direction < number_of_connections) ? Conn_Base_Pointer + direction : number_of_connections - Sel_Number;
  170.       Interface_Sniff_InitList();
  171.    }
  172.    else if ( (Conn_Pointer - Conn_Base_Pointer + direction < 0) && (direction < 0) )         // scroll up
  173.    {
  174.       if (Conn_Base_Pointer > 0)
  175.          Conn_Base_Pointer = (Conn_Base_Pointer + direction > 0) ? Conn_Base_Pointer + direction : 0;
  177.       Interface_Sniff_InitList();
  178.    }
  181.    if (has_colors())
  182.       wbkgdset(main_window, COLOR_PAIR(MAIN_COLOR));
  183.    else
  184.       wattroff(main_window,A_REVERSE);
  187.    if ( (Old_Conn_Pointer >= Conn_Base_Pointer) && (Old_Conn_Pointer <= Conn_Base_Pointer + Sel_Number -1)) // DON'T redraw previous selected item if it is out of view
  188.    {
  189.       wmove(main_window, Old_Conn_Pointer - Conn_Base_Pointer, LeftMargin);
  190.       whline(main_window,' ', W_SELECTCONN);                         //deletes the previous position
  192.       wprintw(main_window, "%3d) %15s:%d", Old_Conn_Pointer+1, Conn_Between_Hosts[Old_Conn_Pointer].ip_source, Conn_Between_Hosts[Old_Conn_Pointer].source_port);
  193.       mvwprintw(main_window, Old_Conn_Pointer-Conn_Base_Pointer, 28," <--> %15s:%d", Conn_Between_Hosts[Old_Conn_Pointer].ip_dest , Conn_Between_Hosts[Old_Conn_Pointer].dest_port);
  194.       wmove(main_window, Old_Conn_Pointer - Conn_Base_Pointer, LeftMargin + 56);  waddch(main_window, ACS_VLINE);
  195.       wprintw(main_window, " %s", Conn_Between_Hosts[Old_Conn_Pointer].status);
  196.       wmove(main_window, Old_Conn_Pointer - Conn_Base_Pointer, LeftMargin + 65);  waddch(main_window, ACS_VLINE);
  197.       wprintw(main_window, " %s", Conn_Between_Hosts[Old_Conn_Pointer].type);
  198.    }
  200.    if (has_colors())
  201.       wbkgdset(main_window, COLOR_PAIR(POINT_COLOR));
  202.    else
  203.       wattron(main_window,A_REVERSE);
  205.    wmove(main_window, Conn_Pointer - Conn_Base_Pointer, LeftMargin);
  206.    whline(main_window, ' ', W_SELECTCONN);                           //select new position
  208.    wprintw(main_window, "%3d) %15s:%d", Conn_Pointer+1, Conn_Between_Hosts[Conn_Pointer].ip_source, Conn_Between_Hosts[Conn_Pointer].source_port);
  209.    mvwprintw(main_window, Conn_Pointer-Conn_Base_Pointer, 28," <--> %15s:%d", Conn_Between_Hosts[Conn_Pointer].ip_dest , Conn_Between_Hosts[Conn_Pointer].dest_port);
  210.    wmove(main_window, Conn_Pointer - Conn_Base_Pointer, LeftMargin + 56);  waddch(main_window, ACS_VLINE);
  211.    wprintw(main_window, " %s", Conn_Between_Hosts[Conn_Pointer].status);
  212.    wmove(main_window, Conn_Pointer - Conn_Base_Pointer, LeftMargin + 65);  waddch(main_window, ACS_VLINE);
  213.    wprintw(main_window, " %s", Conn_Between_Hosts[Conn_Pointer].type);
  215.    werase(bottom_window);
  216.    mvwprintw(bottom_window, 0, 1, " %s", Conn_Between_Hosts[Conn_Pointer].user);
  217.    mvwprintw(bottom_window, 1, 1, " %s", Conn_Between_Hosts[Conn_Pointer].pass);
  218.    snprintf(info, W_MAINX2 - 23, "%s", Conn_Between_Hosts[Conn_Pointer].info);
  219.    mvwprintw(bottom_window, 1, 25, " %s", info);
  221.    wnoutrefresh(bottom_window);
  222.    wnoutrefresh(main_window);
  223.    doupdate();
  224. }
  228. void Interface_Sniff_RefreshList(void)
  229. {
  230.    WINDOW *message_window;
  232. #ifdef DEBUG
  233.    Debug_msg("Interface_Sniff_RefreshList");
  234. #endif
  236.    message_window = newwin(5, strlen("updating list...") + 4,0,0);
  237.    mvwin(message_window, W_MAINY1+(W_MAINY2-W_MAINY1)/2-2, W_MAINX2/2 - (strlen("updating list...") + 4)/2 );
  238.    wbkgdset(message_window, COLOR_PAIR(TITLE_COLOR));
  239.    wattron(message_window, A_BOLD);
  240.    box(message_window,ACS_VLINE,ACS_HLINE);
  241.    mvwprintw(message_window,  2, 2, "updating list...");
  242.    wnoutrefresh(message_window);
  243.    doupdate();
  245.    number_of_connections = Decodedata_RefreshConnectionList();
  246.    Conn_Pointer = 0;
  247.    Conn_Base_Pointer = 0;
  249.    delwin(message_window);
  250.    werase(bottom_window);
  251.    wnoutrefresh(bottom_window);
  252.    wnoutrefresh(main_window);
  254.    doupdate();
  256. }
  259. void Interface_Sniff_KillConn(void)
  260. {
  262.    u_char *buf;
  263.    char *MACD, MACS[6];
  264.    u_long IPS, IPD;
  265.    int sock;
  266. //   char answer;
  268.    if (Conn_Between_Hosts[Conn_Pointer].proto == 'U')
  269.    {
  270.       Interface_PopUp("Trying to kill an UDP connection ?!? Ehi Kiddie, go home !!");
  271.       return;
  272.    }
  275. //   answer = Interface_PopUp("Do U really want to kill this connection (y/n)?");
  276. //   if ((answer != 'y') && (answer != 'Y'))
  277. //      return;
  280. #ifdef DEBUG
  281.    Debug_msg("Interface_Sniff_KillConn -- %s:%d -> %s:%d  %lu %lu", Conn_Between_Hosts[Conn_Pointer].ip_source,
  282.                                                                     Conn_Between_Hosts[Conn_Pointer].source_port,
  283.                                                                     Conn_Between_Hosts[Conn_Pointer].ip_dest,
  284.                                                                     Conn_Between_Hosts[Conn_Pointer].dest_port,
  285.                                                                     Conn_Between_Hosts[Conn_Pointer].source_seq,
  286.                                                                     Conn_Between_Hosts[Conn_Pointer].dest_seq );
  287. #endif
  289.    Inet_GetMACfromString(Inet_MyMACAddress(), MACS);
  290.    IPS = inet_addr(Conn_Between_Hosts[Conn_Pointer].ip_source);
  291.    IPD = inet_addr(Conn_Between_Hosts[Conn_Pointer].ip_dest);
  293.    MACD=Inet_MacFromIP(IPD);
  295.    buf = Inet_Forge_packet( ETH_HEADER + IP_HEADER + TCP_HEADER );
  297.    Inet_Forge_ethernet( buf, MACS, MACD, ETH_P_IP );
  299.    Inet_Forge_ip( buf + ETH_HEADER, IPS, IPD, TCP_HEADER, 0xe77e, 0, IPPROTO_TCP );    // to source
  301.    Inet_Forge_tcp( buf + ETH_HEADER + IP_HEADER, Conn_Between_Hosts[Conn_Pointer].source_port,
  302.                                                  Conn_Between_Hosts[Conn_Pointer].dest_port,
  303.                                                  Conn_Between_Hosts[Conn_Pointer].source_seq,
  304.                                                  0,
  305.                                                  TH_RST,
  306.                                                  0, 0 );
  308.    sock = Inet_OpenRawSock(Options.netiface);
  310.    MACD=Inet_MacFromIP(IPS);
  312.    Inet_SendRawPacket(sock, buf, ETH_HEADER + IP_HEADER + TCP_HEADER );
  314.    Inet_Forge_ethernet( buf, MACS, MACD, ETH_P_IP );
  316.    Inet_Forge_ip( buf + ETH_HEADER, IPD, IPS, TCP_HEADER, 0xe77e, 0, IPPROTO_TCP );    // to dest
  318.    Inet_Forge_tcp( buf + ETH_HEADER + IP_HEADER, Conn_Between_Hosts[Conn_Pointer].dest_port,
  319.                                                  Conn_Between_Hosts[Conn_Pointer].source_port,
  320.                                                  Conn_Between_Hosts[Conn_Pointer].dest_seq,
  321.                                                  0,
  322.                                                  TH_RST,
  323.                                                  0, 0 );
  325.    Inet_SendRawPacket(sock, buf, ETH_HEADER + IP_HEADER + TCP_HEADER );
  327.    Inet_Forge_packet_destroy( buf );
  329.    strcpy(Conn_Between_Hosts[Conn_Pointer].status, "KILLED");
  331.    close(sock);
  333. }
  336. void Interface_Sniff_ActiveDissecor(short mode)
  337. {
  339. #ifdef DEBUG
  340.    Debug_msg("Interface_Sniff_ActiveDissecor %d", active_dissector);
  341. #endif
  343.    wbkgdset(top_window, COLOR_PAIR(HELP_COLOR));
  344.    mvwprintw(top_window, 2, 31, "Active Dissector: ");
  346.    switch(active_dissector)
  347.    {
  348.       case 1:  wbkgdset(top_window, COLOR_PAIR(BOTTOM_COLOR));
  349.                mvwprintw(top_window, 2, 49, "ON ");
  350.                break;
  352.       case 0:  wbkgdset(top_window, COLOR_PAIR(BOTTOM_COLOR));
  353.                mvwprintw(top_window, 2, 49, "OFF");
  354.                break;
  355.    }
  357.    wnoutrefresh(top_window);
  358.    doupdate();
  360. }
  364. void Interface_Sniff_Run(short mode)
  365. {
  366.    int KeyPress;
  367.    int Illithid_pid = 0, Dopple_pid = 0;
  368.    fd_set msk_fd;
  369.    struct timeval TimeOut;
  370.    CONNECTION data_from_illithid;
  372. #ifdef DEBUG
  373.    Debug_msg("Interface_Sniff_Run -- mode %d", mode);
  374. #endif
  377.    wbkgdset(main_window, COLOR_PAIR(MAIN_COLOR));
  378.    werase(main_window);
  379.    werase(bottom_window);
  381.    wmove(bottom_window, 0, 0);
  382.    wnoutrefresh(main_window);
  383.    wnoutrefresh(bottom_window);
  384.    doupdate();
  386.    if (mode != ARPBASED )
  387.       active_dissector = 0;
  389.    Interface_Sniff_ActiveDissecor(mode);
  391.    number_of_connections = 0;
  392.    Interface_Sniff_RefreshList();
  393.    Interface_Sniff_InitList();
  395.    Buffer_Flush(pipe_with_illithid);
  397.    switch (mode)
  398.    {
  399.       case ARPBASED:
  400.       case PUBLICARP:
  401.                      Dopple_pid = Doppleganger_Run(Options.netiface, Host_Source.ip, Host_Dest.ip, Host_Source.mac, Host_Dest.mac);
  403.                      if ( mode == ARPBASED )
  404.                         Illithid_pid = Illithid_ARPBased_GetConnections(Options.netiface, Host_Source.ip, Host_Dest.ip, Host_Source.mac, Host_Dest.mac);
  405.                      else
  406.                         Illithid_pid = Illithid_PublicARP_GetConnections(Options.netiface, Host_Source.ip, Host_Dest.ip, Host_Source.mac, Host_Dest.mac);
  407.                      break;
  408.       case IPBASED:
  409.                      Illithid_pid = Illithid_IPBased_GetConnections(Options.netiface, Host_Source.ip, Host_Dest.ip);
  410.                      break;
  411.       case MACBASED:
  412.                      Illithid_pid = Illithid_MACBased_GetConnections(Options.netiface, Host_Source.mac, Host_Dest.mac);
  413.                      break;
  414.    }
  417.    memset(&TimeOut, 0, sizeof(TimeOut));  //  timeout = 0
  418.    FD_ZERO(&msk_fd);
  420.    loop
  421.    {
  422.       int datalen;
  423.       FD_SET(0, &msk_fd);
  425.       select(FOPEN_MAX, &msk_fd, (fd_set *) 0, (fd_set *) 0, &TimeOut);
  427.       memset(&data_from_illithid, 0, sizeof(CONNECTION));
  428.       datalen = Buffer_Get(pipe_with_illithid, &data_from_illithid, sizeof(CONNECTION));
  430.       if (datalen > 0)
  431.       {
  432.          number_of_connections = Decodedata_MakeConnectionList(data_from_illithid);
  433.          Interface_Sniff_InitList();
  434.       }
  435.       else  // workaround for the 100% CPU usage...
  436.          usleep(5);
  438.       if (FD_ISSET(0, &msk_fd))
  439.       {
  441.          KeyPress = wgetch(main_window);
  443.          switch (KeyPress)
  444.          {
  445.             case KEY_DOWN:
  446.                      Interface_Sniff_PointItem(1);
  447.                      break;
  449.             case KEY_UP:
  450.                      Interface_Sniff_PointItem(-1);
  451.                      break;
  453.             case KEY_NPAGE:
  454.                      Interface_Sniff_PointItem(Sel_Number-1);  //PGDOWN
  455.                      break;
  457.             case KEY_PPAGE:
  458.                      Interface_Sniff_PointItem(-Sel_Number+1); //PGUP
  459.                      break;
  461.             case KEY_RETURN:
  462.                      if (Conn_Between_Hosts[Conn_Pointer].ip_source == NULL) break;   // no connections
  463.                      wmove(bottom_window, 0, 0);
  464.                      if ( mode == PUBLICARP )
  465.                          kill(Dopple_pid,SIGTERM);    // kill publicARP doppleganger...
  467.                      kill(Illithid_pid, SIGUSR2);
  468.                      Interface_Sniff_Data_Run(Conn_Between_Hosts[Conn_Pointer].ip_source,
  469.                                               Conn_Between_Hosts[Conn_Pointer].source_port,
  470.                                               Conn_Between_Hosts[Conn_Pointer].ip_dest,
  471.                                               Conn_Between_Hosts[Conn_Pointer].dest_port,
  472.                                               Conn_Between_Hosts[Conn_Pointer].mac_source,
  473.                                               Conn_Between_Hosts[Conn_Pointer].mac_dest,
  474.                                               Conn_Between_Hosts[Conn_Pointer].proto,
  475.                                               Conn_Between_Hosts[Conn_Pointer].type,
  476.                                               mode);
  477.                      // wait and then...
  478.                      kill(Illithid_pid, SIGUSR2);
  479.                      if ( mode == PUBLICARP )
  480.                          Dopple_pid = Doppleganger_Run(Options.netiface, Host_Source.ip, Host_Dest.ip, Host_Source.mac, Host_Dest.mac);
  482.                      Interface_Sniff_InitList();
  483.                      break;
  485.             case 'K':
  486.             case 'k':
  487.                      if (Conn_Between_Hosts[Conn_Pointer].ip_source == NULL) break;   // no connections
  488.                      Interface_Sniff_KillConn();      // with TH_RST !  i'm too tired to implement FIN handshaking
  489.                      Interface_Sniff_InitList();
  490.                      break;
  492.             case 'D':
  493.             case 'd':
  494.                      {
  495.                         char source[40];
  496.                         char dest[40];
  497.                         char mesg[80];
  498.                         if (Conn_Between_Hosts[Conn_Pointer].ip_source == NULL) break;   // no connections
  499.                         snprintf(source, 40, " %s (%s) <-->", Inet_HostName(Conn_Between_Hosts[Conn_Pointer].ip_source),
  500.                                                               Conn_Between_Hosts[Conn_Pointer].ip_source);
  501.                         snprintf(dest, 40, " %s (%s)", Inet_HostName(Conn_Between_Hosts[Conn_Pointer].ip_dest),
  502.                                                        Conn_Between_Hosts[Conn_Pointer].ip_dest);
  503.                         snprintf(mesg, 80, "%s%s", source, dest);
  504.                         Interface_PopUp(mesg);
  505.                      }
  506.                      break;
  508.             case 'R':
  509.             case 'r':
  510.                      Interface_Sniff_RefreshList();
  511.                      Interface_Sniff_InitList();
  512.                      break;
  514.             case 'A':
  515.             case 'a':
  516.                      if (mode == ARPBASED)
  517.                      {
  518.                         kill(Illithid_pid, SIGUSR1);  // activate/deactivate special dissector
  519.                         active_dissector = 0;
  520.                         Interface_Sniff_ActiveDissecor(mode);
  521.                      }
  522.                      else
  523.                      {
  524.                         Interface_PopUp("ACTIVE dissector is available only in ARP BASED mode !!");
  525.                      }
  526.                      break;
  528.             case KEY_CTRL_L:  // CTRL+L refresh the screen
  529.                      Interface_Redraw();
  530.                      break;
  532.             case KEY_F(1):
  533.             case 'H':
  534.             case 'h':{
  535.                         static char *help[] = {
  536.                            "[qQ][F10] - quit",
  537.                            "[return]  - sniff the selected connection",
  538.                            "[aA]      - enable/disable ACTIVE password collector",
  539.                            "[kK]      - kill the connection (be careful !)",
  540.                            "[dD]      - resolve ip via DNS",
  541.                            "[rR]      - refresh the list",
  542.                            NULL};
  543.                         Interface_HelpWindow(help);
  544.                      }
  545.                      Interface_Redraw();
  546.                      break;
  548.             case 'Q':
  549.             case 'q':
  550.                      kill(Illithid_pid, SIGTERM);
  551.                      if (Dopple_pid) kill(Dopple_pid, SIGTERM);
  552.                      #ifdef DEBUG
  553.                         Debug_msg("Interface_Sniff_END");
  554.                      #endif
  555.                      if (Options.silent) Interface_WExit("They are safe!!  for now... ");
  556.                      werase(bottom_window);
  557.                      wnoutrefresh(bottom_window);
  558.                      doupdate();
  559.                      return;
  560.                      break;
  562.             case KEY_F(10):
  563.                      #ifdef DEBUG
  564.                         Debug_msg("Interface_Sniff_END");
  565.                         Debug_msg("Interface_Run_END");
  566.                      #endif
  567.                      kill(Illithid_pid, SIGTERM);
  568.                      if (Dopple_pid) kill(Dopple_pid, SIGTERM);
  569.                      Interface_WExit("They are safe!!  for now... ");
  570.                      break;
  571.          }
  572.       }
  574.    }
  576. }
  580. #endif
  582. /* EOF */