Beispiel #1
0
int decode_hixie(char *src, size_t srclength, u_char *target, size_t targsize) {
   char *start, *end, cntstr[4];
   int len, framecount = 0, retlen = 0;
   if ((src[0] != '\x00') || (src[srclength-1] != '\xff')) {
      handler_emsg("WebSocket framing error\n");
      return -1;
   }
   start = src+1; // Skip '\x00' start
   do {
      /* We may have more than one frame */
      end = (char *)memchr(start, '\xff', srclength);
      *end = '\x00';
      len = b64_pton(start, target+retlen, targsize-retlen);
      if (len < 0) {
         return len;
      }
      retlen += len;
      start = end + 2; // Skip '\xff' end and '\x00' start 
      framecount++;
   } while (end < (src+srclength-1));
   if (framecount > 1) {
      snprintf(cntstr, 3, "%d", framecount);
      traffic(cntstr);
   }
   return retlen;
}
Beispiel #2
0
int decode_hixie(char *src, size_t srclength,
                 u_char *target, size_t targsize,
                 unsigned int *opcode, unsigned int *left) {
    char *start, *end, cntstr[4];
    int i, len, framecount = 0, retlen = 0;
    unsigned char chr;
    if ((src[0] != '\x00') || (src[srclength-1] != '\xff')) {
        handler_emsg("WebSocket framing error\n");
        return -1;
    }
    *left = srclength;

    if (srclength == 2 &&
        (src[0] == '\xff') && 
        (src[1] == '\x00')) {
        // client sent orderly close frame
        *opcode = 0x8; // Close frame
        return 0;
    }
    *opcode = 0x1; // Text frame

    start = src+1; // Skip '\x00' start
    do {
        /* We may have more than one frame */
        end = (char *)memchr(start, '\xff', srclength);
        *end = '\x00';
        len = b64_pton(start, target+retlen, targsize-retlen);
        if (len < 0) {
            return len;
        }
        retlen += len;
        start = end + 2; // Skip '\xff' end and '\x00' start 
        framecount++;
    } while (end < (src+srclength-1));
    if (framecount > 1) {
        snprintf(cntstr, 3, "%d", framecount);
        traffic(cntstr);
    }
    *left = 0;
    return retlen;
}
Beispiel #3
0
int decode_hybi(unsigned char *src, size_t srclength,
                u_char *target, size_t targsize,
                unsigned int *opcode, unsigned int *left)
{
    unsigned char *frame, *mask, *payload, save_char, cntstr[4];;
    int masked = 0;
    int i = 0, len, framecount = 0;
    size_t remaining;
    unsigned int target_offset = 0, hdr_length = 0, payload_length = 0;
    
    *left = srclength;
    frame = src;

    //printf("Deocde new frame\n");
    while (1) {
        // Need at least two bytes of the header
        // Find beginning of next frame. First time hdr_length, masked and
        // payload_length are zero
        frame += hdr_length + 4*masked + payload_length;
        //printf("frame[0..3]: 0x%x 0x%x 0x%x 0x%x (tot: %d)\n",
        //       (unsigned char) frame[0],
        //       (unsigned char) frame[1],
        //       (unsigned char) frame[2],
        //       (unsigned char) frame[3], srclength);

        if (frame > src + srclength) {
            //printf("Truncated frame from client, need %d more bytes\n", frame - (src + srclength) );
            break;
        }
        remaining = (src + srclength) - frame;
        if (remaining < 2) {
            //printf("Truncated frame header from client\n");
            break;
        }
        framecount ++;

        *opcode = frame[0] & 0x0f;
        masked = (frame[1] & 0x80) >> 7;

        if (*opcode == 0x8) {
            // client sent orderly close frame
            break;
        }

        payload_length = frame[1] & 0x7f;
        if (payload_length < 126) {
            hdr_length = 2;
            //frame += 2 * sizeof(char);
        } else if (payload_length == 126) {
            payload_length = (frame[2] << 8) + frame[3];
            hdr_length = 4;
        } else {
            handler_emsg("Receiving frames larger than 65535 bytes not supported\n");
            return -1;
        }
        if ((hdr_length + 4*masked + payload_length) > remaining) {
            continue;
        }
        //printf("    payload_length: %u, raw remaining: %u\n", payload_length, remaining);
        payload = frame + hdr_length + 4*masked;

        if (*opcode != 1 && *opcode != 2) {
            handler_msg("Ignoring non-data frame, opcode 0x%x\n", *opcode);
            continue;
        }

        if (payload_length == 0) {
            handler_msg("Ignoring empty frame\n");
            continue;
        }

        if ((payload_length > 0) && (!masked)) {
            handler_emsg("Received unmasked payload from client\n");
            return -1;
        }

        // Terminate with a null for base64 decode
        save_char = payload[payload_length];
        payload[payload_length] = '\0';

        // unmask the data
        mask = payload - 4;
        for (i = 0; i < payload_length; i++) {
            payload[i] ^= mask[i%4];
        }

        // base64 decode the data
        len = b64_pton((const char*)payload, target+target_offset, targsize);

        // Restore the first character of the next frame
        payload[payload_length] = save_char;
        if (len < 0) {
            handler_emsg("Base64 decode error code %d", len);
            return len;
        }
        target_offset += len;

        //printf("    len %d, raw %s\n", len, frame);
    }

    if (framecount > 1) {
        snprintf(cntstr, 3, "%d", framecount);
        traffic(cntstr);
    }
    
    *left = remaining;
    return target_offset;
}
Beispiel #4
0
void initializeNodeInfo(staInfo sta[], apInfo* ap){
	int i, j;

	for(i=0; i<gSpec.numSta; i++){
		for(j=0; j<BUFFER_SIZE; j++){
			sta[i].buffer[j].lengthMsdu = 0;
			sta[i].buffer[j].timeStamp = 0.0;
			/*if(sta[i].sumFrameLengthInBuffer>(gSpec.bufferSizeByte*1000)){
				sta[i].waitFrameLength = sta[i].buffer[i].lengthMsdu;
				sta[i].sumFrameLengthInBuffer -= sta[i].buffer[i].lengthMsdu;
				sta[i].buffer[i].lengthMsdu = 0;
				sta[i].buffer[i].timeStamp = 0.0;
				break;
			}*/
		}
		sta[i].buffer[0].lengthMsdu = traffic(true);
		sta[i].sumFrameLengthInBuffer = sta[i].buffer[0].lengthMsdu;
		sta[i].waitFrameLength = traffic(true);
		sta[i].backoffCount = rand() % (gStd.cwMin + 1);
		sta[i].cw = gStd.cwMin;
		sta[i].retryCount = 0;
		sta[i].numTxFrame = 0;
		sta[i].numCollFrame = 0;
		sta[i].numLostFrame = 0;
		sta[i].numSuccFrame = 0;
		sta[i].numPrimFrame = 0;
		sta[i].byteSuccFrame = 0;
		sta[i].fCollNow = false;
		sta[i].afterColl = 0;
		sta[i].fSuccNow = false;
		sta[i].afterSucc = 0;
		sta[i].fTx = false;
		//sta[i].sumFrameLengthInBuffer = 0;
		sta[i].sumDelay = 0.0;
		sta[i].x = (double)(rand() % 1000 + 1) / 10;
		sta[i].y = (double)(rand() % 1000 + 1) / 10;
		sta[i].txPower = 20.0;   //dBm
		sta[i].antennaGain = 2.0;   //dBi
		sta[i].timeNextFrame = poisson(true);
	}

	for(i=0; i<BUFFER_SIZE; i++){
		ap->buffer[i].lengthMsdu = 0;
		ap->buffer[i].timeStamp = 0.0;
		/*if(ap->sumFrameLengthInBuffer>(gSpec.bufferSizeByte*1000)){
			ap->waitFrameLength = ap->buffer[i].lengthMsdu;
			ap->sumFrameLengthInBuffer -= ap->buffer[i].lengthMsdu;
			ap->buffer[i].lengthMsdu = 0;
			ap->buffer[i].timeStamp = 0.0;
			break;
		}*/
	}
	ap->buffer[0].lengthMsdu = traffic(false);
	ap->sumFrameLengthInBuffer = ap->buffer[0].lengthMsdu;
	ap->waitFrameLength = traffic(false);
	ap->backoffCount = rand() % (gStd.cwMin + 1);
	ap->cw = gStd.cwMin;
	ap->retryCount = 0;
	ap->numTxFrame = 0;
	ap->numCollFrame = 0;
	ap->numLostFrame = 0;
	ap->numSuccFrame = 0;
	ap->numPrimFrame = 0;
	ap->byteSuccFrame = 0;
	ap->fCollNow = false;
	ap->afterColl = 0;
	ap->fSuccNow = false;
	ap->afterSucc = 0;
	ap->fTx = false;
	//ap->sumFrameLengthInBuffer = 0;
	ap->sumDelay = 0.0;
	ap->x = 0.0;
	ap->y = 0.0;
	ap->txPower = 20.0;
	ap->antennaGain = 2.0;
	ap->timeNextFrame = poisson(false);
}
Beispiel #5
0
/**
 * interfaces are set up in NetIface[], listen!
 */
