Ejemplo n.º 1
0
static inline __m128i  byteswap32( __m128i v )
{
	//rotate each 32 bit quantity by 16 bits
	// 0xB1 = 10110001 = 2,3,0,1
	v = _mm_shufflehi_epi16( _mm_shufflelo_epi16( v, 0xB1 ), 0xB1 );
	return byteswap16( v );
}
Ejemplo n.º 2
0
static int dealias_ipid16_inseq(scamper_dealias_probe_t **probes,
				int probec, uint16_t fudge, int bs)
{
  uint16_t a, b, c;
  int i;

  /*
   * do a preliminary check to see if the ipids could be in sequence with
   * two samples.
   */
  if(probec == 2)
    {
      /* if it is a strict sequence check, we don't actually know */
      if(fudge == 0)
	return 1;

      a = probes[0]->replies[0]->ipid;
      b = probes[1]->replies[0]->ipid;
      if(bs != 0)
	{
	  a = byteswap16(a);
	  b = byteswap16(b);
	}
      if(dealias_ipid16_inseq2(a, b, fudge) != 0)
	return 1;
      return 0;
    }

  for(i=0; i+2<probec; i++)
    {
      a = probes[i+0]->replies[0]->ipid;
      b = probes[i+1]->replies[0]->ipid;
      c = probes[i+2]->replies[0]->ipid;
      if(bs != 0)
	{
	  a = byteswap16(a);
	  b = byteswap16(b);
	  c = byteswap16(c);
	}
      if(dealias_ipid16_inseq3(a, b, c, fudge) == 0)
	return 0;
    }

  return 1;
}
Ejemplo n.º 3
0
static int write_file_info(state *s)
{
  BITMAPINFOHEADER b;

  // Size of the this header information
  b.biSize = byteswap32(HEADERINFOSIZE);  

  if (s->orientation == ORIENTATION_VERTICAL)
    {
      b.biWidth = byteswap32(s->image_width);
      b.biHeight = byteswap32(s->image_height);
    }
  else
    {
      b.biWidth = byteswap32(s->image_height);
      b.biHeight = byteswap32(s->image_width);
    }

  b.biPlanes      = byteswap16(1);
  b.biBitCount    = byteswap16(24);
  b.biCompression = BI_RGB;

  // How much RGB data follows this header 
  b.biSizeImage = byteswap32((s->image_width * s->image_height) * 3);

  b.biXPelsPerMeter = 0;
  b.biYPelsPerMeter = 0;
  // These values denote how many values are in the RGB color map
  // that follows. 
  b.biClrUsed       = 0;
  b.biClrImportant  = 0;

  if (s->verbose)
    print_status ("%s: Image will be %"PRIu32" x %"PRIu32" x %"PRIu32, 
		  __progname,
		  byteswap32(b.biWidth), 
		  byteswap32(b.biHeight), 
		  byteswap16(b.biBitCount));
  
  fwrite(&b,HEADERINFOSIZE,1,s->out_handle);

  return FALSE;
}
Ejemplo n.º 4
0
static int dealias_ipid16_bo(scamper_dealias_probe_t **probes, int probec)
{
  scamper_dealias_probe_t **s = NULL;
  uint16_t a, b, c = 1, max_bs = 0, max_nobs = 0, u16;
  int i, rc = 2;

  if((s = memdup(probes, sizeof(scamper_dealias_probe_t *) * probec)) == NULL)
    return -1;
  array_qsort((void **)s, probec, (array_cmp_t)dealias_probe_def_cmp);

  for(i=0; i<probec-1; i++)
    {
      if(s[i]->def != s[i+1]->def)
	{
	  if(c >= 3)
	    {
	      if(max_nobs < max_bs)
		rc = 0;
	      else if(max_nobs > max_bs)
		rc = 1;
	      if(rc == 0)
		goto done;
	    }
	  c = 1; max_nobs = 0; max_bs = 0;
	}
      else
	{
	  a = s[i]->replies[0]->ipid; b = s[i+1]->replies[0]->ipid;
	  u16 = dealias_ipid16_diff(a, b);
	  if(u16 > max_nobs || max_nobs == 0)
	    max_nobs = u16;
	  u16 = dealias_ipid16_diff(byteswap16(a), byteswap16(b));
	  if(u16 > max_bs || max_bs == 0)
	    max_bs = u16;
	  c++;
	}
    }

 done:
  if(s != NULL) free(s);
  return rc;
}
Ejemplo n.º 5
0
static int dealias_fudge_inseq(scamper_dealias_probe_t *pr_a,
			       scamper_dealias_probe_t *pr_b,
			       int bs, int fudge)
{
  uint32_t a = pr_a->replies[0]->ipid;
  uint32_t b = pr_b->replies[0]->ipid;

  if(bs != 0)
    {
      a = byteswap16(a);
      b = byteswap16(b);
    }

  if(a > b)
    b += 0x10000;

  if((int)(b - a) > fudge)
    return 0;

  return 1;
}
Ejemplo n.º 6
0
static inline uint16_t swaps(libtrace_t *libtrace, uint16_t num)
{
	/* To deal with open_dead traces that might try and use this
	 * if we don't have any per trace data, assume host byte order
	 */
	if (!DATA(libtrace))
		return num;
	
	/* We can use the PCAP magic number to determine the byte order */
	if (header_is_backwards_magic(&(DATA(libtrace)->header)))
		return byteswap16(num);

	return num;
}
Ejemplo n.º 7
0
/**
 * @brief writes 16-bit value to memory at address
 * @param mem memory to write to
 * @param address location to write to
 * @param value value to store in memory
 * @return true if success, otherwise false
 */
