Bug 5984 - Convert file offsets to 64 bit

git-svn-id: http://svn.digium.com/svn/asterisk/trunk@10579 f38db490-d61c-443f-a65b-d21fe96a405b

17 files changed, 131 insertions, 132 deletions

diff --git a/Makefile b/Makefile
index b6a5bbf16..b9819b436 100644
--- a/Makefile
+++ b/Makefile
@@ -147,6 +147,9 @@ endif
 
 ASTCFLAGS=
 
+# Define this to use files larger than 2GB (useful for sound files longer than 37 hours and logfiles)
+ASTCFLAGS+=-D_FILE_OFFSET_BITS=64
+
 # Pentium Pro Optimize
 #PROC=i686
 
diff --git a/file.c b/file.c
index d150c901c..9e3db7b0c 100644
--- a/file.c
+++ b/file.c
@@ -67,11 +67,11 @@ struct ast_format {
 	/*! Write a frame to a channel */
 	int (*write)(struct ast_filestream *, struct ast_frame *);
 	/*! seek num samples into file, whence(think normal seek) */
-	int (*seek)(struct ast_filestream *, long offset, int whence);
+	int (*seek)(struct ast_filestream *, off_t offset, int whence);
 	/*! trunc file to current position */
 	int (*trunc)(struct ast_filestream *fs);
 	/*! tell current position */
-	long (*tell)(struct ast_filestream *fs);
+	off_t (*tell)(struct ast_filestream *fs);
 	/*! Read the next frame from the filestream (if available) and report when to get next one
 		(in samples) */
 	struct ast_frame * (*read)(struct ast_filestream *, int *whennext);
@@ -106,9 +106,9 @@ int ast_format_register(const char *name, const char *exts, int format,
 						struct ast_filestream * (*open)(FILE *f),
 						struct ast_filestream * (*rewrite)(FILE *f, const char *comment),
 						int (*write)(struct ast_filestream *, struct ast_frame *),
-						int (*seek)(struct ast_filestream *, long sample_offset, int whence),
+						int (*seek)(struct ast_filestream *, off_t sample_offset, int whence),
 						int (*trunc)(struct ast_filestream *),
-						long (*tell)(struct ast_filestream *),
+						off_t (*tell)(struct ast_filestream *),
 						struct ast_frame * (*read)(struct ast_filestream *, int *whennext),
 						void (*close)(struct ast_filestream *),
 						char * (*getcomment)(struct ast_filestream *))
@@ -647,7 +647,7 @@ int ast_playstream(struct ast_filestream *s)
 	return 0;
 }
 
-int ast_seekstream(struct ast_filestream *fs, long sample_offset, int whence)
+int ast_seekstream(struct ast_filestream *fs, off_t sample_offset, int whence)
 {
 	return fs->fmt->seek(fs, sample_offset, whence);
 }
@@ -657,22 +657,22 @@ int ast_truncstream(struct ast_filestream *fs)
 	return fs->fmt->trunc(fs);
 }
 
-long ast_tellstream(struct ast_filestream *fs)
+off_t ast_tellstream(struct ast_filestream *fs)
 {
 	return fs->fmt->tell(fs);
 }
 
-int ast_stream_fastforward(struct ast_filestream *fs, long ms)
+int ast_stream_fastforward(struct ast_filestream *fs, off_t ms)
 {
 	/* I think this is right, 8000 samples per second, 1000 ms a second so 8
 	 * samples per ms  */
-	long samples = ms * 8;
+	off_t samples = ms * 8;
 	return ast_seekstream(fs, samples, SEEK_CUR);
 }
 
-int ast_stream_rewind(struct ast_filestream *fs, long ms)
+int ast_stream_rewind(struct ast_filestream *fs, off_t ms)
 {
-	long samples = ms * 8;
+	off_t samples = ms * 8;
 	samples = samples * -1;
 	return ast_seekstream(fs, samples, SEEK_CUR);
 }
diff --git a/formats/format_au.c b/formats/format_au.c
index 669fa1921..e8be324ae 100644
--- a/formats/format_au.c
+++ b/formats/format_au.c
@@ -107,7 +107,7 @@ static int check_header(FILE *f)
 	AU_HEADER(header);
 	u_int32_t magic;
 	u_int32_t hdr_size;
-	u_int32_t data_size;
+	off_t data_size;
 	u_int32_t encoding;
 	u_int32_t sample_rate;
 	u_int32_t channels;