static int do_listen(void)
{
    /* all ifaces set up... */
    /* FIXME: how do i deal with one iface going down and the others staying up? */
  unsigned i;
  struct timeval tv;
#ifdef WIN32
  HANDLE handles[IFACE_MAX];
#else
  int fds[IFACE_MAX];
  fd_set rd;
  int fdmax = -1;
#endif
  /* initial setup for select()ing */
  tv.tv_sec = 1;
  tv.tv_usec = 0;
  for (i = 0; i < NetIfaces; i++) {
    struct netiface *n = NetIface + i;
#ifdef WIN32
    handles[i] = pcap_getevent(n->pcap);
#else
    fds[i] = pcap_get_selectable_fd(n->pcap);
    if (fds[i] > fdmax)
      fdmax = fds[i];
#endif
  }
  while (0 == Shutdown) {
    static int CountdownToDoom = 0;
    int sel;
#ifdef WIN32
    sel = WaitForMultipleObjects((DWORD)NetIfaces, handles, TRUE, (long)SelectFreq * 1000);
#else
    FD_ZERO(&rd);
    for (i = 0; i < NetIfaces; i++)
      FD_SET(fds[i], &rd);
    sel = select(fdmax + 1, &rd, NULL, NULL, NULL);
#endif
    switch (sel) {
#ifdef WIN32
    case WAIT_FAILED:
#else
    case -1: /* error */
#endif
      perror("select");
      break;
#ifdef WIN32
    case WAIT_TIMEOUT:
#else
    case 0: /* timeout */
#endif
      fprintf(stderr, "timeout...\n");
      continue;
      break;
    default: /* one or more readable */
      for (i = 0; i < NetIfaces; i++) {
        struct netiface *n = NetIface + i;
        struct pcap_pkthdr *header;
        char *packet;
        int cap;
#ifdef WIN32
        if (WAIT_OBJECT_0 + i != sel) {
#else
        if (!FD_ISSET(fds[i], &rd)) {
#endif
          continue;
        }
        /* ok, there should be a packet waiting for us... */
        cap = pcap_next_ex(n->pcap, &header, (const u_char **)&packet);
        switch (cap) {
        case -1: /* err */
          break;
        case 0: /* timeout */
          break;
        case 1: /* ok */
        { /* case scope */
          static parse_status st;
          st.frames = 0;
          parse(packet, header->len, pcap_datalink(n->pcap), &st);
          traffic(&st);
#if 1
          dump(&st);
#endif


#if 0
          /*
           * Crash if we receive data that we did not parse,
           * with the following exceptions...
           */
          if (st.frame[st.frames-1].id == PROT_UNKNOWN
              /* enumerate all cases where we know we get unknown bytes */
              && !(
                /* ethernet frames are often padded with garbage to meet 60 bytes */
                (PROT_IEEE802_3 == st.frame[1].id && 60 == st.frame[0].len)
                /* junk after LLC... */
                || (PROT_STP == st.frame[st.frames-2].id && 7 == st.frame[st.frames-1].len)
                /* junk after SMB over LLC... */
                || (PROT_SMB == st.frame[st.frames-2].id && PROT_LLC == st.frame[2].len)
                /* junk zeroes after BOOTP */
                || (PROT_BOOTP == st.frame[st.frames-2].id &&
                  allzeroes(st.frame[st.frames-1].off, st.frame[st.frames-1].len))
                /* junk after LLDP... */
                || (PROT_LLDP == st.frame[st.frames-2].id && 2 == st.frame[st.frames-1].len)
                /* mysterious message */
                || (PROT_LLC == st.frame[2].id && 82 == st.frame[0].len)
                /* TCP payload */
                || (PROT_TCP == st.frame[st.frames-2].id)
                /* ARP oftens contains garbage */
                || (PROT_ARP == st.frame[st.frames-2].id)
              )) {
            abort();
          }
#endif


#if 0
          /* 
           * the 'gprof' profiling tool requires a clean stop
           * of the program being profiled in order to work.
           * this causes that
           */
          if (CountdownToDoom++ > 4000)
            Shutdown = 1;
#endif




        }
          break;
        default:
          break;
        }
#ifdef WIN32
        break; /* WaitForMultipleObjects only returns the first available, not all */
#endif
      }
      break;
    } /* switch */
  } /* read loop */
  if (Verbosity >= 2) {
    printf("interfaces");
    for (i = 0; i < NetIfaces; i++)
      printf(" %s", NetIface[i].name);
    printf(" down...\n");
  }
  return 1; 
}

/**
 * main loop
 */
static int listen(void)
{
  static char errbuf[PCAP_ERRBUF_SIZE];
  char *dev;
  unsigned i;
  /* listen loop */
  do { 
    int promisc = 1;
    if (0 == NetIfaces) { /* no devs specified, find one */
      dev = pcap_lookupdev(errbuf);
      if (NULL == dev) {
        fprintf(stderr, "Couldn't find default interface: %s\n", errbuf);
        return 0;
      }
      if (Verbosity >= 1)
        printf("Defaulting to dev '%s'\n", dev);
      netiface_add(dev);
    }
    /* set up each iface */
    for (i = 0; i < NetIfaces; i++) {
      struct netiface *n = NetIface + i;
#ifdef WIN32
      promisc = 1;
#else
      promisc = (0 == geteuid());
#endif
      if (Verbosity >= 1)
        printf("opening dev '%s' in %s mode...\n",
          n->name, promisc ? "promiscuous" : "normal");
      n->pcap = pcap_open_live(n->name, PACKET_BUFLEN, promisc, 0, errbuf);
      if (!n->pcap) {
        fprintf(stderr, "Can't open interface '%s'! %s\n", n->name, errbuf);
        fprintf(stderr, "Have you specified an interface with -i?. See -h for more -i info.\n");
        return 0;
      }
      if (-1 == pcap_lookupnet(n->name, &n->net, &n->mask, errbuf)) {
        fprintf(stderr, "Can't get netmask for interface '%s': %s, continuing...\n",
          n->name, errbuf);
        /* no ip address up?! keep on truckin... */
      }
  
      /* TODO: human-readable output, perhaps? */
      if (Verbosity >= 2)
        printf("interface '%s' net: 0x%08X, mask: 0x%08X\n",
          n->name, n->net, n->mask);
    
      /* set filter if we've been supplied one and we've got an ip addres... */
      printf("Applying Filter_Str=\"%s\"...\n", Filter_Str);
      if (NULL != Filter_Str && 0 != n->net && 0 != n->mask) {
        if (-1 == pcap_compile(n->pcap, &Filter, Filter_Str, 0, n->net)) {
          fprintf(stderr, "Can't compile filter '%s': %s. quitting\n",
            Filter_Str, pcap_geterr(n->pcap));
          return 0;
        }
        if (-1 == pcap_setfilter(n->pcap, &Filter)) {
          fprintf(stderr, "Can't install filter '%s': %s. quitting\n",
            Filter_Str, pcap_geterr(n->pcap));
          return 0;
        }
      }
    }
    do_listen();
  } while (!Shutdown);
  return 0;
}

int main(void)
{
  rep_init(stderr);
  parse_init();
  (void)iface_list();
  listen();
  return 0;
}