bool write16Memory(Memory &mem, U32 address, const U16 &value)
{
    bool retval;

    // Check alignment
    if ((address & 0x3) == 0) {
        if (address < MEMORY_SIZE) {
            U16 *memptr = (U16*)&mem.data[address];
            *memptr = byteswap16(value);
            retval = true;
        } else {
            printf("WRITE ERROR: Address 0x%08x >= 0x%08x\n",
                   address, MEMORY_SIZE);
            retval = false;
        }
    } else {
        printf("WRITE ERROR: Address 0x%08x is not 16-bit aligned\n", address);
        retval = false;
    }

    return retval;
}
Ejemplo n.º 8
0
/**
 * @brief reads 16-bit value memory at address and stores it in value
 * @param mem memory to read from
 * @param address location to read from
 * @param value location to store value read
 * @return true if success, otherwise false
 */
bool read16Memory(const Memory &mem, U32 address, U16 &value)
{
    bool retval;

    // Check alignment
    if ((address & 0x1) == 0) {
        if (address < MEMORY_SIZE) {
            U16 *memptr = (U16*)&mem.data[address];
            value = *memptr;
            value = byteswap16(value);
            retval = true;
        } else {
            printf("READ ERROR: Address 0x%08x >= 0x%08x\n",
                   address, MEMORY_SIZE);
            retval = false;
        }
    } else {
        printf("READ ERROR: Address 0x%08x is not 16-bit aligned\n", address);
        retval = false;
    }

    return retval;
}
Ejemplo n.º 9
0
int scamper_dealias_radargun_fudge(scamper_dealias_t *dealias,
				   scamper_dealias_probedef_t *def,
				   scamper_dealias_probedef_t **defs, int *cnt,
				   int fudge)
{
  scamper_dealias_radargun_t *rg = dealias->data;
  scamper_dealias_probe_t *pr, *pr_a, *pr_b;
  scamper_dealias_reply_t *re, *re_a, *re_b, *re_c;
  dealias_resolv_t *dr = NULL;
  dealias_resolv_t *drd;
  uint32_t pid, x;
  int i, j, k, bs, inseq, d = 0;

  if(dealias->method != SCAMPER_DEALIAS_METHOD_RADARGUN)
    goto err;

  if((dr = malloc_zero(sizeof(dealias_resolv_t) * rg->probedefc)) == NULL)
    goto err;

  for(x=0; x<dealias->probec; x++)
    {
      pr = dealias->probes[x];
      pid = pr->def->id;

      /*
       * if this probedef has already been determined to be useless for
       * alias resolution, skip it
       */
      if(dr[pid].probec < 0)
	continue;

      if(pr->replyc > 1)
	{
	  if(dr[pid].probes != NULL)
	    free(dr[pid].probes);
	  dr[pid].probec = -1;

	  if(pr->def == def)
	    goto done;
	  continue;
	}

      /* total number of probes transmitted */
      dr[pid].probet++;

      if(pr->replyc == 0)
	continue;

      re = pr->replies[0];

      /*
       * with three replies, do some basic checks to see if we should
       * continue considering this probedef.
       */
      if(dr[pid].probec == 2)
	{
	  pr_a = dr[pid].probes[0];
	  pr_b = dr[pid].probes[1];
	  re_a = pr_a->replies[0];
	  re_b = pr_b->replies[0];

	  if((re->ipid == pr->ipid && re_a->ipid == pr_a->ipid &&
	      re_b->ipid == pr_b->ipid) ||
	     (re->ipid == re_a->ipid && re->ipid == re_b->ipid))
	    {
	      free(dr[pid].probes);
	      dr[pid].probec = -1;

	      if(pr->def == def)
		goto done;
	      continue;
	    }
	}

      if(array_insert((void ***)&dr[pid].probes,&dr[pid].probec,pr,NULL) != 0)
	goto err;
    }

  /* figure out if we should byteswap the ipid sequence */
  if(dr[def->id].probec < 3)
    goto done;
  re_a = dr[def->id].probes[0]->replies[0];
  re_b = dr[def->id].probes[1]->replies[0];
  re_c = dr[def->id].probes[2]->replies[0];
  if(re_a->ipid < re_b->ipid)
    i = re_b->ipid - re_a->ipid;
  else
    i = 0x10000 + re_b->ipid - re_a->ipid;
  if(re_b->ipid < re_c->ipid)
    i += re_c->ipid - re_b->ipid;
  else
    i += 0x10000 + re_c->ipid - re_b->ipid;
  if(byteswap16(re_a->ipid) < byteswap16(re_b->ipid))
    j = byteswap16(re_b->ipid) - byteswap16(re_a->ipid);
  else
    j = 0x10000 + byteswap16(re_b->ipid) - byteswap16(re_a->ipid);
  if(byteswap16(re_b->ipid) < byteswap16(re_c->ipid))
    j += byteswap16(re_c->ipid) - byteswap16(re_b->ipid);
  else
    j += 0x10000 + byteswap16(re_c->ipid) - byteswap16(re_b->ipid);
  if(i < j)
    bs = 0;
  else
    bs = 1;

  /* for each probedef, consider if it could be an alias */
  drd = &dr[def->id]; d = 0;
  for(pid=0; pid<rg->probedefc; pid++)
    {
      if(&rg->probedefs[pid] == def || dr[pid].probec < 3)
	continue;

      j = 0; k = 0;

      /* get the first ipid */
      if(timeval_cmp(&drd->probes[j]->tx, &dr[pid].probes[k]->tx) < 0)
	pr_a = drd->probes[j++];
      else
	pr_a = dr[pid].probes[k++];

      for(;;)
	{
	  if(timeval_cmp(&drd->probes[j]->tx, &dr[pid].probes[k]->tx) < 0)
	    pr_b = drd->probes[j++];
	  else
	    pr_b = dr[pid].probes[k++];

	  if((inseq = dealias_fudge_inseq(pr_a, pr_b, bs, fudge)) == 0)
	    break;

	  if(j == drd->probec || k == dr[pid].probec)
	    break;
	}

      /*
       * if the pairs do not appear to have insequence IP-ID values, then
       * abandon
       */
      if(inseq == 0)
	continue;

      defs[d++] = &rg->probedefs[pid];
      if(d == *cnt)
	break;
    }

 done:
  *cnt = d;
  for(x=0; x<rg->probedefc; x++)
    if(dr[x].probec > 0)
      free(dr[x].probes);
  return 0;

 err:
  if(dr != NULL)
    {
      for(x=0; x<rg->probedefc; x++)
	if(dr[x].probec > 0)
	  free(dr[x].probes);
    }
  return -1;
}
Ejemplo n.º 10
0
int scamper_dealias_ipid(const scamper_dealias_probe_t **probes,
			 uint32_t probec, scamper_dealias_ipid_t *ipid)
{
  const scamper_dealias_probe_t *p;
  const scamper_dealias_reply_t *r;
  uint32_t bs_mind = 0x30000;
  uint32_t bs_maxd = 0;
  uint32_t bs_sum  = 0;
  uint32_t mind = 0x30000;
  uint32_t maxd = 0;
  uint32_t sum  = 0;
  uint32_t diff;
  uint32_t cur, prev;
  uint32_t i;
  int echo, cons;

  ipid->type = SCAMPER_DEALIAS_IPID_UNKNOWN;

  echo = 1;
  cons = 1;

  if(probec == 0 || probes[0] == NULL || probes[0]->replyc != 1)
    return 0;

  prev = probes[0]->replies[0]->ipid;
  for(i=1; i<probec; i++)
    {
      if((p = probes[i]) == NULL)
	return 0;

      if(p->replyc != 1)
	return 0;

      if((r = p->replies[0]) == NULL)
	return 0;

      /* non byteswap case */
      cur = r->ipid;
      if(cur > prev)
	diff = cur - prev;
      else if(cur < prev)
	diff = 0x10000 + cur - prev;
      else
	diff = 0;
      if(diff < mind)
	mind = diff;
      if(diff > maxd)
	maxd = diff;
      sum += diff;

      /* byteswap case */
      cur = byteswap16(r->ipid);
      prev = byteswap16(prev);
      if(cur > prev)
	diff = cur - prev;
      else if(cur < prev)
	diff = 0x10000 + cur - prev;
      else
	diff = 0;
      if(diff < bs_mind)
	bs_mind = diff;
      if(diff > maxd)
	bs_maxd = diff;
      bs_sum += diff;

      if(echo != 0 && p->ipid != r->ipid && p->ipid != byteswap16(r->ipid))
	echo = 0;
      else if(cons != 0 && probes[i-1]->replies[0]->ipid != r->ipid)
	cons = 0;

      prev = r->ipid;
    }

  if(cons == 0 && echo == 0)
    {
      /* figure out which byte ordering best explains the sequence */
      if(sum < bs_sum)
	{
	  ipid->mind = mind;
	  ipid->maxd = maxd;
	}
      else
	{
	  ipid->mind = bs_mind;
	  ipid->maxd = bs_maxd;
	}
      ipid->type = SCAMPER_DEALIAS_IPID_INCR;
    }
  else if(cons != 0)
    {
      if(probes[0]->replies[0]->ipid == 0)
	ipid->type = SCAMPER_DEALIAS_IPID_ZERO;
      else
	ipid->type = SCAMPER_DEALIAS_IPID_CONST;
    }
  else if(echo != 0)
    {
      ipid->type = SCAMPER_DEALIAS_IPID_ECHO;
    }

  return 0;
}
Ejemplo n.º 11
0
int savebmp(char *filename, unsigned char *buf, int w, int h,
	enum BMPPIXELFORMAT f, int srcpitch, int srcbottomup)
{
	int fd=-1, byteswritten, dstpitch, retcode=0;
	int flags=O_RDWR|O_CREAT|O_TRUNC;
	unsigned char *tempbuf=NULL;  char *temp;
	bmphdr bh;  int mode;