@@ -141,7 +141,7 @@ static int check_header(FILE *f)
 	}
 	/* Skip to data */
 	fseek(f, 0, SEEK_END);
-	data_size = ftell(f) - hdr_size;
+	data_size = ftello(f) - hdr_size;
 	if (fseek(f, hdr_size, SEEK_SET) == -1 ) {
 		ast_log(LOG_WARNING, "Failed to skip to data: %d\n", hdr_size);
 		return -1;
@@ -155,9 +155,9 @@ static int update_header(FILE *f)
 	u_int32_t datalen;
 	int bytes;
 
-	cur = ftell(f);
+	cur = ftello(f);
 	fseek(f, 0, SEEK_END);
-	end = ftell(f);
+	end = ftello(f);
 	/* data starts 24 bytes in */
 	bytes = end - AU_HEADER_SIZE;
 	datalen = htoll(bytes);
@@ -315,16 +315,16 @@ static int au_write(struct ast_filestream *fs, struct ast_frame *f)
 	return 0;
 }
 
-static int au_seek(struct ast_filestream *fs, long sample_offset, int whence)
+static int au_seek(struct ast_filestream *fs, off_t sample_offset, int whence)
 {
 	off_t min, max, cur;
-	long offset = 0, samples;
+	unsigned long offset = 0, samples;
 	
 	samples = sample_offset;
 	min = AU_HEADER_SIZE;
-	cur = ftell(fs->f);
+	cur = ftello(fs->f);
 	fseek(fs->f, 0, SEEK_END);
-	max = ftell(fs->f);
+	max = ftello(fs->f);
 	if (whence == SEEK_SET)
 		offset = samples + min;
 	else if (whence == SEEK_CUR || whence == SEEK_FORCECUR)
@@ -341,16 +341,16 @@ static int au_seek(struct ast_filestream *fs, long sample_offset, int whence)
 
 static int au_trunc(struct ast_filestream *fs)
 {
-	if (ftruncate(fileno(fs->f), ftell(fs->f)))
+	if (ftruncate(fileno(fs->f), ftello(fs->f)))
 		return -1;
 	return update_header(fs->f);
 }
 
-static long au_tell(struct ast_filestream *fs)
+static off_t au_tell(struct ast_filestream *fs)
 {
 	off_t offset;
 
-	offset = ftell(fs->f);
+	offset = ftello(fs->f);
 	return offset - AU_HEADER_SIZE;
 }
 
diff --git a/formats/format_g723.c b/formats/format_g723.c
index 8263b379a..5eff15df3 100644
--- a/formats/format_g723.c
+++ b/formats/format_g723.c
@@ -214,7 +214,7 @@ static int g723_write(struct ast_filestream *fs, struct ast_frame *f)
 	return 0;
 }
 
-static int g723_seek(struct ast_filestream *fs, long sample_offset, int whence)
+static int g723_seek(struct ast_filestream *fs, off_t sample_offset, int whence)
 {
 	return -1;
 }
@@ -222,12 +222,12 @@ static int g723_seek(struct ast_filestream *fs, long sample_offset, int whence)
 static int g723_trunc(struct ast_filestream *fs)
 {
 	/* Truncate file to current length */
-	if (ftruncate(fileno(fs->f), ftell(fs->f)) < 0)
+	if (ftruncate(fileno(fs->f), ftello(fs->f)) < 0)
 		return -1;
 	return 0;
 }
 
-static long g723_tell(struct ast_filestream *fs)
+static off_t g723_tell(struct ast_filestream *fs)
 {
 	return -1;
 }
diff --git a/formats/format_g726.c b/formats/format_g726.c
index 717fdaf5b..70c6ac88f 100644
--- a/formats/format_g726.c
+++ b/formats/format_g726.c
@@ -391,7 +391,7 @@ static char *g726_getcomment(struct ast_filestream *s)
 	return NULL;
 }
 
-static int g726_seek(struct ast_filestream *fs, long sample_offset, int whence)
+static int g726_seek(struct ast_filestream *fs, off_t sample_offset, int whence)
 {
 	return -1;
 }
@@ -401,7 +401,7 @@ static int g726_trunc(struct ast_filestream *fs)
 	return -1;
 }
 
-static long g726_tell(struct ast_filestream *fs)
+static off_t g726_tell(struct ast_filestream *fs)
 {
 	return -1;
 }
