/** * Navit, a modular navigation system. * Copyright (C) 2005-2011 Navit Team * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * version 2 as published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #define _FILE_OFFSET_BITS 64 #define _LARGEFILE_SOURCE #define _LARGEFILE64_SOURCE #include "config.h" #ifdef HAVE_UNISTD_H #include #endif #ifdef _MSC_VER #include #else #include #endif /* _MSC_VER */ #include #include #include #include #include #include #include #include #include #include "debug.h" #include "cache.h" #include "file.h" #include "atom.h" #include "item.h" #include "util.h" #include "types.h" #ifdef HAVE_SOCKET #include #include #endif extern char *version; #ifdef HAVE_LIBCRYPTO #include #include #include #include #include #endif #ifdef HAVE_API_ANDROID #define lseek lseek64 #endif #ifndef O_LARGEFILE #define O_LARGEFILE 0 #endif #ifndef O_BINARY #define O_BINARY 0 #endif #ifdef CACHE_SIZE static GHashTable *file_name_hash; #endif static struct cache *file_cache; #ifdef _MSC_VER #pragma pack(push,1) #endif /* _MSC_VER */ struct file_cache_id { long long offset; int size; int file_name_id; int method; #ifndef _MSC_VER }__attribute__ ((packed)); #else /* _MSC_VER */ }; #pragma pack(pop) #endif /* _MSC_VER */ #ifdef HAVE_SOCKET static int file_socket_connect(char *host, char *service) { struct addrinfo hints; struct addrinfo *result, *rp; int fd=-1,s; memset(&hints, 0, sizeof(struct addrinfo)); hints.ai_family = AF_UNSPEC; hints.ai_socktype = SOCK_STREAM; hints.ai_flags = 0; hints.ai_protocol = 0; s = getaddrinfo(host, service, &hints, &result); if (s != 0) { dbg(0,"getaddrinfo error %s\n",gai_strerror(s)); return -1; } for (rp = result; rp != NULL; rp = rp->ai_next) { fd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol); if (fd != -1) { if (connect(fd, rp->ai_addr, rp->ai_addrlen) != -1) break; close(fd); fd=-1; } } freeaddrinfo(result); return fd; } static void file_http_request(struct file *file, char *method, char *host, char *path, char *header, int persistent) { char *request=g_strdup_printf("%s %s HTTP/1.0\r\nUser-Agent: navit %s\r\nHost: %s\r\n%s%s%s\r\n",method,path,version,host,persistent?"Connection: Keep-Alive\r\n":"",header?header:"",header?"\r\n":""); write(file->fd, request, strlen(request)); dbg(1,"%s\n",request); file->requests++; } static int file_request_do(struct file *file, struct attr **options, int connect) { struct attr *attr; char *name; if (!options) return 0; attr=attr_search(options, NULL, attr_url); if (!attr) return 0; name=attr->u.str; if (!name) return 0; g_free(file->name); file->name = g_strdup(name); if (!strncmp(name,"http://",7)) { char *host=g_strdup(name+7); char *port=strchr(host,':'); char *path=strchr(name+7,'/'); char *method="GET"; char *header=NULL; int persistent=0; if ((attr=attr_search(options, NULL, attr_http_method)) && attr->u.str) method=attr->u.str; if ((attr=attr_search(options, NULL, attr_http_header)) && attr->u.str) header=attr->u.str; if ((attr=attr_search(options, NULL, attr_persistent))) persistent=attr->u.num; if (path) host[path-name-7]='\0'; if (port) *port++='\0'; dbg(1,"host=%s path=%s\n",host,path); if (connect) file->fd=file_socket_connect(host,port?port:"80"); file_http_request(file,method,host,path,header,persistent); file->special=1; g_free(host); } return 1; } #endif static unsigned char * file_http_header_end(unsigned char *str, int len) { int i; for (i=0; i+1headers) return NULL; return g_hash_table_lookup(f->headers, header); } struct file * file_create(char *name, struct attr **options) { struct stat stat; struct file *file= g_new0(struct file,1); struct attr *attr; int open_flags=O_LARGEFILE|O_BINARY; if (options && (attr=attr_search(options, NULL, attr_url))) { #ifdef HAVE_SOCKET file_request_do(file, options, 1); #endif } else { if (options && (attr=attr_search(options, NULL, attr_readwrite)) && attr->u.num) { open_flags |= O_RDWR; if ((attr=attr_search(options, NULL, attr_create)) && attr->u.num) open_flags |= O_CREAT; } else open_flags |= O_RDONLY; file->name = g_strdup(name); file->fd=open(name, open_flags, 0666); if (file->fd == -1) { g_free(file); return NULL; } dbg(1,"fd=%d\n", file->fd); fstat(file->fd, &stat); file->size=stat.st_size; dbg(1,"size="LONGLONG_FMT"\n", file->size); file->name_id = (long)atom(name); } #ifdef CACHE_SIZE if (!options || !(attr=attr_search(options, NULL, attr_cache)) || attr->u.num) file->cache=1; #endif dbg_assert(file != NULL); return file; } #if 0 struct file * file_create_url(char *url) { } #endif #ifndef S_ISDIR #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR) #endif #ifndef S_ISREG #define S_ISREG(m) (((m) & S_IFMT) == S_IFREG) #endif int file_is_dir(char *name) { struct stat buf; if (! stat(name, &buf)) { return S_ISDIR(buf.st_mode); } return 0; } int file_is_reg(char *name) { struct stat buf; if (! stat(name, &buf)) { return S_ISREG(buf.st_mode); } return 0; } long long file_size(struct file *file) { return file->size; } int file_mkdir(char *name, int pflag) { char *buffer=g_alloca(sizeof(char)*(strlen(name)+1)); int ret; char *next; dbg(1,"enter %s %d\n",name,pflag); if (!pflag) { if (file_is_dir(name)) return 0; #if defined HAVE_API_WIN32_BASE || defined _MSC_VER return mkdir(name); #else return mkdir(name, 0777); #endif } strcpy(buffer, name); next=buffer; while ((next=strchr(next, '/'))) { *next='\0'; if (*buffer) { ret=file_mkdir(buffer, 0); if (ret) return ret; } *next++='/'; } if (pflag == 2) return 0; return file_mkdir(buffer, 0); } int file_mmap(struct file *file) { #if 0 int mmap_size=file->size+1024*1024; #else int mmap_size=file->size; #endif #ifdef HAVE_API_WIN32_BASE file->begin = (char*)mmap_readonly_win32( file->name, &file->map_handle, &file->map_file ); #else file->begin=mmap(NULL, mmap_size, PROT_READ|PROT_WRITE, MAP_PRIVATE, file->fd, 0); dbg_assert(file->begin != NULL); if (file->begin == (void *)0xffffffff) { perror("mmap"); return 0; } #endif dbg_assert(file->begin != (void *)0xffffffff); file->mmap_end=file->begin+mmap_size; file->end=file->begin+file->size; return 1; } unsigned char * file_data_read(struct file *file, long long offset, int size) { void *ret; if (file->special) return NULL; if (file->begin) return file->begin+offset; if (file_cache) { struct file_cache_id id={offset,size,file->name_id,0}; ret=cache_lookup(file_cache,&id); if (ret) return ret; ret=cache_insert_new(file_cache,&id,size); } else ret=g_malloc(size); lseek(file->fd, offset, SEEK_SET); if (read(file->fd, ret, size) != size) { file_data_free(file, ret); ret=NULL; } return ret; } static void file_process_headers(struct file *file, unsigned char *headers) { char *tok; char *cl; if (file->headers) g_hash_table_destroy(file->headers); file->headers=g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL); while ((tok=strtok((char*)headers, "\r\n"))) { char *sep; tok=g_strdup(tok); sep=strchr(tok,':'); if (!sep) sep=strchr(tok,'/'); if (!sep) { g_free(tok); continue; } *sep++='\0'; if (*sep == ' ') sep++; strtolower(tok, tok); dbg(1,"header '%s'='%s'\n",tok,sep); g_hash_table_insert(file->headers, tok, sep); headers=NULL; } cl=g_hash_table_lookup(file->headers, "content-length"); if (cl) #ifdef HAVE__ATOI64 file->size=_atoi64(cl); #else file->size=atoll(cl); #endif } static void file_shift_buffer(struct file *file, int amount) { memmove(file->buffer, file->buffer+amount, file->buffer_len-amount); file->buffer_len-=amount; } unsigned char * file_data_read_special(struct file *file, int size, int *size_ret) { unsigned char *ret,*hdr; int rets=0,rd; int buffer_size=8192; int eof=0; if (!file->special) return NULL; if (!file->buffer) file->buffer=g_malloc(buffer_size); ret=g_malloc(size); while ((size > 0 || file->requests) && (!eof || file->buffer_len)) { int toread=buffer_size-file->buffer_len; if (toread >= 4096 && !eof) { if (!file->requests && toread > size) toread=size; rd=read(file->fd, file->buffer+file->buffer_len, toread); if (rd > 0) { file->buffer_len+=rd; } else eof=1; } if (file->requests) { dbg(1,"checking header\n"); if ((hdr=file_http_header_end(file->buffer, file->buffer_len))) { hdr[-1]='\0'; dbg(1,"found %s (%d bytes)\n",file->buffer,sizeof(file->buffer)); file_process_headers(file, file->buffer); file_shift_buffer(file, hdr-file->buffer); file->requests--; if (file_http_header(file, "location")) break; } } if (!file->requests) { rd=file->buffer_len; if (rd > size) rd=size; memcpy(ret+rets, file->buffer, rd); file_shift_buffer(file, rd); rets+=rd; size-=rd; } } *size_ret=rets; return ret; } unsigned char * file_data_read_all(struct file *file) { return file_data_read(file, 0, file->size); } void file_data_flush(struct file *file, long long offset, int size) { if (file_cache) { struct file_cache_id id={offset,size,file->name_id,0}; cache_flush(file_cache,&id); dbg(1,"Flushing "LONGLONG_FMT" %d bytes\n",offset,size); } } int file_data_write(struct file *file, long long offset, int size, unsigned char *data) { file_data_flush(file, offset, size); lseek(file->fd, offset, SEEK_SET); if (write(file->fd, data, size) != size) return 0; if (file->size < offset+size) file->size=offset+size; return 1; } int file_get_contents(char *name, unsigned char **buffer, int *size) { struct file *file; file=file_create(name, 0); if (!file) return 0; *size=file_size(file); *buffer=file_data_read_all(file); file_destroy(file); return 1; } static int uncompress_int(Bytef *dest, uLongf *destLen, const Bytef *source, uLong sourceLen) { z_stream stream; int err; stream.next_in = (Bytef*)source; stream.avail_in = (uInt)sourceLen; stream.next_out = dest; stream.avail_out = (uInt)*destLen; stream.zalloc = (alloc_func)0; stream.zfree = (free_func)0; err = inflateInit2(&stream, -MAX_WBITS); if (err != Z_OK) return err; err = inflate(&stream, Z_FINISH); if (err != Z_STREAM_END) { inflateEnd(&stream); if (err == Z_NEED_DICT || (err == Z_BUF_ERROR && stream.avail_in == 0)) return Z_DATA_ERROR; return err; } *destLen = stream.total_out; err = inflateEnd(&stream); return err; } unsigned char * file_data_read_compressed(struct file *file, long long offset, int size, int size_uncomp) { void *ret; char *buffer = 0; uLongf destLen=size_uncomp; if (file_cache) { struct file_cache_id id={offset,size,file->name_id,1}; ret=cache_lookup(file_cache,&id); if (ret) return ret; ret=cache_insert_new(file_cache,&id,size_uncomp); } else ret=g_malloc(size_uncomp); lseek(file->fd, offset, SEEK_SET); buffer = (char *)g_malloc(size); if (read(file->fd, buffer, size) != size) { g_free(ret); ret=NULL; } else { if (uncompress_int(ret, &destLen, (Bytef *)buffer, size) != Z_OK) { dbg(0,"uncompress failed\n"); g_free(ret); ret=NULL; } } g_free(buffer); return ret; } unsigned char * file_data_read_encrypted(struct file *file, long long offset, int size, int size_uncomp, int compressed, char *passwd) { #ifdef HAVE_LIBCRYPTO void *ret; unsigned char *buffer = 0; uLongf destLen=size_uncomp; if (file_cache) { struct file_cache_id id={offset,size,file->name_id,1}; ret=cache_lookup(file_cache,&id); if (ret) return ret; ret=cache_insert_new(file_cache,&id,size_uncomp); } else ret=g_malloc(size_uncomp); lseek(file->fd, offset, SEEK_SET); buffer = (unsigned char *)g_malloc(size); if (read(file->fd, buffer, size) != size) { g_free(ret); ret=NULL; } else { unsigned char key[34], salt[8], verify[2], counter[16], xor[16], mac[10], *datap; int overhead=sizeof(salt)+sizeof(verify)+sizeof(mac); int esize=size-overhead; PKCS5_PBKDF2_HMAC_SHA1(passwd, strlen(passwd), (unsigned char *)buffer, 8, 1000, 34, key); if (key[32] == buffer[8] && key[33] == buffer[9] && esize >= 0) { AES_KEY aeskey; AES_set_encrypt_key(key, 128, &aeskey); datap=buffer+sizeof(salt)+sizeof(verify); memset(counter, 0, sizeof(counter)); while (esize > 0) { int i,curr_size,idx=0; do { counter[idx]++; } while (!counter[idx++]); AES_encrypt(counter, xor, &aeskey); curr_size=esize; if (curr_size > sizeof(xor)) curr_size=sizeof(xor); for (i = 0 ; i < curr_size ; i++) *datap++^=xor[i]; esize-=curr_size; } size-=overhead; datap=buffer+sizeof(salt)+sizeof(verify); if (compressed) { if (uncompress_int(ret, &destLen, (Bytef *)datap, size) != Z_OK) { dbg(0,"uncompress failed\n"); g_free(ret); ret=NULL; } } else { if (size == destLen) memcpy(ret, buffer, destLen); else { dbg(0,"memcpy failed\n"); g_free(ret); ret=NULL; } } } else { g_free(ret); ret=NULL; } } g_free(buffer); return ret; #else return NULL; #endif } void file_data_free(struct file *file, unsigned char *data) { if (file->begin) { if (data == file->begin) return; if (data >= file->begin && data < file->end) return; } if (file->cache && data) { cache_entry_destroy(file_cache, data); } else g_free(data); } void file_data_remove(struct file *file, unsigned char *data) { if (file->begin) { if (data == file->begin) return; if (data >= file->begin && data < file->end) return; } if (file->cache && data) { cache_flush_data(file_cache, data); } else g_free(data); } int file_exists(char const *name) { struct stat buf; if (! stat(name, &buf)) return 1; return 0; } void file_remap_readonly(struct file *f) { #if defined(_WIN32) || defined(__CEGCC__) #else void *begin; munmap(f->begin, f->size); begin=mmap(f->begin, f->size, PROT_READ, MAP_PRIVATE, f->fd, 0); if (f->begin != begin) printf("remap failed\n"); #endif } void file_unmap(struct file *f) { #if defined(_WIN32) || defined(__CEGCC__) mmap_unmap_win32( f->begin, f->map_handle , f->map_file ); #else munmap(f->begin, f->size); #endif } #ifndef _MSC_VER void * file_opendir(char *dir) { return opendir(dir); } #else void * file_opendir(char *dir) { WIN32_FIND_DATAA FindFileData; HANDLE hFind = INVALID_HANDLE_VALUE; #undef UNICODE // we need FindFirstFileA() which takes an 8-bit c-string char* fname=g_alloca(sizeof(char)*(strlen(dir)+4)); sprintf(fname,"%s\\*",dir); hFind = FindFirstFileA(fname, &FindFileData); return hFind; } #endif #ifndef _MSC_VER char * file_readdir(void *hnd) { struct dirent *ent; ent=readdir(hnd); if (! ent) return NULL; return ent->d_name; } #else char * file_readdir(void *hnd) { WIN32_FIND_DATA FindFileData; if (FindNextFile(hnd, &FindFileData) ) { return FindFileData.cFileName; } else { return NULL; } } #endif /* _MSC_VER */ #ifndef _MSC_VER void file_closedir(void *hnd) { closedir(hnd); } #else void file_closedir(void *hnd) { FindClose(hnd); } #endif /* _MSC_VER */ struct file * file_create_caseinsensitive(char *name, struct attr **options) { char *dirname=g_alloca(sizeof(char)*(strlen(name)+1)); char *filename; char *p; void *d; struct file *ret; ret=file_create(name, options); if (ret) return ret; strcpy(dirname, name); p=dirname+strlen(name); while (p > dirname) { if (*p == '/') break; p--; } *p=0; d=file_opendir(dirname); if (d) { *p++='/'; while ((filename=file_readdir(d))) { if (!g_strcasecmp(filename, p)) { strcpy(p, filename); ret=file_create(dirname, options); if (ret) break; } } file_closedir(d); } return ret; } void file_destroy(struct file *f) { if (f->headers) g_hash_table_destroy(f->headers); switch (f->special) { case 0: case 1: close(f->fd); break; } if ( f->begin != NULL ) { file_unmap( f ); } g_free(f->buffer); g_free(f->name); g_free(f); } struct file_wordexp { int err; wordexp_t we; }; struct file_wordexp * file_wordexp_new(const char *pattern) { struct file_wordexp *ret=g_new0(struct file_wordexp, 1); ret->err=wordexp(pattern, &ret->we, 0); if (ret->err) dbg(0,"wordexp('%s') returned %d\n", pattern, ret->err); return ret; } int file_wordexp_get_count(struct file_wordexp *wexp) { return wexp->we.we_wordc; } char ** file_wordexp_get_array(struct file_wordexp *wexp) { return wexp->we.we_wordv; } void file_wordexp_destroy(struct file_wordexp *wexp) { if (! wexp->err) wordfree(&wexp->we); g_free(wexp); } int file_get_param(struct file *file, struct param_list *param, int count) { int i=count; param_add_string("Filename", file->name, ¶m, &count); param_add_hex("Size", file->size, ¶m, &count); return i-count; } int file_version(struct file *file, int mode) { #ifndef HAVE_API_WIN32_BASE struct stat st; int error; if (mode == 3) { long long size=lseek(file->fd, 0, SEEK_END); if (file->begin && file->begin+size > file->mmap_end) { file->version++; } else { file->size=size; if (file->begin) file->end=file->begin+file->size; } } else { if (mode == 2) error=stat(file->name, &st); else error=fstat(file->fd, &st); if (error || !file->version || file->mtime != st.st_mtime || file->ctime != st.st_ctime) { file->mtime=st.st_mtime; file->ctime=st.st_ctime; file->version++; dbg(1,"%s now version %d\n", file->name, file->version); } } return file->version; #else return 0; #endif } void * file_get_os_handle(struct file *file) { return GINT_TO_POINTER(file->fd); } void file_init(void) { #ifdef CACHE_SIZE file_name_hash=g_hash_table_new(g_str_hash, g_str_equal); file_cache=cache_new(sizeof(struct file_cache_id), CACHE_SIZE); #endif } void file_cache_init(void) { }