	#ifdef _WIN32
	flags|=O_BINARY;  mode=_S_IREAD|_S_IWRITE;
	#else
	mode=S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH;
	#endif
	if(!filename || !buf || w<1 || h<1 || f<0 || f>BMPPIXELFORMATS-1 || srcpitch<0)
		_throw("bad argument to savebmp()");

	if(srcpitch==0) srcpitch=w*ps[f];

	if((temp=strrchr(filename, '.'))!=NULL)
	{
		if(!stricmp(temp, ".ppm"))
			return saveppm(filename, buf, w, h, f, srcpitch, srcbottomup);
	}

	_unix(fd=open(filename, flags, mode));
	dstpitch=((w*3)+3)&(~3);

	bh.bfType=0x4d42;
	bh.bfSize=BMPHDRSIZE+dstpitch*h;
	bh.bfReserved1=0;  bh.bfReserved2=0;
	bh.bfOffBits=BMPHDRSIZE;
	bh.biSize=40;
	bh.biWidth=w;  bh.biHeight=h;
	bh.biPlanes=0;  bh.biBitCount=24;
	bh.biCompression=BI_RGB;  bh.biSizeImage=0;
	bh.biXPelsPerMeter=0;  bh.biYPelsPerMeter=0;
	bh.biClrUsed=0;  bh.biClrImportant=0;