diff --git a/formats/format_g729.c b/formats/format_g729.c
index 6afe539da..5194cea05 100644
--- a/formats/format_g729.c
+++ b/formats/format_g729.c
@@ -181,14 +181,14 @@ static char *g729_getcomment(struct ast_filestream *s)
 	return NULL;
 }
 
-static int g729_seek(struct ast_filestream *fs, long sample_offset, int whence)
+static int g729_seek(struct ast_filestream *fs, off_t sample_offset, int whence)
 {
 	long bytes;
 	off_t min,cur,max,offset=0;
 	min = 0;
-	cur = ftell(fs->f);
-	fseek(fs->f, 0, SEEK_END);
-	max = ftell(fs->f);
+	cur = ftello(fs->f);
+	fseeko(fs->f, 0, SEEK_END);
+	max = ftello(fs->f);
 	
 	bytes = 20 * (sample_offset / 160);
 	if (whence == SEEK_SET)
@@ -202,7 +202,7 @@ static int g729_seek(struct ast_filestream *fs, long sample_offset, int whence)
 	}
 	/* protect against seeking beyond begining. */
 	offset = (offset < min)?min:offset;
-	if (fseek(fs->f, offset, SEEK_SET) < 0)
+	if (fseeko(fs->f, offset, SEEK_SET) < 0)
 		return -1;
 	return 0;
 }
@@ -210,15 +210,15 @@ static int g729_seek(struct ast_filestream *fs, long sample_offset, int whence)
 static int g729_trunc(struct ast_filestream *fs)
 {
 	/* Truncate file to current length */
-	if (ftruncate(fileno(fs->f), ftell(fs->f)) < 0)
+	if (ftruncate(fileno(fs->f), ftello(fs->f)) < 0)
 		return -1;
 	return 0;
 }
 
-static long g729_tell(struct ast_filestream *fs)
+static off_t g729_tell(struct ast_filestream *fs)
 {
 	off_t offset;
-	offset = ftell(fs->f);
+	offset = ftello(fs->f);
 	return (offset/20)*160;
 }
 
diff --git a/formats/format_gsm.c b/formats/format_gsm.c
index 176c73a97..c6ef31f7e 100644
--- a/formats/format_gsm.c
+++ b/formats/format_gsm.c
@@ -195,14 +195,14 @@ static int gsm_write(struct ast_filestream *fs, struct ast_frame *f)
 	return 0;
 }
 
-static int gsm_seek(struct ast_filestream *fs, long sample_offset, int whence)
+static int gsm_seek(struct ast_filestream *fs, off_t sample_offset, int whence)
 {
 	off_t offset=0,min,cur,max,distance;
 	
 	min = 0;
-	cur = ftell(fs->f);
-	fseek(fs->f, 0, SEEK_END);
-	max = ftell(fs->f);
+	cur = ftello(fs->f);
+	fseeko(fs->f, 0, SEEK_END);
+	max = ftello(fs->f);
 	/* have to fudge to frame here, so not fully to sample */
 	distance = (sample_offset/160) * 33;
 	if(whence == SEEK_SET)
@@ -217,23 +217,23 @@ static int gsm_seek(struct ast_filestream *fs, long sample_offset, int whence)
 		offset = (offset > max)?max:offset;
 	} else if (offset > max) {
 		int i;
-		fseek(fs->f, 0, SEEK_END);
+		fseeko(fs->f, 0, SEEK_END);
 		for (i=0; i< (offset - max) / 33; i++) {
 			fwrite(gsm_silence, 1, 33, fs->f);
 		}
 	}
-	return fseek(fs->f, offset, SEEK_SET);
+	return fseeko(fs->f, offset, SEEK_SET);
 }
 
 static int gsm_trunc(struct ast_filestream *fs)
 {
-	return ftruncate(fileno(fs->f), ftell(fs->f));
+	return ftruncate(fileno(fs->f), ftello(fs->f));
 }
 
-static long gsm_tell(struct ast_filestream *fs)
+static off_t gsm_tell(struct ast_filestream *fs)
 {
 	off_t offset;
-	offset = ftell(fs->f);
+	offset = ftello(fs->f);
 	return (offset/33)*160;
 }
 
diff --git a/formats/format_h263.c b/formats/format_h263.c
index ccba23d6d..45692a354 100644
--- a/formats/format_h263.c
+++ b/formats/format_h263.c
@@ -221,7 +221,7 @@ static char *h263_getcomment(struct ast_filestream *s)
 	return NULL;
 }
 
