hermes.c

Go to the documentation of this file.

/* Linux Prism II Stumbler - Utility Scan for 802_11 networks under Linux
 * 
 * File : hermes.c
 * Project : WifiScanner (c) 2002 Hervé Schauer Consultants
 * Usage : This utility is written for use with IEEE 802.11 adapters based
 * on Intersil's PRISM II chipset (PCMCIA).
 * 
 * Base code was from prismstumbler Jan Fernquist <Jan.B.Fernquist@telia.com>
 * and wlanctl from www.linux-wlan.com
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 * $Id: hermes.c 174 2007-07-25 13:20:29Z poggij $
 */

// A lot of think is get from kismet
//  http://www.kismetwireless.net/

#include <include.h>
#include <src/hermes.h>
#include <src/crt_io.h>
#include <src/functions.h>

static char *ID = "$Id: hermes.c 174 2007-07-25 13:20:29Z poggij $";

// All extern value you want
extern UINT8 SingleChannel;
extern UINT8 TypeOfCard;

static CaptureArg ca;
static char errbuf[PCAP_ERRBUF_SIZE];
static UINT8 wlan_payload[MAX_BUFFER_SIZE];

//-------------
int selectChannelHERMES(char *devname, int channel)
{
  char str[80];
  int result = NO_ERROR;

#if 0
  sprintf(str, "iwpriv %s monitor 1 %d 2>/dev/null 1>/dev/null", devname,
          channel);
  //debug(3, str, "\n");
  result += system(str);
#endif
  Iwconfig_Set_IntPriv(devname, "monitor", 1, channel);

  //return result;
  // No error return, because it's possible to change to a forbidden channel
  //  So we don't want that the program stop because of this restriction
  return NO_ERROR;
}

int shutCardHERMES(char *devname)
{
  char str[80];
  int result = NO_ERROR;

  // Turn off monitor mode
  result = IwconfigSetMode(devname, IW_MODE_INFRA);
  warning_if_error(result);

  result = IfconfigSetFlags(devname, 0);
  warning_if_error(result);

  sprintf(str, "iwpriv %s monitor 0 1", devname);
  debug(3, "%s\n", str);
  result += system(str);

  return result;
}

int openCardHERMES(char *devname)
{
  char str[80];
  int result = NO_ERROR;

  // Turn on monitor mode
  result = IfconfigSetFlags(devname, IFF_UP + IFF_PROMISC);
  warning_if_error(result);

  IwconfigClearSSID(devname);

  sprintf(str, "iwpriv %s monitor 1 1", devname);
  debug(3, "%s\n", str);
  result += system(str);

  return result;
}


// Get packet from card
int getPacketHERMES(p80211_caphdr_t * wlan_header, UINT8 * buf, int maxlen)
{
  struct pcap_pkthdr pktHdr;
  u_char *ret;
  fd_set rs;
  p80211msg_lnxind_wlansniffrm_t *Sniff_Frame;

  FD_ZERO(&rs);
  FD_SET(0, &rs);

  ret = (u_char *) pcap_next(ca.pcap, &pktHdr);
  // If no problem and packet is enought big (with data)
  if ((ret)
      && (pktHdr.len >= sizeof(p80211msg_lnxind_wlansniffrm_t))) {
    if (memcpy_buff(buf, ret, pktHdr.len) == NULL)
      return 0;
    Sniff_Frame = (p80211msg_lnxind_wlansniffrm_t *) buf;
    // Fill Header
    wlan_header->version = 0;    // It's a reduced capture frame format
    wlan_header->length = 0;     // Not used for now
    wlan_header->mactime = Sniff_Frame->mactime.data;
    wlan_header->hosttime = Sniff_Frame->hosttime.data;
    wlan_header->phytype = phytype_dsss_dot11_b; // Not used for now
    wlan_header->channel = Sniff_Frame->channel.data;
    wlan_header->datarate = Sniff_Frame->rate.data * 5;  // datarate is in units of 100kbps.
    wlan_header->antenna = 0;    // Not used for now
    wlan_header->priority = 0;   // Not used for now
    wlan_header->ssi_type = 0;   // Not used for now
    wlan_header->ssi_signal = Sniff_Frame->signal.data;
    wlan_header->ssi_noise = Sniff_Frame->noise.data;
    wlan_header->preamble = 0;   // Not used for now
    wlan_header->encoding = 0;   // Not used for now
    // Fill data frame
    if (memcpy_buff(wlan_payload,
                    &buf[sizeof(p80211msg_lnxind_wlansniffrm_t)],
                    pktHdr.len - sizeof(p80211msg_lnxind_wlansniffrm_t)) ==
        NULL)
      return 0;
    if (memcpy_buff(buf, wlan_payload,
                    maxlen - sizeof(p80211msg_lnxind_wlansniffrm_t)) ==
        NULL)
      return 0;

    if (pktHdr.len <= sizeof(p80211msg_lnxind_wlansniffrm_t))
      // Don't return negative value
      return 0;
    else
      return (pktHdr.len - sizeof(p80211msg_lnxind_wlansniffrm_t));
  } else {
    return (0);                 /* Noting to read */
  }
}

int openPacketHERMES(char *devname)
{
  ca.pcap = pcap_open_live(devname, 3000, 1, 0, errbuf);
  if (ca.pcap) {
    pcap_setnonblock(ca.pcap, 1, errbuf);
    ca.DataLink = pcap_datalink(ca.pcap);
    ca.offset = CalculateOffset(ca.DataLink);
    return NO_ERROR;
  }
  return ERROR_CANT_OPEN_PCAP;
}

void closePacketHERMES(void)
{
  pcap_close(ca.pcap);
}

---