	if(!littleendian())
	{
		bh.bfType=byteswap16(bh.bfType);
		bh.bfSize=byteswap(bh.bfSize);
		bh.bfOffBits=byteswap(bh.bfOffBits);
		bh.biSize=byteswap(bh.biSize);
		bh.biWidth=byteswap(bh.biWidth);
		bh.biHeight=byteswap(bh.biHeight);
		bh.biPlanes=byteswap16(bh.biPlanes);
		bh.biBitCount=byteswap16(bh.biBitCount);
		bh.biCompression=byteswap(bh.biCompression);
		bh.biSizeImage=byteswap(bh.biSizeImage);
		bh.biXPelsPerMeter=byteswap(bh.biXPelsPerMeter);
		bh.biYPelsPerMeter=byteswap(bh.biYPelsPerMeter);
		bh.biClrUsed=byteswap(bh.biClrUsed);
		bh.biClrImportant=byteswap(bh.biClrImportant);
	}

	writeme(fd, &bh.bfType, sizeof(unsigned short));
	writeme(fd, &bh.bfSize, sizeof(unsigned int));
	writeme(fd, &bh.bfReserved1, sizeof(unsigned short));
	writeme(fd, &bh.bfReserved2, sizeof(unsigned short));
	writeme(fd, &bh.bfOffBits, sizeof(unsigned int));
	writeme(fd, &bh.biSize, sizeof(unsigned int));
	writeme(fd, &bh.biWidth, sizeof(int));
	writeme(fd, &bh.biHeight, sizeof(int));
	writeme(fd, &bh.biPlanes, sizeof(unsigned short));
	writeme(fd, &bh.biBitCount, sizeof(unsigned short));
	writeme(fd, &bh.biCompression, sizeof(unsigned int));
	writeme(fd, &bh.biSizeImage, sizeof(unsigned int));
	writeme(fd, &bh.biXPelsPerMeter, sizeof(int));
	writeme(fd, &bh.biYPelsPerMeter, sizeof(int));
	writeme(fd, &bh.biClrUsed, sizeof(unsigned int));
	writeme(fd, &bh.biClrImportant, sizeof(unsigned int));