-static int h263_seek(struct ast_filestream *fs, long sample_offset, int whence)
+static int h263_seek(struct ast_filestream *fs, off_t sample_offset, int whence)
 {
 	/* No way Jose */
 	return -1;
@@ -230,16 +230,16 @@ static int h263_seek(struct ast_filestream *fs, long sample_offset, int whence)
 static int h263_trunc(struct ast_filestream *fs)
 {
 	/* Truncate file to current length */
-	if (ftruncate(fileno(fs->f), ftell(fs->f)) < 0)
+	if (ftruncate(fileno(fs->f), ftello(fs->f)) < 0)
 		return -1;
 	return 0;
 }
 
-static long h263_tell(struct ast_filestream *fs)
+static off_t h263_tell(struct ast_filestream *fs)
 {
 	/* XXX This is totally bogus XXX */
 	off_t offset;
-	offset = ftell(fs->f);
+	offset = ftello(fs->f);
 	return (offset/20)*160;
 }
 
diff --git a/formats/format_ilbc.c b/formats/format_ilbc.c
index cbe017f66..f0bcfbf4e 100644
--- a/formats/format_ilbc.c
+++ b/formats/format_ilbc.c
@@ -180,14 +180,14 @@ static char *ilbc_getcomment(struct ast_filestream *s)
 	return NULL;
 }
 
-static int ilbc_seek(struct ast_filestream *fs, long sample_offset, int whence)
+static int ilbc_seek(struct ast_filestream *fs, off_t sample_offset, int whence)
 {
 	long bytes;
 	off_t min,cur,max,offset=0;
 	min = 0;
-	cur = ftell(fs->f);
-	fseek(fs->f, 0, SEEK_END);
-	max = ftell(fs->f);
+	cur = ftello(fs->f);
+	fseeko(fs->f, 0, SEEK_END);
+	max = ftello(fs->f);
 	
 	bytes = 50 * (sample_offset / 240);
 	if (whence == SEEK_SET)
@@ -201,7 +201,7 @@ static int ilbc_seek(struct ast_filestream *fs, long sample_offset, int whence)
 	}
 	/* protect against seeking beyond begining. */
 	offset = (offset < min)?min:offset;
-	if (fseek(fs->f, offset, SEEK_SET) < 0)
+	if (fseeko(fs->f, offset, SEEK_SET) < 0)
 		return -1;
 	return 0;
 }
@@ -209,15 +209,15 @@ static int ilbc_seek(struct ast_filestream *fs, long sample_offset, int whence)
 static int ilbc_trunc(struct ast_filestream *fs)
 {
 	/* Truncate file to current length */
-	if (ftruncate(fileno(fs->f), ftell(fs->f)) < 0)
+	if (ftruncate(fileno(fs->f), ftello(fs->f)) < 0)
 		return -1;
 	return 0;
 }
 
-static long ilbc_tell(struct ast_filestream *fs)
+static off_t ilbc_tell(struct ast_filestream *fs)
 {
 	off_t offset;
-	offset = ftell(fs->f);
+	offset = ftello(fs->f);
 	return (offset/50)*240;
 }
 
diff --git a/formats/format_ogg_vorbis.c b/formats/format_ogg_vorbis.c
index 408f19e13..0437a38ef 100644
--- a/formats/format_ogg_vorbis.c
+++ b/formats/format_ogg_vorbis.c
@@ -626,14 +626,12 @@ static int ogg_vorbis_trunc(struct ast_filestream *s)
  * \return 0 on success, -1 on failure.
  */
 
