int tr_general(uint8_t *src_data, uint16_t* offset, uint16_t* length, uint8_t* buffer, struct ipfix_lnf_map* item_info) { switch(*length) { case 1: readui8(buffer) = readui8(src_data + *offset); break; case 2: readui16(buffer) = ntohs(readui16(src_data + *offset)); break; case 4: readui32(buffer) = ntohl(readui32(src_data + *offset)); break; case 8: readui64(buffer) = be64toh(readui64(src_data + *offset)); break; case VAR_IE_LENGTH: *length = real_length(src_data, offset, *length); default: //Assume data type to be octetArray -> no endian conversion memcpy(buffer, src_data + *offset, *length); } if(/*length check comes here*/0){ //invalid length return 1; } return 0; }
static int ZIP_isArchive(const char *filename, int forWriting) { PHYSFS_uint32 sig; int retval = 0; void *in; in = __PHYSFS_platformOpenRead(filename); BAIL_IF_MACRO(in == NULL, NULL, 0); /* * The first thing in a zip file might be the signature of the * first local file record, so it makes for a quick determination. */ if (readui32(in, &sig)) { retval = (sig == ZIP_LOCAL_FILE_SIG); if (!retval) { /* * No sig...might be a ZIP with data at the start * (a self-extracting executable, etc), so we'll have to do * it the hard way... */ retval = (zip_find_end_of_central_dir(in, NULL) != -1); } /* if */ } /* if */ __PHYSFS_platformClose(in); return(retval); } /* ZIP_isArchive */
int tr_datetime(uint8_t *src_data, uint16_t* offset, uint16_t *length, uint8_t* buffer, struct ipfix_lnf_map* item_info) { //lnf requires timestamp in milliseconds uint16_t ie = item_info->ie; switch(ie) { //FlowEnd/StartSysUpTime case 21: case 22: readui64(buffer) = ntohl(readui32(src_data + *offset)); break; //iana ipfix flowStart/EndSeconds case 150: case 151: readui64(buffer) = be64toh(readui64(src_data + *offset))*1000; break; //flowStart/EndMilliseconds case 152: case 153: readui64(buffer) = be64toh(readui64(src_data + *offset)); break; //flowStart/EndMicroseconds case 154: case 155: readui64(buffer) = be64toh(readui64(src_data + *offset))/1000; break; //flowStart/EndNanoseconds case 156: case 157: readui64(buffer) = be64toh(readui64(src_data + *offset))/1000000; break; default: return 1; } return 0; }
int tr_address(uint8_t *src_data, uint16_t* offset, uint16_t *length, uint8_t* buffer, struct ipfix_lnf_map* item_info) { switch(*length) { case 4: memset(buffer, 0x0, sizeof(lnf_ip_t)); ((lnf_ip_t*)buffer)->data[3] = readui32(src_data + *offset); break; case 16: memcpy(buffer, src_data + *offset, 16); break; default: return 1; } return 0; }
// !!! FIXME: this is sort of a big, ugly function. const MOJOSHADER_effect *MOJOSHADER_parseEffect(const char *profile, const unsigned char *buf, const unsigned int _len, const MOJOSHADER_swizzle *swiz, const unsigned int swizcount, const MOJOSHADER_samplerMap *smap, const unsigned int smapcount, MOJOSHADER_malloc m, MOJOSHADER_free f, void *d) { if ( ((m == NULL) && (f != NULL)) || ((m != NULL) && (f == NULL)) ) return &MOJOSHADER_out_of_mem_effect; // supply both or neither. if (m == NULL) m = MOJOSHADER_internal_malloc; if (f == NULL) f = MOJOSHADER_internal_free; MOJOSHADER_effect *retval = (MOJOSHADER_effect*)m(sizeof (MOJOSHADER_effect), d); if (retval == NULL) return &MOJOSHADER_out_of_mem_effect; // supply both or neither. memset(retval, '\0', sizeof (*retval)); retval->malloc = m; retval->free = f; retval->malloc_data = d; const uint8 *ptr = (const uint8 *) buf; uint32 len = (uint32) _len; size_t siz = 0; int i, j, k; if (len < 8) goto parseEffect_unexpectedEOF; const uint8 *base = NULL; if (readui32(&ptr, &len) != 0xFEFF0901) // !!! FIXME: is this always magic? goto parseEffect_notAnEffectsFile; else { const uint32 offset = readui32(&ptr, &len); base = ptr; //printf("base offset == %u\n", offset); if (offset > len) goto parseEffect_unexpectedEOF; ptr += offset; len -= offset; } // else // params... if (len < 16) goto parseEffect_unexpectedEOF; const uint32 numparams = readui32(&ptr, &len); const uint32 numtechniques = readui32(&ptr, &len); readui32(&ptr, &len); // !!! FIXME: there are 8 unknown bytes here. Annotations? /*const uint32 numobjects = */ readui32(&ptr, &len); if (numparams > 0) { siz = sizeof (MOJOSHADER_effectParam) * numparams; retval->params = (MOJOSHADER_effectParam *) m(siz, d); if (retval->params == NULL) goto parseEffect_outOfMemory; memset(retval->params, '\0', siz); retval->param_count = numparams; for (i = 0; i < numparams; i++) { if (len < 16) goto parseEffect_unexpectedEOF; const uint32 typeoffset = readui32(&ptr, &len); /*const uint32 valoffset =*/ readui32(&ptr, &len); /*const uint32 flags =*/ readui32(&ptr, &len); const uint32 numannos = readui32(&ptr, &len); for (j = 0; j < numannos; j++) { if (len < 8) goto parseEffect_unexpectedEOF; // !!! FIXME: parse annotations. readui32(&ptr, &len); readui32(&ptr, &len); } // for const uint8 *typeptr = base + typeoffset; unsigned int typelen = 9999999; // !!! FIXME /*const uint32 paramtype =*/ readui32(&typeptr, &typelen); /*const uint32 paramclass =*/ readui32(&typeptr, &typelen); const uint32 paramname = readui32(&typeptr, &typelen); const uint32 paramsemantic = readui32(&typeptr, &typelen); // !!! FIXME: sanity checks! const char *namestr = ((const char *) base) + paramname; const char *semstr = ((const char *) base) + paramsemantic; uint32 len; char *strptr; len = *((const uint32 *) namestr); strptr = (char *) m(len + 1, d); memcpy(strptr, namestr + 4, len); strptr[len] = '\0'; retval->params[i].name = strptr; len = *((const uint32 *) semstr); strptr = (char *) m(len + 1, d); memcpy(strptr, semstr + 4, len); strptr[len] = '\0'; retval->params[i].semantic = strptr; } // for } // if uint32 numshaders = 0; // we'll calculate this later. // techniques... if (numtechniques > 0) { siz = sizeof (MOJOSHADER_effectTechnique) * numtechniques; retval->techniques = (MOJOSHADER_effectTechnique *) m(siz, d); if (retval->techniques == NULL) goto parseEffect_outOfMemory; memset(retval->techniques, '\0', siz); retval->technique_count = numtechniques; for (i = 0; i < numtechniques; i++) { if (len < 12) goto parseEffect_unexpectedEOF; MOJOSHADER_effectTechnique *technique = &retval->techniques[i]; const uint32 nameoffset = readui32(&ptr, &len); const uint32 numannos = readui32(&ptr, &len); const uint32 numpasses = readui32(&ptr, &len); if (nameoffset >= _len) goto parseEffect_unexpectedEOF; if (numannos > 0) { // !!! FIXME: expose these to the caller? for (j = 0; j < numannos; j++) { if (len < 8) goto parseEffect_unexpectedEOF; readui32(&ptr, &len); // typedef offset readui32(&ptr, &len); // value offset } // for } // if // !!! FIXME: verify this doesn't go past EOF looking for a null. { const char *namestr = ((char *) base) + nameoffset; uint32 len = *((const uint32 *) namestr); char *strptr = (char *) m(len + 1, d); memcpy(strptr, namestr + 4, len); strptr[len] = '\0'; technique->name = strptr; } if (numpasses > 0) { technique->pass_count = numpasses; siz = sizeof (MOJOSHADER_effectPass) * numpasses; technique->passes = (MOJOSHADER_effectPass *) m(siz, d); if (technique->passes == NULL) goto parseEffect_outOfMemory; memset(technique->passes, '\0', siz); for (j = 0; j < numpasses; j++) { if (len < 12) goto parseEffect_unexpectedEOF; MOJOSHADER_effectPass *pass = &technique->passes[j]; const uint32 passnameoffset = readui32(&ptr, &len); const uint32 numannos = readui32(&ptr, &len); const uint32 numstates = readui32(&ptr, &len); if (passnameoffset >= _len) goto parseEffect_unexpectedEOF; // !!! FIXME: verify this doesn't go past EOF looking for a null. { const char *namestr = ((char *) base) + passnameoffset; uint32 len = *((const uint32 *) namestr); char *strptr = (char *) m(len + 1, d); memcpy(strptr, namestr + 4, len); strptr[len] = '\0'; pass->name = strptr; } if (numannos > 0) { for (k = 0; k < numannos; k++) { if (len < 8) goto parseEffect_unexpectedEOF; // !!! FIXME: do something with this. readui32(&ptr, &len); readui32(&ptr, &len); } // for } // if if (numstates > 0) { pass->state_count = numstates; siz = sizeof (MOJOSHADER_effectState) * numstates; pass->states = (MOJOSHADER_effectState *) m(siz, d); if (pass->states == NULL) goto parseEffect_outOfMemory; memset(pass->states, '\0', siz); for (k = 0; k < numstates; k++) { if (len < 16) goto parseEffect_unexpectedEOF; MOJOSHADER_effectState *state = &pass->states[k]; const uint32 type = readui32(&ptr, &len); readui32(&ptr, &len); // !!! FIXME: don't know what this field does. /*const uint32 offsetend = */ readui32(&ptr, &len); /*const uint32 offsetstart = */ readui32(&ptr, &len); state->type = type; if ((type == 0x92) || (type == 0x93)) numshaders++; } // for } // if } // for } // if } // for } // if // textures... if (len < 8) goto parseEffect_unexpectedEOF; const int numtextures = readui32(&ptr, &len); const int numobjects = readui32(&ptr, &len); // !!! FIXME: "objects" for lack of a better word. if (numtextures > 0) { siz = sizeof (MOJOSHADER_effectTexture) * numtextures; retval->textures = (MOJOSHADER_effectTexture*)m(siz, d); if (retval->textures == NULL) goto parseEffect_outOfMemory; memset(retval->textures, '\0', siz); for (i = 0; i < numtextures; i++) { if (len < 8) goto parseEffect_unexpectedEOF; MOJOSHADER_effectTexture *texture = &retval->textures[i]; const uint32 texparam = readui32(&ptr, &len); const uint32 texsize = readui32(&ptr, &len); // apparently texsize will pad out to 32 bits. const uint32 readsize = (((texsize + 3) / 4) * 4); if (len < readsize) goto parseEffect_unexpectedEOF; texture->param = texparam; char *str = (char*)m(texsize + 1, d); if (str == NULL) goto parseEffect_outOfMemory; memcpy(str, ptr, texsize); str[texsize] = '\0'; texture->name = str; ptr += readsize; len -= readsize; } // for } // if // shaders... if (numshaders > 0) { siz = sizeof (MOJOSHADER_effectShader) * numshaders; retval->shaders = (MOJOSHADER_effectShader *) m(siz, d); if (retval->shaders == NULL) goto parseEffect_outOfMemory; memset(retval->shaders, '\0', siz); retval->shader_count = numshaders; // !!! FIXME: I wonder if we should pull these from offsets and not // !!! FIXME: count on them all being in a line like this. for (i = 0; i < numshaders; i++) { if (len < 24) goto parseEffect_unexpectedEOF; MOJOSHADER_effectShader *shader = &retval->shaders[i]; const uint32 technique = readui32(&ptr, &len); const uint32 pass = readui32(&ptr, &len); readui32(&ptr, &len); // !!! FIXME: don't know what this does. readui32(&ptr, &len); // !!! FIXME: don't know what this does (vertex/pixel/geometry?) readui32(&ptr, &len); // !!! FIXME: don't know what this does. const uint32 shadersize = readui32(&ptr, &len); if (len < shadersize) goto parseEffect_unexpectedEOF; shader->technique = technique; shader->pass = pass; shader->shader = MOJOSHADER_parse(profile, ptr, shadersize, swiz, swizcount, smap, smapcount, m, f, d); // !!! FIXME: check for errors. ptr += shadersize; len -= shadersize; } // for } // if // !!! FIXME: we parse this, but don't expose the data, yet. // mappings ... assert(numshaders <= numobjects); const uint32 nummappings = numobjects - numshaders; if (nummappings > 0) { for (i = 0; i < nummappings; i++) { if (len < 24) goto parseEffect_unexpectedEOF; /*const uint32 magic = */ readui32(&ptr, &len); /*const uint32 index = */ readui32(&ptr, &len); readui32(&ptr, &len); // !!! FIXME: what is this field? readui32(&ptr, &len); // !!! FIXME: what is this field? /*const uint32 type = */ readui32(&ptr, &len); const uint32 mapsize = readui32(&ptr, &len); if (mapsize > 0) { const uint32 readsize = (((mapsize + 3) / 4) * 4); if (len < readsize) goto parseEffect_unexpectedEOF; } // if } // for } // if retval->profile = (char *) m(strlen(profile) + 1, d); if (retval->profile == NULL) goto parseEffect_outOfMemory; strcpy((char *) retval->profile, profile); return retval; // !!! FIXME: do something with this. parseEffect_notAnEffectsFile: parseEffect_unexpectedEOF: parseEffect_outOfMemory: MOJOSHADER_freeEffect(retval); return &MOJOSHADER_out_of_mem_effect; } // MOJOSHADER_parseEffect
// !!! FIXME: improve the crap out of this API later. int isDDS(const void *_ptr, const unsigned long _len) { size_t len = (size_t) _len; const uint8 *ptr = (const uint8 *) _ptr; return (readui32(ptr, len) == DDS_MAGIC); } // isDDS
static int parse_dds( DDSHeader &header, const uint8 *&ptr, size_t &len, unsigned int &_glfmt, unsigned int &_miplevels) { const uint32 pitchAndLinear = (DDSD_PITCH | DDSD_LINEARSIZE); uint32 width = 0; uint32 height = 0; uint32 calcSize = 0; uint32 calcSizeFlag = DDSD_LINEARSIZE; // Files start with magic value... if (readui32(ptr, len) != DDS_MAGIC) return 0; // not a DDS file. // Then comes the DDS header... if (len < DDS_HEADERSIZE) return 0; header.dwSize = readui32(ptr, len); header.dwFlags = readui32(ptr, len); header.dwHeight = readui32(ptr, len); header.dwWidth = readui32(ptr, len); header.dwPitchOrLinearSize = readui32(ptr, len); header.dwDepth = readui32(ptr, len); header.dwMipMapCount = readui32(ptr, len); for (unsigned int i = 0; i < STATICARRAYLEN(header.dwReserved1); i++) header.dwReserved1[i] = readui32(ptr, len); header.ddspf.dwSize = readui32(ptr, len); header.ddspf.dwFlags = readui32(ptr, len); header.ddspf.dwFourCC = readui32(ptr, len); header.ddspf.dwRGBBitCount = readui32(ptr, len); header.ddspf.dwRBitMask = readui32(ptr, len); header.ddspf.dwGBitMask = readui32(ptr, len); header.ddspf.dwBBitMask = readui32(ptr, len); header.ddspf.dwABitMask = readui32(ptr, len); header.dwCaps = readui32(ptr, len); header.dwCaps2 = readui32(ptr, len); header.dwCaps3 = readui32(ptr, len); header.dwCaps4 = readui32(ptr, len); header.dwReserved2 = readui32(ptr, len); width = header.dwWidth; height = header.dwHeight; header.dwCaps &= ~DDSCAPS_ALPHA; // we'll get this from the pixel format. if (header.dwSize != DDS_HEADERSIZE) // header size must be 124. return 0; else if (header.ddspf.dwSize != DDS_PIXFMTSIZE) // size must be 32. return 0; else if ((header.dwFlags & DDSD_REQ) != DDSD_REQ) // must have these bits. return 0; else if ((header.dwCaps & DDSCAPS_TEXTURE) == 0) return 0; else if (header.dwCaps2 != 0) // !!! FIXME (non-zero with other bits in dwCaps set) return 0; else if ((header.dwFlags & pitchAndLinear) == pitchAndLinear) return 0; // can't specify both. _miplevels = (header.dwCaps & DDSCAPS_MIPMAP) ? header.dwMipMapCount : 1; if (header.ddspf.dwFlags & DDPF_FOURCC) { switch (header.ddspf.dwFourCC) { case FOURCC_DXT1: _glfmt = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT; calcSize = ((width ? ((width + 3) / 4) : 1) * 8) * (height ? ((height + 3) / 4) : 1); break; case FOURCC_DXT3: _glfmt = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT; calcSize = ((width ? ((width + 3) / 4) : 1) * 16) * (height ? ((height + 3) / 4) : 1); break; case FOURCC_DXT5: _glfmt = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT; calcSize = ((width ? ((width + 3) / 4) : 1) * 16) * (height ? ((height + 3) / 4) : 1); break; // !!! FIXME: DX10 is an extended header, introduced by DirectX 10. //case FOURCC_DX10: do_something(); break; //case FOURCC_DXT2: // premultiplied alpha unsupported. //case FOURCC_DXT4: // premultiplied alpha unsupported. default: return 0; // unsupported data format. } // switch } // if // no FourCC...uncompressed data. else if (header.ddspf.dwFlags & DDPF_RGB) { if ( (header.ddspf.dwRBitMask != 0x00FF0000) || (header.ddspf.dwGBitMask != 0x0000FF00) || (header.ddspf.dwBBitMask != 0x000000FF) ) return 0; // !!! FIXME: deal with this. if (header.ddspf.dwFlags & DDPF_ALPHAPIXELS) { if ( (header.ddspf.dwRGBBitCount != 32) || (header.ddspf.dwABitMask != 0xFF000000) ) return 0; // unsupported. _glfmt = GL_BGRA; } // if else { if (header.ddspf.dwRGBBitCount != 24) return 0; // unsupported. _glfmt = GL_BGR; } // else calcSizeFlag = DDSD_PITCH; calcSize = ((width * header.ddspf.dwRGBBitCount) + 7) / 8; } // else if //else if (header.ddspf.dwFlags & DDPF_LUMINANCE) // !!! FIXME //else if (header.ddspf.dwFlags & DDPF_YUV) // !!! FIXME //else if (header.ddspf.dwFlags & DDPF_ALPHA) // !!! FIXME else { return 0; // unsupported data format. } // else if // no pitch or linear size? Calculate it. if ((header.dwFlags & pitchAndLinear) == 0) { if (!calcSizeFlag) { assert(0 && "should have caught this up above"); return 0; // uh oh. } // if header.dwPitchOrLinearSize = calcSize; header.dwFlags |= calcSizeFlag; } // if return 1; } // parse_dds