	if((tempbuf=(unsigned char *)malloc(dstpitch*h))==NULL)
		_throw("Memory allocation error");

	pixelconvert(buf, f, srcpitch, tempbuf, BMP_BGR, dstpitch, w, h, 
		!srcbottomup);

	if((byteswritten=write(fd, tempbuf, dstpitch*h))!=dstpitch*h)
		_throw(strerror(errno));

	finally:
	if(tempbuf) free(tempbuf);
	if(fd!=-1) close(fd);
	return retcode;
}
Ejemplo n.º 12
0
int loadbmp(char *filename, unsigned char **buf, int *w, int *h, 
	enum BMPPIXELFORMAT f, int align, int dstbottomup)
{
	int fd=-1, bytesread, srcpitch, srcbottomup=1, srcps, dstpitch,
		retcode=0;
	unsigned char *tempbuf=NULL;
	bmphdr bh;  int flags=O_RDONLY;

	dstbottomup=dstbottomup? 1:0;
	#ifdef _WIN32
	flags|=O_BINARY;
	#endif
	if(!filename || !buf || !w || !h || f<0 || f>BMPPIXELFORMATS-1 || align<1)
		_throw("invalid argument to loadbmp()");
	if((align&(align-1))!=0)
		_throw("Alignment must be a power of 2");
	_unix(fd=open(filename, flags));

	readme(fd, &bh.bfType, sizeof(unsigned short));
	if(!littleendian())	bh.bfType=byteswap16(bh.bfType);