-static int ogg_vorbis_seek(struct ast_filestream *s, long sample_offset,
-			   int whence)
-{
+static int ogg_vorbis_seek(struct ast_filestream *s, off_t sample_offset, int whence) {
 	ast_log(LOG_WARNING, "Seeking is not supported on OGG/Vorbis streams!\n");
 	return -1;
 }
 
-static long ogg_vorbis_tell(struct ast_filestream *s)
+static off_t ogg_vorbis_tell(struct ast_filestream *s)
 {
 	ast_log(LOG_WARNING, "Telling is not supported on OGG/Vorbis streams!\n");
 	return -1;
diff --git a/formats/format_pcm.c b/formats/format_pcm.c
index da72a559e..240be65d1 100644
--- a/formats/format_pcm.c
+++ b/formats/format_pcm.c
@@ -174,14 +174,14 @@ static int pcm_write(struct ast_filestream *fs, struct ast_frame *f)
 	return 0;
 }
 
-static int pcm_seek(struct ast_filestream *fs, long sample_offset, int whence)
+static int pcm_seek(struct ast_filestream *fs, off_t sample_offset, int whence)
 {
-	long cur, max, offset = 0;
+	off_t cur, max, offset = 0;
  	int ret = -1;	/* assume error */
 
-	cur = ftell(fs->f);
-	fseek(fs->f, 0, SEEK_END);
-	max = ftell(fs->f);
+	cur = ftello(fs->f);
+	fseeko(fs->f, 0, SEEK_END);
+	max = ftello(fs->f);
 
 	switch (whence) {
 	case SEEK_SET:
@@ -218,20 +218,20 @@ static int pcm_seek(struct ast_filestream *fs, long sample_offset, int whence)
 			ast_log(LOG_WARNING, "offset too large %ld, truncating to %ld\n", offset, max);
 			offset = max;
 		}
-		ret = fseek(fs->f, offset, SEEK_SET);
+		ret = fseeko(fs->f, offset, SEEK_SET);
 	}
 	return ret;
 }
 
 static int pcm_trunc(struct ast_filestream *fs)
 {
-	return ftruncate(fileno(fs->f), ftell(fs->f));
+	return ftruncate(fileno(fs->f), ftello(fs->f));
 }
 
-static long pcm_tell(struct ast_filestream *fs)
+static off_t pcm_tell(struct ast_filestream *fs)
 {
 	off_t offset;
-	offset = ftell(fs->f);
+	offset = ftello(fs->f);
 	return offset;
 }
 
diff --git a/formats/format_pcm_alaw.c b/formats/format_pcm_alaw.c
index ffbb17a4f..de90ce2da 100644
--- a/formats/format_pcm_alaw.c
+++ b/formats/format_pcm_alaw.c
@@ -220,7 +220,7 @@ static int pcm_write(struct ast_filestream *fs, struct ast_frame *f)
 		unsigned long cur, to_write;
 
 		cur = stat_buf.st_size;
-		if (fseek(fs->f, cur, SEEK_SET) < 0) {
+		if (fseeko(fs->f, cur, SEEK_SET) < 0) {
 			ast_log( LOG_WARNING, "Cannot seek in file: %s\n", strerror(errno) );
 			return -1;
 		}
@@ -236,7 +236,7 @@ static int pcm_write(struct ast_filestream *fs, struct ast_frame *f)
 	}
 
 
-	if (fseek(s->f, fpos, SEEK_SET) < 0) {
+	if (fseeko(s->f, fpos, SEEK_SET) < 0) {
 		ast_log( LOG_WARNING, "Cannot seek in file: %s\n", strerror(errno) );
 		return -1;
 	}
@@ -249,14 +249,14 @@ static int pcm_write(struct ast_filestream *fs, struct ast_frame *f)
 	return 0;
 }
 
-static int pcm_seek(struct ast_filestream *fs, long sample_offset, int whence)
+static int pcm_seek(struct ast_filestream *fs, off_t sample_offset, int whence)
 {
-	long cur, max, offset = 0;
+	off_t cur, max, offset = 0;
  	int ret = -1; /* assume error */
 
-	cur = ftell(fs->f);
-	fseek(fs->f, 0, SEEK_END);
-	max = ftell(fs->f);
+	cur = ftello(fs->f);
+	fseeko(fs->f, 0, SEEK_END);
+	max = ftello(fs->f);
 
 	switch (whence) {
 	case SEEK_SET:
@@ -290,24 +290,24 @@ static int pcm_seek(struct ast_filestream *fs, long sample_offset, int whence)
 		}
 		ret = 0; /* success */
 	} else {
-                if (offset > max) {
-                        ast_log(LOG_WARNING, "offset too large %ld, truncating to %ld\n", offset, max);
-                        offset = max;
+		if (offset > max) {
+			ast_log(LOG_WARNING, "offset too large %ld, truncating to %ld\n", offset, max);
+			offset = max;
 		}
-                ret = fseek(fs->f, offset, SEEK_SET);
+		ret = fseeko(fs->f, offset, SEEK_SET);
 	}
 	return ret;
 }
 
 static int pcm_trunc(struct ast_filestream *fs)
 {
-	return ftruncate(fileno(fs->f), ftell(fs->f));
+	return ftruncate(fileno(fs->f), ftello(fs->f));
 }
 
