static Eina_File * check_bc(Eina_File *of, const char *fname, Eina_Bool *bc) { if (of) { struct stat bc_stat, sc_stat; /* original file doesn't exist, only bytecode does, use bytecode */ if (stat(fname, &sc_stat) < 0) return of; if (stat(eina_file_filename_get(of), &bc_stat) < 0) { /* what? */ eina_file_close(of); goto generate; } /* bytecode is newer than original file, use bytecode */ if (bc_stat.st_mtime > sc_stat.st_mtime) return of; /* bytecode is not new enough; trigger regeneration */ eina_file_close(of); } generate: *bc = EINA_TRUE; return eina_file_open(fname, EINA_FALSE); }
static Eina_Bool _etui_epub_mimetype_is_valid(Etui_Provider_Data *pd) { char buf[PATH_MAX]; Eina_File *f; void *data; snprintf(buf, sizeof(buf), "%s/%s", pd->doc.path, "mimetype"); buf[sizeof(buf) - 1] = '\0'; f = eina_file_open(buf, EINA_FALSE); if (!f) return EINA_FALSE; data = eina_file_map_all(f, EINA_FILE_POPULATE); if (!data) { eina_file_close(f); return EINA_FALSE; } if (strcmp(data, "application/epub+zip") != 0) { eina_file_close(f); return EINA_FALSE; } eina_file_close(f); return EINA_TRUE; }
static Eina_Bool _etui_epub_opf_is_valid(Etui_Provider_Data *pd) { char buf[PATH_MAX]; Eina_File *f; snprintf(buf, sizeof(buf), "%s/%s", pd->doc.path, pd->container.content_file); buf[sizeof(buf) - 1] = '\0'; f = eina_file_open(buf, EINA_FALSE); if (!f) return EINA_FALSE; if (!eina_simple_xml_parse((const char *)eina_file_map_all(f, EINA_FILE_POPULATE), eina_file_size_get(f), EINA_TRUE, _etui_epub_opf_parse_cb, pd)) { eina_file_close(f); return EINA_FALSE; } eina_file_close(f); return EINA_TRUE; }
void _evas_xcb_xdefaults_shutdown(void) { if (!_evas_xcb_xdefaults_file) return; if (_evas_xcb_xdefaults_data) eina_file_map_free(_evas_xcb_xdefaults_file, _evas_xcb_xdefaults_data); if (_evas_xcb_xdefaults_file) eina_file_close(_evas_xcb_xdefaults_file); }
static Eina_Bool _etui_epub_ncx_is_valid(Etui_Provider_Data *pd) { char buf[PATH_MAX]; Etui_Epub_Opf_Manifest_Item *item; Eina_File *f; char *oebps_dir; if (!pd->opf.toc_id) return EINA_FALSE; item = eina_hash_find(pd->opf.manifest, pd->opf.toc_id); if (!item) return EINA_FALSE; oebps_dir = strdup(pd->container.content_file); if (!oebps_dir) return EINA_FALSE; snprintf(buf, sizeof(buf), "%s/%s/%s", pd->doc.path, dirname(oebps_dir), item->href); buf[sizeof(buf) - 1] = '\0'; free(oebps_dir); f = eina_file_open(buf, EINA_FALSE); if (!f) { return EINA_FALSE; } pd->ncx.current_depth = -1; if (!eina_simple_xml_parse((const char *)eina_file_map_all(f, EINA_FILE_POPULATE), eina_file_size_get(f), EINA_TRUE, _etui_epub_ncx_parse_cb, pd)) { eina_file_close(f); return EINA_FALSE; } eina_file_close(f); return EINA_TRUE; }
Eina_Bool shotgun_emoticon_custom_add(Shotgun_Auth *auth, const char *file, const char *text, const char *type) { Shotgun_Custom_Emoticon *emo; char *data_base64, tmp_cid[63]; size_t len, len64; const char *sha1; Eina_File *fh; const unsigned char *data; EINA_SAFETY_ON_NULL_RETURN_VAL(auth, EINA_FALSE); EINA_SAFETY_ON_NULL_RETURN_VAL(file, EINA_FALSE); EINA_SAFETY_ON_NULL_RETURN_VAL(text, EINA_FALSE); EINA_SAFETY_ON_NULL_RETURN_VAL(type, EINA_FALSE); fh = eina_file_open(file, EINA_FALSE); if (!fh) { ERR("Couldnt open file %s", file); return EINA_FALSE; } len = eina_file_size_get(fh); data = (const unsigned char *)eina_file_map_all(fh, EINA_FILE_SEQUENTIAL); DBG("data[%p] len=%ld", data, len); DBG("data[1] = %c", data[1]); sha1 = sha1_buffer(data, len); data_base64 = shotgun_base64_encode(data, len, &len64); eina_file_map_free(fh, (void *)data); eina_file_close(fh); emo = calloc(1, sizeof(Shotgun_Custom_Emoticon)); if (!emo) return EINA_FALSE; emo->file = eina_stringshare_add(file); emo->text = strdup(text); emo->type = strdup(type); emo->data_base64 = data_base64; sprintf(tmp_cid, "cid:sha1+%[email protected]", sha1); emo->cid = strdup(tmp_cid); auth->custom_emoticons = eina_inlist_append(auth->custom_emoticons, EINA_INLIST_GET(emo)); return EINA_TRUE; }
static void read_watch_file(const char *file) { Eina_File *f; Eina_Iterator *it; Eina_File_Line *ln; Eio_Monitor *mon; Eina_List *r = NULL; f = eina_file_open(file, EINA_FALSE); if (!f) return ; it = eina_file_map_lines(f); if (!it) goto err; EINA_ITERATOR_FOREACH(it, ln) { const char *path; Eina_Bool do_append = EINA_TRUE; if (ln->length < 4) continue ; if (anotate) { path = eina_stringshare_add_length(ln->start + 3, ln->length - 3); fprintf(stdout, "%c: %s\n", *ln->start, path); if (*ln->start == 'O') do_append = EINA_FALSE; } else { path = eina_stringshare_add_length(ln->start, ln->length); } if (do_append) r = eina_list_append(r, eio_monitor_add(path)); eina_stringshare_del(path); } eina_iterator_free(it); EINA_LIST_FREE(watching, mon) eio_monitor_del(mon); watching = r; err: eina_file_close(f); }
static void _loaded_handle(Image_Entry *ie, const Msg_Loaded *msg) { Data_Entry *dentry = ie->data2; const char *shmpath; shmpath = ((const char *)msg) + sizeof(*msg); // dentry->shm.path = strdup(shmpath); dentry->shm.mmap_offset = msg->shm.mmap_offset; dentry->shm.use_offset = msg->shm.use_offset; dentry->shm.mmap_size = msg->shm.mmap_size; dentry->shm.image_size = msg->shm.image_size; dentry->shm.f = eina_file_open(shmpath, EINA_TRUE); if (!dentry->shm.f) { free(dentry); ie->data2 = NULL; return; } dentry->shm.data = eina_file_map_new(dentry->shm.f, EINA_FILE_WILLNEED, dentry->shm.mmap_offset, dentry->shm.mmap_size); if (!dentry->shm.data) { eina_file_close(dentry->shm.f); free(dentry); ie->data2 = NULL; } if (ie->data2) { RGBA_Image *im = (RGBA_Image *)ie; im->image.data = evas_cserve2_image_data_get(ie); ie->flags.alpha_sparse = msg->alpha_sparse; ie->flags.loaded = EINA_TRUE; im->image.no_free = 1; } }
/** * @internal * @param file The file to parse * @return Returns an Eina_Hash with the contents of @a file, or NULL if the * file fails to parse or if the file doesn't exist * @brief Parses the ini file @a file into an Eina_Hash */ static Eina_Hash * efreet_ini_parse(const char *file) { Eina_Hash *data = NULL, *section = NULL; Eina_Iterator *it = NULL; Eina_File_Line *line; Eina_File *f; EINA_SAFETY_ON_NULL_RETURN_VAL(file, NULL); f = eina_file_open(file, EINA_FALSE); if (!f) return NULL; data = eina_hash_string_small_new(EINA_FREE_CB(eina_hash_free)); if (!data) goto error; /* let's make mmap safe and just get 0 pages for IO erro */ eina_mmap_safety_enabled_set(EINA_TRUE); it = eina_file_map_lines(f); if (!it) goto error; EINA_ITERATOR_FOREACH(it, line) { const char *eq; unsigned int start = 0; /* skip empty lines */ if (line->length == 0) continue; /* skip white space at start of line */ while ((start < line->length) && (isspace((unsigned char)line->start[start]))) start++; /* skip empty lines */ if (start == line->length) continue; /* skip comments */ if (line->start[start] == '#') continue; /* new section */ if (line->start[start] == '[') { const char *head_start; const char *head_end; head_start = &(line->start[start]) + 1; head_end = memchr(line->start, ']', line->length); if (head_end) { char *header; size_t len; len = head_end - head_start + 1; header = alloca(len); memcpy(header, head_start, len - 1); header[len - 1] = '\0'; section = eina_hash_string_small_new(EINA_FREE_CB(eina_stringshare_del)); eina_hash_del_by_key(data, header); eina_hash_add(data, header, section); } else { /* invalid file - skip line? or refuse to parse file? */ /* just printf for now till we figure out what to do */ // ERR("Invalid file (%s) (missing ] on group name)", file); } continue; } if (!section) { INF("Invalid file (%s) (missing section)", file); goto error; } eq = memchr(line->start, '=', line->length); if (eq) { const char *key_start, *key_end; const char *value_start, *value_end; char *key, *value; size_t len; key_start = &(line->start[start]); key_end = eq - 1; /* trim whitespace from end of key */ while ((isspace((unsigned char)*key_end)) && (key_end > key_start)) key_end--; key_end++; /* make sure we have a key */ if (key_start == key_end) continue; value_start = eq + 1; value_end = line->end; /* line->end points to char after '\n' or '\r' */ value_end--; /* trim whitespace from end of value */ while ((isspace((unsigned char)*value_end)) && (value_end > value_start)) value_end--; value_end++; /* trim whitespace from start of value */ while ((isspace((unsigned char)*value_start)) && (value_start < value_end)) value_start++; len = key_end - key_start + 1; key = alloca(len); memcpy(key, key_start, len - 1); key[len - 1] = '\0'; /* empty value allowed */ if (value_end == value_start) { eina_hash_del_by_key(section, key); eina_hash_add(section, key, ""); } else { len = value_end - value_start + 1; value = alloca(len); memcpy(value, value_start, len - 1); value[len - 1] = '\0'; eina_hash_del_by_key(section, key); eina_hash_add(section, key, efreet_ini_unescape(value)); } } else { /* invalid file... */ INF("Invalid file (%s) (missing = from key=value pair)", file); goto error; } } eina_iterator_free(it); eina_file_close(f); #if 0 if (!eina_hash_population(data)) { eina_hash_free(data); return NULL; } #endif return data; error: if (data) eina_hash_free(data); if (it) eina_iterator_free(it); eina_file_close(f); return NULL; }
EAPI Eet_Key * eet_identity_open(const char *certificate_file, const char *private_key_file, Eet_Key_Password_Callback cb) { #ifdef HAVE_SIGNATURE /* Signature declarations */ Eet_Key *key = NULL; # ifdef HAVE_GNUTLS /* Gnutls private declarations */ Eina_File *f = NULL; void *data = NULL; gnutls_datum_t load_file = { NULL, 0 }; char pass[1024]; if (!emile_cipher_init()) return NULL; /* Init */ if (!(key = malloc(sizeof(Eet_Key)))) goto on_error; key->references = 1; if (gnutls_x509_crt_init(&(key->certificate))) goto on_error; if (gnutls_x509_privkey_init(&(key->private_key))) goto on_error; /* Mmap certificate_file */ f = eina_file_open(certificate_file, 0); if (!f) goto on_error; /* let's make mmap safe and just get 0 pages for IO erro */ eina_mmap_safety_enabled_set(EINA_TRUE); data = eina_file_map_all(f, EINA_FILE_SEQUENTIAL); if (!data) goto on_error; /* Import the certificate in Eet_Key structure */ load_file.data = data; load_file.size = eina_file_size_get(f); if (gnutls_x509_crt_import(key->certificate, &load_file, GNUTLS_X509_FMT_PEM) < 0) goto on_error; eina_file_map_free(f, data); /* Reset values */ eina_file_close(f); f = NULL; data = NULL; load_file.data = NULL; load_file.size = 0; /* Mmap private_key_file */ f = eina_file_open(private_key_file, 0); if (!f) goto on_error; /* let's make mmap safe and just get 0 pages for IO erro */ eina_mmap_safety_enabled_set(EINA_TRUE); data = eina_file_map_all(f, EINA_FILE_SEQUENTIAL); if (!data) goto on_error; /* Import the private key in Eet_Key structure */ load_file.data = data; load_file.size = eina_file_size_get(f); /* Try to directly import the PEM encoded private key */ if (gnutls_x509_privkey_import(key->private_key, &load_file, GNUTLS_X509_FMT_PEM) < 0) { /* Else ask for the private key pass */ if (cb && cb(pass, 1024, 0, NULL)) { /* If pass then try to decode the pkcs 8 private key */ if (gnutls_x509_privkey_import_pkcs8(key->private_key, &load_file, GNUTLS_X509_FMT_PEM, pass, 0)) goto on_error; } else /* Else try to import the pkcs 8 private key without pass */ if (gnutls_x509_privkey_import_pkcs8(key->private_key, &load_file, GNUTLS_X509_FMT_PEM, NULL, 1)) goto on_error; } eina_file_map_free(f, data); eina_file_close(f); return key; on_error: if (data) eina_file_map_free(f, data); if (f) eina_file_close(f); if (key) { if (key->certificate) gnutls_x509_crt_deinit(key->certificate); if (key->private_key) gnutls_x509_privkey_deinit(key->private_key); free(key); } # else /* ifdef HAVE_GNUTLS */ /* Openssl private declarations */ FILE *fp; EVP_PKEY *pkey = NULL; X509 *cert = NULL; if (!emile_cipher_init()) return NULL; /* Load the X509 certificate in memory. */ fp = fopen(certificate_file, "rb"); if (!fp) return NULL; cert = PEM_read_X509(fp, NULL, NULL, NULL); fclose(fp); if (!cert) goto on_error; /* Check the presence of the public key. Just in case. */ pkey = X509_get_pubkey(cert); if (!pkey) goto on_error; /* Load the private key in memory. */ fp = fopen(private_key_file, "rb"); if (!fp) goto on_error; pkey = PEM_read_PrivateKey(fp, NULL, cb, NULL); fclose(fp); if (!pkey) goto on_error; /* Load the certificate and the private key in Eet_Key structure */ key = malloc(sizeof(Eet_Key)); if (!key) goto on_error; key->references = 1; key->certificate = cert; key->private_key = pkey; return key; on_error: if (cert) X509_free(cert); if (pkey) EVP_PKEY_free(pkey); # endif /* ifdef HAVE_GNUTLS */ #else (void) certificate_file; (void) private_key_file; (void) cb; #endif /* ifdef HAVE_SIGNATURE */ return NULL; }
static Error_Type image_load(const char *file, const char *key, const char *shmfile, Slave_Msg_Image_Load *params, Slave_Msg_Image_Loaded *result, const char *loader) { Evas_Module *module; Eina_File *fd; Evas_Image_Load_Func *funcs = NULL; Evas_Image_Load_Opts *opts = ¶ms->opts; Evas_Image_Property property; Evas_Image_Animated animated; Error_Type ret = CSERVE2_GENERIC; void *loader_data = NULL; Eina_Bool ok; Eina_Stringshare *skey = NULL; int error; fd = eina_file_open(file, EINA_FALSE); if (!fd) { return CSERVE2_DOES_NOT_EXIST; // FIXME: maybe check errno } char *map = _cserve2_shm_map(shmfile, params->shm.mmap_size, params->shm.mmap_offset); if (map == MAP_FAILED) { eina_file_close(fd); return CSERVE2_RESOURCE_ALLOCATION_FAILED; } module = evas_module_find_type(EVAS_MODULE_TYPE_IMAGE_LOADER, loader); if (!module) { printf("LOAD failed at %s:%d: no module found for loader %s\n", __FUNCTION__, __LINE__, loader); goto done; } memset(&property, 0, sizeof (property)); property.w = params->w; property.h = params->h; skey = eina_stringshare_add(key); loader_data = _image_file_open(fd, skey, opts, module, &property, &animated, &funcs); if (!loader_data) { printf("LOAD failed at %s:%d: could not open image %s:%s\n", __FUNCTION__, __LINE__, file, skey); goto done; } ok = funcs->file_data(loader_data, &property, map, &error); if (!ok || (error != EVAS_LOAD_ERROR_NONE)) { printf("LOAD failed at %s:%d: file_data failed for loader %s: error %d\n", __FUNCTION__, __LINE__, loader, error); goto done; } result->w = property.w; result->h = property.h; if (property.alpha) { result->alpha_sparse = evas_cserve2_image_premul_data((unsigned int *) map, result->w * result->h); } //printf("LOAD successful: %dx%d alpha_sparse %d\n", // result->w, result->h, result->alpha_sparse); ret = CSERVE2_NONE; done: eina_file_close(fd); _cserve2_shm_unmap(map, params->shm.mmap_size); if (funcs) { if (loader_data) funcs->file_close(loader_data); evas_module_unload(module); } eina_stringshare_del(skey); return ret; }
static Error_Type image_open(const char *file, const char *key, Slave_Msg_Image_Opened *result, const char **use_loader) { Evas_Module *module; Eina_File *fd; const char *loader = NULL; const int filelen = strlen(file); unsigned int i; Error_Type ret = CSERVE2_NONE; Eina_Stringshare *skey = eina_stringshare_add(key); Evas_Image_Load_Opts load_opts; memset(&load_opts, 0, sizeof(load_opts)); fd = eina_file_open(file, EINA_FALSE); if (!fd) { return CSERVE2_DOES_NOT_EXIST; // FIXME: maybe check errno } if (!*use_loader) goto try_extension; loader = *use_loader; module = evas_module_find_type(EVAS_MODULE_TYPE_IMAGE_LOADER, loader); if (module) { if (_image_file_header(fd, skey, &load_opts, result, module)) goto success; } try_extension: loader = NULL; for (i = 0; i < sizeof(map_loaders) / sizeof(map_loaders[0]); i++) { int extlen = strlen(map_loaders[i].extension); if (extlen > filelen) continue; if (!strcasecmp(map_loaders[i].extension, file + filelen - extlen)) { loader = map_loaders[i].loader; break; } } if (loader) { module = evas_module_find_type(EVAS_MODULE_TYPE_IMAGE_LOADER, loader); if (_image_file_header(fd, skey, &load_opts, result, module)) goto success; loader = NULL; module = NULL; } // Try all known modules for (i = 0; i < sizeof(loaders_name) / sizeof(loaders_name[0]); i++) { loader = loaders_name[i]; module = evas_module_find_type(EVAS_MODULE_TYPE_IMAGE_LOADER, loader); if (!module) continue; if (_image_file_header(fd, skey, &load_opts, result, module)) goto success; } ret = CSERVE2_UNKNOWN_FORMAT; goto end; success: ret = CSERVE2_NONE; *use_loader = loader; // FIXME: Do we really need to unload the module now? evas_module_unload(module); end: eina_file_close(fd); eina_stringshare_del(skey); return ret; }
int main(int argc, char **argv) { Eina_File *f; Eina_Iterator *it; Eina_File_Line *l; GeoIP *geo; Community_Country *country; unsigned long long correct = 0; unsigned long long lines = 0; int i; if (argc != 2) return -1; eina_init(); community = eina_hash_stringshared_new(NULL); days = eina_hash_new(_community_day_key_length, _community_day_key_cmp, _community_day_key_hash, NULL, 5); countries = eina_hash_string_superfast_new(NULL); geo = GeoIP_new(GEOIP_STANDARD); memset(months, 0, sizeof (months)); /* Read real name country to tld file */ f = eina_file_open("country_tld.csv", EINA_FALSE); if (!f) return -1; it = eina_file_map_lines(f); EINA_ITERATOR_FOREACH(it, l) { const char *s; int i; s = memchr(l->start, ',', l->length); if (!s) continue ; country = calloc(1, sizeof (Community_Country)); country->tld = _eina_stringshare_up(l->start, s - l->start); country->country = _eina_stringshare_up(s + 1, l->length - (s - l->start + 1)); country->access = eina_hash_stringshared_new(NULL); eina_hash_direct_add(countries, country->tld, country); } eina_iterator_free(it); eina_file_close(f); /* Read population information */ f = eina_file_open("country_population.csv", EINA_FALSE); if (!f) return -1; it = eina_file_map_lines(f); EINA_ITERATOR_FOREACH(it, l) { Eina_Iterator *it2; const char *s; const char *country_name; const char *r; for (s = l->start; s < l->end; s++) { const char *convert = VIGRID_NUMBER_SEARCH; r = strchr(convert, *s); if (r) break ; } if (!r) continue; country = NULL; country_name = _eina_stringshare_up(l->start, s - l->start - 1); it2 = eina_hash_iterator_data_new(countries); EINA_ITERATOR_FOREACH(it2, country) { if (country->country == country_name) { unsigned long long offset = s - l->start; country->population = _eina_file_int_get(l, &offset); break; } } eina_iterator_free(it2); }
static Eina_Bool evas_image_load_file_head_ico(Evas_Img_Load_Params *ilp, const char *file, const char *key, int *error) { Eina_File *f; void *map = NULL; size_t position = 0; unsigned short word; unsigned char byte; int wanted_w = 0, wanted_h = 0, w, h, cols, i, planes = 0, bpp = 0, pdelta, search = -1, have_choice = 0, hasa = 1; unsigned int bmoffset, bmsize, fsize; unsigned short reserved, type, count; struct { int pdelta; int w, h; int cols; int bpp, planes; int hot_x, hot_y; unsigned int bmoffset, bmsize; } chosen = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; f = eina_file_open(file, EINA_FALSE); if (!f) { *error = EVAS_LOAD_ERROR_DOES_NOT_EXIST; return EINA_FALSE; } *error = EVAS_LOAD_ERROR_UNKNOWN_FORMAT; fsize = eina_file_size_get(f); if (fsize < (6 + 16 + 40)) goto close_file; map = eina_file_map_all(f, EINA_FILE_SEQUENTIAL); if (!map) goto close_file; // key: // NULL == highest res // biggest == highest res // smallest == lowest res // // smaller == next size SMALLER than load opts WxH (if possible) // bigger == next size BIGGER than load opts WxH (if possible) // more ? search = BIGGEST; if ((ilp->opts.w > 0) && (ilp->opts.h > 0)) { wanted_w = ilp->opts.w; wanted_h = ilp->opts.h; search = SMALLER; } if (!read_ushort(map, fsize, &position, &reserved)) goto close_file; if (!read_ushort(map, fsize, &position, &type)) goto close_file; if (!read_ushort(map, fsize, &position, &count)) goto close_file; if (!((reserved == 0) && ((type == ICON) || (type == CURSOR)) && (count > 0))) goto close_file; *error = EVAS_LOAD_ERROR_CORRUPT_FILE; if (key) { if (!strcmp(key, "biggest")) { wanted_w = 0; wanted_h = 0; search = BIGGEST; chosen.pdelta = 0; } else if (!strcmp(key, "smallest")) { wanted_w = 1; wanted_h = 1; search = SMALLEST; chosen.pdelta = 0x7fffffff; } else if (!strcmp(key, "smaller")) { chosen.pdelta = 0x7fffffff; search = SMALLER; } else if (!strcmp(key, "bigger")) { chosen.pdelta = 0x7fffffff; search = BIGGER; } } for (i = 0; i < count; i++) { unsigned char tw = 0, th = 0, tcols = 0; if (!read_uchar(map, fsize, &position, &tw)) goto close_file; w = tw; if (w <= 0) w = 256; if (!read_uchar(map, fsize, &position, &th)) goto close_file; h = th; if (h <= 0) h = 256; if (!read_uchar(map, fsize, &position, &tcols)) goto close_file; cols = tcols; if (cols <= 0) cols = 256; if (!read_uchar(map, fsize, &position, &byte)) goto close_file; if (!read_ushort(map, fsize, &position, &word)) goto close_file; if (type == CURSOR) planes = word; //else hot_x = word; if (!read_ushort(map, fsize, &position, &word)) goto close_file; if (type == CURSOR) bpp = word; //else hot_y = word; if (!read_uint(map, fsize, &position, &bmsize)) goto close_file; if (!read_uint(map, fsize, &position, &bmoffset)) goto close_file; if ((bmsize <= 0) || (bmoffset <= 0) || (bmoffset >= fsize)) goto close_file; if (search == BIGGEST) { pdelta = w * h; if ((!have_choice) || ((pdelta >= chosen.pdelta) && (((bpp >= 3) && (bpp >= chosen.bpp)) || ((bpp < 3) && (cols >= chosen.cols))))) { have_choice = 1; chosen.pdelta = pdelta; chosen.w = w; chosen.h = h; chosen.cols = cols; chosen.bpp = bpp; chosen.planes = planes; chosen.bmsize = bmsize; chosen.bmoffset = bmoffset; } } else { if (search == SMALLEST) { pdelta = w * h; if ((!have_choice) || ((pdelta <= chosen.pdelta) && (((bpp >= 3) && (bpp >= chosen.bpp)) || ((bpp < 3) && (cols >= chosen.cols))))) { have_choice = 1; chosen.pdelta = pdelta; chosen.w = w; chosen.h = h; chosen.cols = cols; chosen.bpp = bpp; chosen.planes = planes; chosen.bmsize = bmsize; chosen.bmoffset = bmoffset; } } else if (search == SMALLER) { pdelta = (wanted_w * wanted_h) - (w * h); if ((!have_choice) || ((w <= wanted_w) && (h <= wanted_h) && (pdelta <= chosen.pdelta) && (((bpp >= 3) && (bpp >= chosen.bpp)) || ((bpp < 3) && (cols >= chosen.cols))))) { have_choice = 1; if (pdelta < 0) pdelta = 0x7fffffff; chosen.pdelta = pdelta; chosen.w = w; chosen.h = h; chosen.cols = cols; chosen.bpp = bpp; chosen.planes = planes; chosen.bmsize = bmsize; chosen.bmoffset = bmoffset; } } else if (search == BIGGER) { pdelta = (w * h) - (wanted_w * wanted_h); if ((!have_choice) || ((w >= wanted_w) && (h >= wanted_h) && (pdelta <= chosen.pdelta) && (((bpp >= 3) && (bpp >= chosen.bpp)) || ((bpp < 3) && (cols >= chosen.cols))))) { have_choice = 1; if (pdelta < 0) pdelta = 0x7fffffff; chosen.pdelta = pdelta; chosen.w = w; chosen.h = h; chosen.cols = cols; chosen.bpp = bpp; chosen.planes = planes; chosen.bmsize = bmsize; chosen.bmoffset = bmoffset; } } } } if (chosen.bmoffset == 0) goto close_file; position = chosen.bmoffset; w = chosen.w; h = chosen.h; if ((w > 256) || (h > 256)) goto close_file; if ((w < 1) || (h < 1) || (w > IMG_MAX_SIZE) || (h > IMG_MAX_SIZE) || IMG_TOO_BIG(w, h)) { if (IMG_TOO_BIG(w, h)) *error = EVAS_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED; else *error = EVAS_LOAD_ERROR_GENERIC; goto close_file; } ilp->w = w; ilp->h = h; if (hasa) ilp->alpha = 1; eina_file_map_free(f, map); eina_file_close(f); *error = EVAS_LOAD_ERROR_NONE; return EINA_TRUE; close_file: if (map) eina_file_map_free(f, map); eina_file_close(f); return EINA_FALSE; }