	if(bh.bfType==0x3650)
	{
		_catch(loadppm(&fd, buf, w, h, f, align, dstbottomup, 0));
		goto finally;
	}
	if(bh.bfType==0x3350)
	{
		_catch(loadppm(&fd, buf, w, h, f, align, dstbottomup, 1));
		goto finally;
	}

	readme(fd, &bh.bfSize, sizeof(unsigned int));
	readme(fd, &bh.bfReserved1, sizeof(unsigned short));
	readme(fd, &bh.bfReserved2, sizeof(unsigned short));
	readme(fd, &bh.bfOffBits, sizeof(unsigned int));
	readme(fd, &bh.biSize, sizeof(unsigned int));
	readme(fd, &bh.biWidth, sizeof(int));
	readme(fd, &bh.biHeight, sizeof(int));
	readme(fd, &bh.biPlanes, sizeof(unsigned short));
	readme(fd, &bh.biBitCount, sizeof(unsigned short));
	readme(fd, &bh.biCompression, sizeof(unsigned int));
	readme(fd, &bh.biSizeImage, sizeof(unsigned int));
	readme(fd, &bh.biXPelsPerMeter, sizeof(int));
	readme(fd, &bh.biYPelsPerMeter, sizeof(int));
	readme(fd, &bh.biClrUsed, sizeof(unsigned int));
	readme(fd, &bh.biClrImportant, sizeof(unsigned int));

	if(!littleendian())
	{
		bh.bfSize=byteswap(bh.bfSize);
		bh.bfOffBits=byteswap(bh.bfOffBits);
		bh.biSize=byteswap(bh.biSize);
		bh.biWidth=byteswap(bh.biWidth);
		bh.biHeight=byteswap(bh.biHeight);
		bh.biPlanes=byteswap16(bh.biPlanes);
		bh.biBitCount=byteswap16(bh.biBitCount);
		bh.biCompression=byteswap(bh.biCompression);
		bh.biSizeImage=byteswap(bh.biSizeImage);
		bh.biXPelsPerMeter=byteswap(bh.biXPelsPerMeter);
		bh.biYPelsPerMeter=byteswap(bh.biYPelsPerMeter);
		bh.biClrUsed=byteswap(bh.biClrUsed);
		bh.biClrImportant=byteswap(bh.biClrImportant);
	}

	if(bh.bfType!=0x4d42 || bh.bfOffBits<BMPHDRSIZE
	|| bh.biWidth<1 || bh.biHeight==0)
		_throw("Corrupt bitmap header");
	if((bh.biBitCount!=24 && bh.biBitCount!=32) || bh.biCompression!=BI_RGB)
		_throw("Only uncompessed RGB bitmaps are supported");

	*w=bh.biWidth;  *h=bh.biHeight;  srcps=bh.biBitCount/8;
	if(*h<0) {*h=-(*h);  srcbottomup=0;}
	srcpitch=(((*w)*srcps)+3)&(~3);
	dstpitch=(((*w)*ps[f])+(align-1))&(~(align-1));

	if(srcpitch*(*h)+bh.bfOffBits!=bh.bfSize) _throw("Corrupt bitmap header");
	if((tempbuf=(unsigned char *)malloc(srcpitch*(*h)))==NULL
	|| (*buf=(unsigned char *)malloc(dstpitch*(*h)))==NULL)
		_throw("Memory allocation error");
	if(lseek(fd, (long)bh.bfOffBits, SEEK_SET)!=(long)bh.bfOffBits)
		_throw(strerror(errno));
	_unix(bytesread=read(fd, tempbuf, srcpitch*(*h)));
	if(bytesread!=srcpitch*(*h)) _throw("Read error");

	pixelconvert(tempbuf, BMP_BGR, srcpitch, *buf, f, dstpitch, *w, *h, 
		srcbottomup!=dstbottomup);

	finally:
	if(tempbuf) free(tempbuf);
	if(fd!=-1) close(fd);
	return retcode;
}
Ejemplo n.º 13
0
 static uint16_t _swap16(uint16_t x)
 {
     return byteswap16(x);
 }