-static long pcm_tell(struct ast_filestream *fs)
+static off_t pcm_tell(struct ast_filestream *fs)
 {
 	off_t offset;
-	offset = ftell(fs->f);
+	offset = ftello(fs->f);
 	return offset;
 }
 
diff --git a/formats/format_sln.c b/formats/format_sln.c
index d155b09a2..74792c605 100644
--- a/formats/format_sln.c
+++ b/formats/format_sln.c
@@ -169,15 +169,15 @@ static int slinear_write(struct ast_filestream *fs, struct ast_frame *f)
 	return 0;
 }
 
-static int slinear_seek(struct ast_filestream *fs, long sample_offset, int whence)
+static int slinear_seek(struct ast_filestream *fs, off_t sample_offset, int whence)
 {
 	off_t offset=0,min,cur,max;
 
 	min = 0;
 	sample_offset <<= 1;
-	cur = ftell(fs->f);
-	fseek(fs->f, 0, SEEK_END);
-	max = ftell(fs->f);
+	cur = ftello(fs->f);
+	fseeko(fs->f, 0, SEEK_END);
+	max = ftello(fs->f);
 	if (whence == SEEK_SET)
 		offset = sample_offset;
 	else if (whence == SEEK_CUR || whence == SEEK_FORCECUR)
@@ -189,18 +189,18 @@ static int slinear_seek(struct ast_filestream *fs, long sample_offset, int whenc
 	}
 	/* always protect against seeking past begining. */
 	offset = (offset < min)?min:offset;
-	return fseek(fs->f, offset, SEEK_SET);
+	return fseeko(fs->f, offset, SEEK_SET);
 }
 
 static int slinear_trunc(struct ast_filestream *fs)
 {
-	return ftruncate(fileno(fs->f), ftell(fs->f));
+	return ftruncate(fileno(fs->f), ftello(fs->f));
 }
 
-static long slinear_tell(struct ast_filestream *fs)
+static off_t slinear_tell(struct ast_filestream *fs)
 {
 	off_t offset;
-	offset = ftell(fs->f);
+	offset = ftello(fs->f);
 	return offset / 2;
 }
 
diff --git a/formats/format_vox.c b/formats/format_vox.c
index 60d2630be..8cc143178 100644
--- a/formats/format_vox.c
+++ b/formats/format_vox.c
@@ -178,14 +178,14 @@ static char *vox_getcomment(struct ast_filestream *s)
 	return NULL;
 }
 
-static int vox_seek(struct ast_filestream *fs, long sample_offset, int whence)
+static int vox_seek(struct ast_filestream *fs, off_t sample_offset, int whence)
 {
      off_t offset=0,min,cur,max,distance;
 	
      min = 0;
-     cur = ftell(fs->f);
-     fseek(fs->f, 0, SEEK_END);
-	 max = ftell(fs->f);
+     cur = ftello(fs->f);
+     fseeko(fs->f, 0, SEEK_END);
+	 max = ftello(fs->f);
 	 
      /* have to fudge to frame here, so not fully to sample */
      distance = sample_offset/2;
@@ -199,19 +199,19 @@ static int vox_seek(struct ast_filestream *fs, long sample_offset, int whence)
 	  offset = (offset > max)?max:offset;
 	  offset = (offset < min)?min:offset;
      }
-     fseek(fs->f, offset, SEEK_SET);
-	 return ftell(fs->f);
+     fseeko(fs->f, offset, SEEK_SET);
+	 return ftello(fs->f);
 }
 
 static int vox_trunc(struct ast_filestream *fs)
 {
-     return ftruncate(fileno(fs->f), ftell(fs->f));
+     return ftruncate(fileno(fs->f), ftello(fs->f));
 }
 
-static long vox_tell(struct ast_filestream *fs)
+static off_t vox_tell(struct ast_filestream *fs)
 {
      off_t offset;
-     offset = ftell(fs->f) << 1;
+     offset = ftello(fs->f) << 1;
      return offset; 
 }
 
diff --git a/formats/format_wav.c b/formats/format_wav.c
index 2e74e740b..67df4163b 100644
--- a/formats/format_wav.c
+++ b/formats/format_wav.c
@@ -234,9 +234,9 @@ static int update_header(FILE *f)
 	int datalen,filelen,bytes;
 	
 	
-	cur = ftell(f);
+	cur = ftello(f);
 	fseek(f, 0, SEEK_END);
-	end = ftell(f);
+	end = ftello(f);
 	/* data starts 44 bytes in */
 	bytes = end - 44;
 	datalen = htoll(bytes);
