void block_dns_ipbyhost(char *host)
{
struct in_addr inaddr;
Context;
/* Check if someone passed us an IP address as hostname
* and return it straight away */
if (egg_inet_aton(host, &inaddr)) {
call_ipbyhost(host, my_ntohl(inaddr.s_addr), 1);
return;
}
if (!setjmp(alarmret)) {
struct hostent *hp;
struct in_addr *in;
IP ip = 0;
alarm(resolve_timeout);
hp = gethostbyname(host);
alarm(0);
if (hp) {
in = (struct in_addr *) (hp->h_addr_list[0]);
ip = (IP) (in->s_addr);
call_ipbyhost(host, my_ntohl(ip), 1);
return;
}
/* Fall through. */
}
call_ipbyhost(host, 0, 0);
Context;
}
/*
* Implementation notes: readBinaryFile
* ------------------------------------
* The binary lexicon file format must follow this pattern:
* DAWG:<startnode index>:<num bytes>:<num bytes block of edge data>
*/
void DawgLexicon::readBinaryFile(std::istream& input) {
long startIndex, numBytes;
char firstFour[4], expected[] = "DAWG";
if (input.fail()) {
error("DawgLexicon::addWordsFromFile: Couldn't read input");
}
input.read(firstFour, 4);
input.get();
input >> startIndex;
input.get();
input >> numBytes;
input.get();
if (input.fail() || strncmp(firstFour, expected, 4) != 0
|| startIndex < 0 || numBytes < 0) {
error("DawgLexicon::addWordsFromFile: Improperly formed lexicon file");
}
numEdges = numBytes / sizeof(Edge);
edges = new Edge[numEdges];
start = &edges[startIndex];
input.read((char*) edges, numBytes);
if (input.fail() && !input.eof()) {
error("DawgLexicon::addWordsFromFile: Improperly formed lexicon file");
}
#if defined(BYTE_ORDER) && BYTE_ORDER == LITTLE_ENDIAN
uint32_t *cur = (uint32_t *) edges;
for (int i = 0; i < numEdges; i++, cur++) {
*cur = my_ntohl(*cur);
}
#endif
numDawgWords = countDawgWords(start);
}
bool CxImageSKA::Decode(CxFile *hFile)
{
if (hFile==NULL)
return false;
// read the header
SKAHEADER ska_header;
hFile->Read(&ska_header,sizeof(SKAHEADER),1);
ska_header.Width = my_ntohs(ska_header.Width);
ska_header.Height = my_ntohs(ska_header.Height);
ska_header.dwUnknown = my_ntohl(ska_header.dwUnknown);
// check header
if (ska_header.dwUnknown != 0x01000000 ||
ska_header.Width > 0x7FFF || ska_header.Height > 0x7FFF ||
ska_header.BppExp != 3)
return false;
if (info.nEscape == -1){
head.biWidth = ska_header.Width ;
head.biHeight= ska_header.Height;
info.dwType = CXIMAGE_FORMAT_SKA;
return true;
}
int bpp = 1<<ska_header.BppExp;
Create(ska_header.Width,ska_header.Height,bpp,CXIMAGE_FORMAT_SKA);
if (!IsValid())
return false;
// read the palette
int nColors = 1<<bpp;
rgb_color* ppal = (rgb_color*)malloc(nColors*sizeof(rgb_color));
if (!ppal) return false;
hFile->Read(ppal,nColors*sizeof(rgb_color),1);
SetPalette(ppal,nColors);
free(ppal);
//read the image
hFile->Read(GetBits(),ska_header.Width*ska_header.Height,1);
//reorder rows
if (GetEffWidth() != ska_header.Width){
BYTE *src,*dst;
src = GetBits() + ska_header.Width*(ska_header.Height-1);
dst = GetBits(ska_header.Height-1);
for(int y=0;y<ska_header.Height;y++){
memcpy(dst,src,ska_header.Width);
src -= ska_header.Width;
dst -= GetEffWidth();
}
}
Flip();
return true;
}
/*
* Read the |index|'th entry out of the current book into |entry|. Note that
* the files are always big-endian, so we need to byte swap on little-endian
* platforms.
*/
void read_book_entry(int index, book_entry_t* entry)
{
fseek(book, index * 16, SEEK_SET);
fread(entry, 16, 1, book);
entry->key = my_ntohll(entry->key);
entry->move = my_ntohs(entry->move);
entry->weight = my_ntohs(entry->weight);
entry->learn = my_ntohl(entry->learn);
}
bool CxImageSKA::Encode(CxFile * hFile)
{
if (EncodeSafeCheck(hFile)) return false;
if(head.biBitCount > 8) {
strcpy(info.szLastError,"SKA Images must be 8 bit or less");
return false;
}
SKAHEADER ska_header;
ska_header.Width = (unsigned short)GetWidth();
ska_header.Height = (unsigned short)GetHeight();
ska_header.BppExp = 3;
ska_header.dwUnknown = 0x01000000;
ska_header.Width = my_ntohs(ska_header.Width);
ska_header.Height = my_ntohs(ska_header.Height);
ska_header.dwUnknown = my_ntohl(ska_header.dwUnknown);
hFile->Write(&ska_header,sizeof(SKAHEADER),1);
ska_header.Width = my_ntohs(ska_header.Width);
ska_header.Height = my_ntohs(ska_header.Height);
ska_header.dwUnknown = my_ntohl(ska_header.dwUnknown);
if (head.biBitCount<8) IncreaseBpp(8);
rgb_color pal[256];
for(int idx=0; idx<256; idx++){
GetPaletteColor(idx,&(pal[idx].r),&(pal[idx].g),&(pal[idx].b));
}
hFile->Write(pal,256*sizeof(rgb_color),1);
BYTE* src = GetBits(ska_header.Height-1);
for(int y=0;y<ska_header.Height;y++){
hFile->Write(src,ska_header.Width,1);
src -= GetEffWidth();
}
return true;
}
int trace_get_item(struct trace_item *item)
{
int n_items;
if (trace_buf_ptr == trace_buf_end) { /* if no more unprocessed items in the trace buffer, get new data */
n_items = fread(trace_buf, sizeof(struct trace_item), TRACE_BUFSIZE, trace_fd);
if (!n_items) return 0; /* if no more items in the file, we are done */
trace_buf_ptr = 0;
trace_buf_end = n_items; /* n_items were read and placed in trace buffer */
}
struct trace_item* temp = &trace_buf[trace_buf_ptr]; /* read a new trace item for processing */
*item = *temp;
trace_buf_ptr++;
if (is_big_endian()) {
item->PC = my_ntohl(temp->PC);
item->Addr = my_ntohl(temp->Addr);
}
return 1;
}
/*
* Implementation notes: readBinaryFile
* ------------------------------------
* The binary lexicon file format must follow this pattern:
* DAWG:<startnode index>:<num bytes>:<num bytes block of edge data>
*/
void DawgLexicon::readBinaryFile(const std::string& filename) {
long startIndex, numBytes;
char firstFour[4], expected[] = "DAWG";
#ifdef _foreachpatch_h
std::ifstream istr(filename.c_str(), __IOS_IN__ | __IOS_BINARY__);
#else
std::ifstream istr(filename.c_str(), std::ios::in | std::ios::binary);
#endif // _foreachpatch_h
if (istr.fail()) {
error("DawgLexicon::addWordsFromFile: Couldn't open lexicon file " + filename);
}
istr.read(firstFour, 4);
istr.get();
istr >> startIndex;
istr.get();
istr >> numBytes;
istr.get();
if (istr.fail() || strncmp(firstFour, expected, 4) != 0
|| startIndex < 0 || numBytes < 0) {
error("DawgLexicon::addWordsFromFile: Improperly formed lexicon file " + filename);
}
numEdges = numBytes / sizeof(Edge);
edges = new Edge[numEdges];
start = &edges[startIndex];
istr.read((char*) edges, numBytes);
if (istr.fail() && !istr.eof()) {
error("DawgLexicon::addWordsFromFile: Improperly formed lexicon file " + filename);
}
#if defined(BYTE_ORDER) && BYTE_ORDER == LITTLE_ENDIAN
uint32_t *cur = (uint32_t *) edges;
for (int i = 0; i < numEdges; i++, cur++) {
*cur = my_ntohl(*cur);
}
#endif
istr.close();
numDawgWords = countDawgWords(start);
}
bool CxImageICO::Decode(CxFile *hFile)
{
if (hFile==NULL) return false;
DWORD off = hFile->Tell(); //<yuandi>
int page=info.nFrame; //internal icon structure indexes
// read the first part of the header
ICONHEADER icon_header;
hFile->Read(&icon_header,sizeof(ICONHEADER),1);
icon_header.idType = my_ntohs(icon_header.idType);
icon_header.idCount = my_ntohs(icon_header.idCount);
// check if it's an icon or a cursor
if ((icon_header.idReserved == 0) && ((icon_header.idType == 1)||(icon_header.idType == 2))) {
info.nNumFrames = icon_header.idCount;
// load the icon descriptions
ICONDIRENTRY *icon_list = (ICONDIRENTRY *)malloc(icon_header.idCount * sizeof(ICONDIRENTRY));
int c;
for (c = 0; c < icon_header.idCount; c++) {
hFile->Read(icon_list + c, sizeof(ICONDIRENTRY), 1);
icon_list[c].wPlanes = my_ntohs(icon_list[c].wPlanes);
icon_list[c].wBitCount = my_ntohs(icon_list[c].wBitCount);
icon_list[c].dwBytesInRes = my_ntohl(icon_list[c].dwBytesInRes);
icon_list[c].dwImageOffset = my_ntohl(icon_list[c].dwImageOffset);
}
if ((page>=0)&&(page<icon_header.idCount)){
if (info.nEscape == -1) {
// Return output dimensions only
head.biWidth = icon_list[page].bWidth;
head.biHeight = icon_list[page].bHeight;
#if CXIMAGE_SUPPORT_PNG
if (head.biWidth==0 && head.biHeight==0)
{ // Vista icon support
hFile->Seek(off + icon_list[page].dwImageOffset, SEEK_SET);
CxImage png;
png.SetEscape(-1);
if (png.Decode(hFile,CXIMAGE_FORMAT_PNG)){
Transfer(png);
info.nNumFrames = icon_header.idCount;
}
}
#endif //CXIMAGE_SUPPORT_PNG
free(icon_list);
info.dwType = CXIMAGE_FORMAT_ICO;
return true;
}
// get the bit count for the colors in the icon <CoreyRLucier>
BITMAPINFOHEADER bih;
hFile->Seek(off + icon_list[page].dwImageOffset, SEEK_SET);
if (icon_list[page].bWidth==0 && icon_list[page].bHeight==0)
{ // Vista icon support
#if CXIMAGE_SUPPORT_PNG
CxImage png;
if (png.Decode(hFile,CXIMAGE_FORMAT_PNG)){
Transfer(png);
info.nNumFrames = icon_header.idCount;
}
SetType(CXIMAGE_FORMAT_ICO);
#endif //CXIMAGE_SUPPORT_PNG
}
else
{ // standard icon
hFile->Read(&bih,sizeof(BITMAPINFOHEADER),1);
bihtoh(&bih);
c = bih.biBitCount;
// allocate memory for one icon
Create(icon_list[page].bWidth,icon_list[page].bHeight, c, CXIMAGE_FORMAT_ICO); //image creation
// read the palette
RGBQUAD pal[256];
if (bih.biClrUsed)
hFile->Read(pal,bih.biClrUsed*sizeof(RGBQUAD), 1);
else
hFile->Read(pal,head.biClrUsed*sizeof(RGBQUAD), 1);
SetPalette(pal,head.biClrUsed); //palette assign
//read the icon
if (c<=24){
hFile->Read(info.pImage, head.biSizeImage, 1);
} else { // 32 bit icon
BYTE* buf=(BYTE*)malloc(4*head.biHeight*head.biWidth);
BYTE* src = buf;
hFile->Read(buf, 4*head.biHeight*head.biWidth, 1);
#if CXIMAGE_SUPPORT_ALPHA
if (!AlphaIsValid()) AlphaCreate();
#endif //CXIMAGE_SUPPORT_ALPHA
for (long y = 0; y < head.biHeight; y++) {
BYTE* dst = GetBits(y);
for(long x=0;x<head.biWidth;x++){
*dst++=src[0];
*dst++=src[1];
*dst++=src[2];
#if CXIMAGE_SUPPORT_ALPHA
AlphaSet(x,y,src[3]);
#endif //CXIMAGE_SUPPORT_ALPHA
src+=4;
}
}
free(buf);
}
// apply the AND and XOR masks
int maskwdt = ((head.biWidth+31) / 32) * 4; //line width of AND mask (always 1 Bpp)
int masksize = head.biHeight * maskwdt; //size of mask
BYTE *mask = (BYTE *)malloc(masksize);
if (hFile->Read(mask, masksize, 1)){
bool bGoodMask=false;
for (int im=0;im<masksize;im++){
if (mask[im]!=255){
bGoodMask=true;
break;
}
}
if (bGoodMask && c != 32){
#if CXIMAGE_SUPPORT_ALPHA
bool bNeedAlpha = false;
if (!AlphaIsValid()){
AlphaCreate();
} else {
bNeedAlpha=true; //32bit icon
}
int x,y;
for (y = 0; y < head.biHeight; y++) {
for (x = 0; x < head.biWidth; x++) {
if (((mask[y*maskwdt+(x>>3)]>>(7-x%8))&0x01)){
AlphaSet(x,y,0);
bNeedAlpha=true;
}
}
}
if (!bNeedAlpha) AlphaDelete();
#endif //CXIMAGE_SUPPORT_ALPHA
//check if there is only one transparent color
RGBQUAD cc,ct;
long* pcc = (long*)&cc;
long* pct = (long*)&ct;
int nTransColors=0;
int nTransIndex=0;
for (y = 0; y < head.biHeight; y++){
for (x = 0; x < head.biWidth; x++){
if (((mask[y*maskwdt+(x>>3)] >> (7-x%8)) & 0x01)){
cc = GetPixelColor(x,y,false);
if (nTransColors==0){
nTransIndex = GetPixelIndex(x,y);
nTransColors++;
ct = cc;
} else {
if (*pct!=*pcc){
nTransColors++;
}
}
}
}
}
if (nTransColors==1){
SetTransColor(ct);
SetTransIndex(nTransIndex);
#if CXIMAGE_SUPPORT_ALPHA
AlphaDelete(); //because we have a unique transparent color in the image
#endif //CXIMAGE_SUPPORT_ALPHA
}
// <vho> - Transparency support w/o Alpha support
if (c <= 8){ // only for icons with less than 256 colors (XP icons need alpha).
// find a color index, which is not used in the image
// it is almost sure to find one, bcs. nobody uses all possible colors for an icon
BYTE colorsUsed[256];
memset(colorsUsed, 0, sizeof(colorsUsed));
for (y = 0; y < head.biHeight; y++){
for (x = 0; x < head.biWidth; x++){
colorsUsed[BlindGetPixelIndex(x,y)] = 1;
}
}
int iTransIdx = -1;
for (x = (int)(head.biClrUsed-1); x>=0 ; x--){
if (colorsUsed[x] == 0){
iTransIdx = x; // this one is not in use. we may use it as transparent color
break;
}
}
// Go thru image and set unused color as transparent index if needed
if (iTransIdx >= 0){
bool bNeedTrans = false;
for (y = 0; y < head.biHeight; y++){
for (x = 0; x < head.biWidth; x++){
// AND mask (Each Byte represents 8 Pixels)
if (((mask[y*maskwdt+(x>>3)] >> (7-x%8)) & 0x01)){
// AND mask is set (!=0). This is a transparent part
SetPixelIndex(x, y, (BYTE)iTransIdx);
bNeedTrans = true;
}
}
}
// set transparent index if needed
if (bNeedTrans) SetTransIndex(iTransIdx);
#if CXIMAGE_SUPPORT_ALPHA
AlphaDelete(); //because we have a transparent color in the palette
#endif //CXIMAGE_SUPPORT_ALPHA
}
}
} else if(c != 32){
void set_dev_info(struct rmi * rmi, DEV_INFO_S * pdev) {
printf("dev_ip: 0x%08x %s\n", pdev->dev_ip, net_to_ip(my_ntohl(pdev->dev_ip)));
return;
}