@@ -263,7 +263,7 @@ static int update_header(FILE *f)
 		ast_log(LOG_WARNING, "Unable to set write datalen\n");
 		return -1;
 	}
-	if (fseek(f, cur, SEEK_SET)) {
+	if (fseeko(f, cur, SEEK_SET)) {
 		ast_log(LOG_WARNING, "Unable to return to position\n");
 		return -1;
 	}
@@ -419,7 +419,7 @@ static struct ast_frame *wav_read(struct ast_filestream *s, int *whennext)
 	int bytes = sizeof(tmp);
 	off_t here;
 	/* Send a frame from the file to the appropriate channel */
-	here = ftell(s->f);
+	here = ftello(s->f);
 	if ((s->maxlen - here) < bytes)
 		bytes = s->maxlen - here;
 	if (bytes < 0)
@@ -522,16 +522,15 @@ static int wav_write(struct ast_filestream *fs, struct ast_frame *f)
 
 }
 
-static int wav_seek(struct ast_filestream *fs, long sample_offset, int whence)
+static int wav_seek(struct ast_filestream *fs, off_t sample_offset, int whence)
 {
-	off_t min,max,cur;
-	long offset=0,samples;
-	
+	off_t min, max, cur, offset = 0, samples;
+
 	samples = sample_offset * 2; /* SLINEAR is 16 bits mono, so sample_offset * 2 = bytes */
 	min = 44; /* wav header is 44 bytes */
-	cur = ftell(fs->f);
-	fseek(fs->f, 0, SEEK_END);
-	max = ftell(fs->f);
+	cur = ftello(fs->f);
+	fseeko(fs->f, 0, SEEK_END);
+	max = ftello(fs->f);
 	if (whence == SEEK_SET)
 		offset = samples + min;
 	else if (whence == SEEK_CUR || whence == SEEK_FORCECUR)
@@ -543,20 +542,20 @@ static int wav_seek(struct ast_filestream *fs, long sample_offset, int whence)
 	}
 	/* always protect the header space. */
 	offset = (offset < min)?min:offset;
-	return fseek(fs->f,offset,SEEK_SET);
+	return fseeko(fs->f, offset, SEEK_SET);
 }
 
 static int wav_trunc(struct ast_filestream *fs)
 {
-	if (ftruncate(fileno(fs->f), ftell(fs->f)))
+	if (ftruncate(fileno(fs->f), ftello(fs->f)))
 		return -1;
 	return update_header(fs->f);
 }
 
-static long wav_tell(struct ast_filestream *fs)
+static off_t wav_tell(struct ast_filestream *fs)
 {
 	off_t offset;
-	offset = ftell(fs->f);
+	offset = ftello(fs->f);
 	/* subtract header size to get samples, then divide by 2 for 16 bit samples */
 	return (offset - 44)/2;
 }
diff --git a/formats/format_wav_gsm.c b/formats/format_wav_gsm.c
index c7bc50425..0875e77fe 100644
--- a/formats/format_wav_gsm.c
+++ b/formats/format_wav_gsm.c
@@ -232,9 +232,9 @@ static int update_header(FILE *f)
 	off_t cur,end,bytes;
 	int datalen,filelen;
 	
-	cur = ftell(f);
+	cur = ftello(f);
 	fseek(f, 0, SEEK_END);
-	end = ftell(f);
+	end = ftello(f);
 	/* in a gsm WAV, data starts 60 bytes in */
 	bytes = end - 60;
 	datalen = htoll((bytes + 1) & ~0x1);
@@ -259,7 +259,7 @@ static int update_header(FILE *f)
 		ast_log(LOG_WARNING, "Unable to set write datalen\n");
 		return -1;
 	}
-	if (fseek(f, cur, SEEK_SET)) {
+	if (fseeko(f, cur, SEEK_SET)) {
 		ast_log(LOG_WARNING, "Unable to return to position\n");
 		return -1;
 	}
@@ -417,7 +417,7 @@ static void wav_close(struct ast_filestream *s)
 	ast_update_use_count();
 	/* Pad to even length */
 	fseek(s->f, 0, SEEK_END);
-	if (ftell(s->f) & 0x1)
+	if (ftello(s->f) & 0x1)
 		fwrite(&zero, 1, 1, s->f);
 	fclose(s->f);
 	free(s);
@@ -499,13 +499,13 @@ static int wav_write(struct ast_filestream *fs, struct ast_frame *f)
 	return 0;
 }
 
-static int wav_seek(struct ast_filestream *fs, long sample_offset, int whence)
+static int wav_seek(struct ast_filestream *fs, off_t sample_offset, int whence)
 {
 	off_t offset=0,distance,cur,min,max;
 	min = 60;
-	cur = ftell(fs->f);
+	cur = ftello(fs->f);
 	fseek(fs->f, 0, SEEK_END);
-	max = ftell(fs->f);
+	max = ftello(fs->f);
 	/* I'm getting sloppy here, I'm only going to go to even splits of the 2
 	 * frames, if you want tighter cuts use format_gsm, format_pcm, or format_wav */
 	distance = (sample_offset/320) * 65;
@@ -527,20 +527,20 @@ static int wav_seek(struct ast_filestream *fs, long sample_offset, int whence)
 		}
 	}
 	fs->secondhalf = 0;
-	return fseek(fs->f, offset, SEEK_SET);
+	return fseeko(fs->f, offset, SEEK_SET);
 }
 
 static int wav_trunc(struct ast_filestream *fs)
 {
-	if (ftruncate(fileno(fs->f), ftell(fs->f)))
+	if (ftruncate(fileno(fs->f), ftello(fs->f)))
 		return -1;
 	return update_header(fs->f);
 }
 
-static long wav_tell(struct ast_filestream *fs)
+static off_t wav_tell(struct ast_filestream *fs)
 {
 	off_t offset;
-	offset = ftell(fs->f);
+	offset = ftello(fs->f);
 	/* since this will most likely be used later in play or record, lets stick
 	 * to that level of resolution, just even frames boundaries */
 	return (offset - 52)/65*320;
diff --git a/include/asterisk/file.h b/include/asterisk/file.h
index e52570183..67150cf95 100644
--- a/include/asterisk/file.h
+++ b/include/asterisk/file.h
@@ -31,7 +31,6 @@
 #include "asterisk/frame.h"
 #include <fcntl.h>
 
-
 #if defined(__cplusplus) || defined(c_plusplus)
 extern "C" {
 #endif
@@ -56,9 +55,9 @@ int ast_format_register(const char *name, const char *exts, int format,
 						struct ast_filestream * (*open)(FILE *f),
 						struct ast_filestream * (*rewrite)(FILE *f, const char *comment),
 						int (*write)(struct ast_filestream *, struct ast_frame *),
-						int (*seek)(struct ast_filestream *, long offset, int whence),
+						int (*seek)(struct ast_filestream *, off_t offset, int whence),
 						int (*trunc)(struct ast_filestream *),
-						long (*tell)(struct ast_filestream *),
+						off_t (*tell)(struct ast_filestream *),
 						struct ast_frame * (*read)(struct ast_filestream *, int *timetonext),
 						void (*close)(struct ast_filestream *),
 						char * (*getcomment)(struct ast_filestream *));
@@ -262,7 +261,7 @@ int ast_playstream(struct ast_filestream *s);
  * \param whence SEEK_SET, SEEK_CUR, SEEK_END 
  * Returns 0 for success, or -1 for error
  */
-int ast_seekstream(struct ast_filestream *fs, long sample_offset, int whence);
+int ast_seekstream(struct ast_filestream *fs, off_t sample_offset, int whence);
 
 /*! Trunc stream at current location */
 /*!
@@ -277,7 +276,7 @@ int ast_truncstream(struct ast_filestream *fs);
  * \param ms milliseconds to move
  * Returns 0 for success, or -1 for error
  */
-int ast_stream_fastforward(struct ast_filestream *fs, long ms);
+int ast_stream_fastforward(struct ast_filestream *fs, off_t ms);
 
 /*! Rewind stream ms */
 /*!
@@ -285,14 +284,14 @@ int ast_stream_fastforward(struct ast_filestream *fs, long ms);
  * \param ms milliseconds to move
  * Returns 0 for success, or -1 for error
  */
-int ast_stream_rewind(struct ast_filestream *fs, long ms);
+int ast_stream_rewind(struct ast_filestream *fs, off_t ms);
 
 /*! Tell where we are in a stream */
 /*!
  * \param fs fs to act on
  * Returns a long as a sample offset into stream
  */
-long ast_tellstream(struct ast_filestream *fs);
+off_t ast_tellstream(struct ast_filestream *fs);
 
 /*! Read a frame from a filestream */
 /*!