FILE() now supports line-mode and writing (altering) files.
authorTilghman Lesher <tilghman@meg.abyt.es>
Tue, 13 Jul 2010 18:31:41 +0000 (18:31 +0000)
committerTilghman Lesher <tilghman@meg.abyt.es>
Tue, 13 Jul 2010 18:31:41 +0000 (18:31 +0000)
(closes issue #16461)
 Reported by: skyman
 Patches:
       20100622__issue16461.diff.txt uploaded by tilghman (license 14)
 Tested by: tilghman

Review: https://reviewboard.asterisk.org/r/737/

git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@276114 65c4cc65-6c06-0410-ace0-fbb531ad65f3

CHANGES
funcs/func_env.c
tests/test_func_file.c [new file with mode: 0644]

diff --git a/CHANGES b/CHANGES
index 3dd909d..a68e225 100644 (file)
--- a/CHANGES
+++ b/CHANGES
@@ -229,6 +229,7 @@ Dialplan Functions
    on hold or is a call waiting call.
  * Added option to dialplan function CDR(), the 'f' option
    allows for high resolution times for billsec and duration fields.
+ * FILE() now supports line-mode and writing.
 
 Dialplan Variables
 ------------------
index e9ddd41..f5814ae 100644 (file)
@@ -1,7 +1,7 @@
 /*
  * Asterisk -- An open source telephony toolkit.
  *
- * Copyright (C) 1999 - 2006, Digium, Inc.
+ * Copyright (C) 1999 - 2010, Digium, Inc.
  *
  * See http://www.asterisk.org for more information about
  * the Asterisk project. Please do not directly contact
@@ -17,7 +17,7 @@
 /*! \file
  *
  * \brief Environment related dialplan functions
- * 
+ *
  * \ingroup functions
  */
 
 
 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
 
-#include <sys/stat.h>
+#include <sys/stat.h>   /* stat(2) */
 
 #include "asterisk/module.h"
 #include "asterisk/channel.h"
 #include "asterisk/pbx.h"
 #include "asterisk/utils.h"
 #include "asterisk/app.h"
+#include "asterisk/file.h"
 
 /*** DOCUMENTATION
        <function name="ENV" language="en_US">
@@ -70,26 +71,158 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
        </function>
        <function name="FILE" language="en_US">
                <synopsis>
-                       Obtains the contents of a file.
+                       Read or write text file.
                </synopsis>
                <syntax>
                        <parameter name="filename" required="true" />
-                       <parameter name="offset" required="true">
+                       </parameter>
+                       <parameter name="offset">
                                <para>Maybe specified as any number. If negative, <replaceable>offset</replaceable> specifies the number
                                of bytes back from the end of the file.</para>
                        </parameter>
-                       <parameter name="length" required="true">
+                       <parameter name="length">
                                <para>If specified, will limit the length of the data read to that size. If negative,
                                trims <replaceable>length</replaceable> bytes from the end of the file.</para>
                        </parameter>
+                       <parameter name="options">
+                               <optionlist>
+                                       <option name="l">
+                                               <para>Line mode:  offset and length are assumed to be
+                                               measured in lines, instead of byte offsets.</para>
+                                       </option>
+                                       <option name="a">
+                                               <para>In write mode only, the append option is used to
+                                               append to the end of the file, instead of overwriting
+                                               the existing file.</para>
+                                       </option>
+                                       <option name="d">
+                                               <para>In write mode and line mode only, this option does
+                                               not automatically append a newline string to the end of
+                                               a value.  This is useful for deleting lines, instead of
+                                               setting them to blank.</para>
+                                       </option>
+                               </optionlist>
+                       </parameter>
+                       <parameter name="format">
+                               <para>The <replaceable>format</replaceable> parameter may be
+                               used to delimit the type of line terminators in line mode.</para>
+                               <optionlist>
+                                       <option name="u">
+                                               <para>Unix newline format.</para>
+                                       </option>
+                                       <option name="d">
+                                               <para>DOS newline format.</para>
+                                       </option>
+                                       <option name="m">
+                                               <para>Macintosh newline format.</para>
+                                       </option>
+                               </optionlist>
+                       </parameter>
+               </syntax>
+               <description>
+                       <para>Read and write text file in character and line mode.</para>
+                       <para>Examples:</para>
+                       <para/>
+                       <para>Read mode (byte):</para>
+                       <para>    ;reads the entire content of the file.</para>
+                       <para>    Set(foo=${FILE(/tmp/test.txt)})</para>
+                       <para>    ;reads from the 11th byte to the end of the file (i.e. skips the first 10).</para>
+                       <para>    Set(foo=${FILE(/tmp/test.txt,10)})</para>
+                       <para>    ;reads from the 11th to 20th byte in the file (i.e. skip the first 10, then read 10 bytes).</para>
+                       <para>    Set(foo=${FILE(/tmp/test.txt,10,10)})</para>
+                       <para/>
+                       <para>Read mode (line):</para>
+                       <para>    ; reads the 3rd line of the file.</para>
+                       <para>    Set(foo=${FILE(/tmp/test.txt,3,1,l)})</para>
+                       <para>    ; reads the 3rd and 4th lines of the file.</para>
+                       <para>    Set(foo=${FILE(/tmp/test.txt,3,2,l)})</para>
+                       <para>    ; reads from the third line to the end of the file.</para>
+                       <para>    Set(foo=${FILE(/tmp/test.txt,3,,l)})</para>
+                       <para>    ; reads the last three lines of the file.</para>
+                       <para>    Set(foo=${FILE(/tmp/test.txt,-3,,l)})</para>
+                       <para>    ; reads the 3rd line of a DOS-formatted file.</para>
+                       <para>    Set(foo=${FILE(/tmp/test.txt,3,1,l,d)})</para>
+                       <para/>
+                       <para>Write mode (byte):</para>
+                       <para>    ; truncate the file and write "bar"</para>
+                       <para>    Set(FILE(/tmp/test.txt)=bar)</para>
+                       <para>    ; Append "bar"</para>
+                       <para>    Set(FILE(/tmp/test.txt,,,a)=bar)</para>
+                       <para>    ; Replace the first byte with "bar" (replaces 1 character with 3)</para>
+                       <para>    Set(FILE(/tmp/test.txt,0,1)=bar)</para>
+                       <para>    ; Replace 10 bytes beginning at the 21st byte of the file with "bar"</para>
+                       <para>    Set(FILE(/tmp/test.txt,20,10)=bar)</para>
+                       <para>    ; Replace all bytes from the 21st with "bar"</para>
+                       <para>    Set(FILE(/tmp/test.txt,20)=bar)</para>
+                       <para>    ; Insert "bar" after the 4th character</para>
+                       <para>    Set(FILE(/tmp/test.txt,4,0)=bar)</para>
+                       <para/>
+                       <para>Write mode (line):</para>
+                       <para>    ; Replace the first line of the file with "bar"</para>
+                       <para>    Set(FILE(/tmp/foo.txt,0,1,l)=bar)</para>
+                       <para>    ; Replace the last line of the file with "bar"</para>
+                       <para>    Set(FILE(/tmp/foo.txt,-1,,l)=bar)</para>
+                       <para>    ; Append "bar" to the file with a newline</para>
+                       <para>    Set(FILE(/tmp/foo.txt,,,al)=bar)</para>
+               </description>
+               <see-also>
+                       <ref type="function">FILE_COUNT_LINE</ref>
+                       <ref type="function">FILE_FORMAT</ref>
+               </see-also>
+       </function>
+       <function name="FILE_COUNT_LINE" language="en_US">
+               <synopsis>
+                       Obtains the number of lines of a text file.
+               </synopsis>
+               <syntax>
+                       <parameter name="filename" required="true" />
+                       <parameter name="format">
+                               <para>Format may be one of the following:</para>
+                               <optionlist>
+                                       <option name="u">
+                                               <para>Unix newline format.</para>
+                                       </option>
+                                       <option name="d">
+                                               <para>DOS newline format.</para>
+                                       </option>
+                                       <option name="m">
+                                               <para>Macintosh newline format.</para>
+                                       </option>
+                               </optionlist>
+                               <note><para>If not specified, an attempt will be made to determine the newline format type.</para></note>
+                       </parameter>
+               </syntax>
+               <description>
+                       <para>Returns the number of lines, or <literal>-1</literal> on error.</para>
+               </description>
+               <see-also>
+                       <ref type="function">FILE</ref>
+                       <ref type="function">FILE_FORMAT</ref>
+               </see-also>
+       </function>
+       <function name="FILE_FORMAT" language="en_US">
+               <synopsis>
+                       Return the newline format of a text file.
+               </synopsis>
+               <syntax>
+                       <parameter name="filename" required="true" />
                </syntax>
                <description>
+                       <para>Return the line terminator type:</para>
+                       <para>'u' - Unix "\n" format</para>
+                       <para>'d' - DOS "\r\n" format</para>
+                       <para>'m' - Macintosh "\r" format</para>
+                       <para>'x' - Cannot be determined</para>
                </description>
+               <see-also>
+                       <ref type="function">FILE</ref>
+                       <ref type="function">FILE_COUNT_LINE</ref>
+               </see-also>
        </function>
  ***/
 
 static int env_read(struct ast_channel *chan, const char *cmd, char *data,
-                   char *buf, size_t len)
+                       char *buf, size_t len)
 {
        char *ret = NULL;
 
@@ -105,7 +238,7 @@ static int env_read(struct ast_channel *chan, const char *cmd, char *data,
 }
 
 static int env_write(struct ast_channel *chan, const char *cmd, char *data,
-                    const char *value)
+                        const char *value)
 {
        if (!ast_strlen_zero(data) && strncmp(data, "AST_", 4)) {
                if (!ast_strlen_zero(value)) {
@@ -119,7 +252,7 @@ static int env_write(struct ast_channel *chan, const char *cmd, char *data,
 }
 
 static int stat_read(struct ast_channel *chan, const char *cmd, char *data,
-                    char *buf, size_t len)
+                        char *buf, size_t len)
 {
        char *action;
        struct stat s;
@@ -161,66 +294,874 @@ static int stat_read(struct ast_channel *chan, const char *cmd, char *data,
        return 0;
 }
 
-static int file_read(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
+enum file_format {
+       FF_UNKNOWN = -1,
+       FF_UNIX,
+       FF_DOS,
+       FF_MAC,
+};
+
+static int64_t count_lines(const char *filename, enum file_format newline_format)
+{
+       int count = 0;
+       char fbuf[4096];
+       FILE *ff;
+
+       if (!(ff = fopen(filename, "r"))) {
+               ast_log(LOG_ERROR, "Unable to open '%s': %s\n", filename, strerror(errno));
+               return -1;
+       }
+
+       while (fgets(fbuf, sizeof(fbuf), ff)) {
+               char *next = fbuf, *first_cr = NULL, *first_nl = NULL;
+
+               /* Must do it this way, because if the fileformat is FF_MAC, then Unix
+                * assumptions about line-format will not come into play. */
+               while (next) {
+                       if (newline_format == FF_DOS || newline_format == FF_MAC || newline_format == FF_UNKNOWN) {
+                               first_cr = strchr(next, '\r');
+                       }
+                       if (newline_format == FF_UNIX || newline_format == FF_UNKNOWN) {
+                               first_nl = strchr(next, '\n');
+                       }
+
+                       /* No terminators found in buffer */
+                       if (!first_cr && !first_nl) {
+                               break;
+                       }
+
+                       if (newline_format == FF_UNKNOWN) {
+                               if ((first_cr && !first_nl) || (first_cr && first_cr < first_nl)) {
+                                       if (first_nl && first_nl == first_cr + 1) {
+                                               newline_format = FF_DOS;
+                                       } else if (first_cr && first_cr == &fbuf[sizeof(fbuf) - 2]) {
+                                               /* Get it on the next pass */
+                                               fseek(ff, -1, SEEK_CUR);
+                                               break;
+                                       } else {
+                                               newline_format = FF_MAC;
+                                               first_nl = NULL;
+                                       }
+                               } else {
+                                       newline_format = FF_UNIX;
+                                       first_cr = NULL;
+                               }
+                               /* Jump down into next section */
+                       }
+
+                       if (newline_format == FF_DOS) {
+                               if (first_nl && first_cr && first_nl == first_cr + 1) {
+                                       next = first_nl + 1;
+                                       count++;
+                               } else if (first_cr == &fbuf[sizeof(fbuf) - 2]) {
+                                       /* Get it on the next pass */
+                                       fseek(ff, -1, SEEK_CUR);
+                                       break;
+                               }
+                       } else if (newline_format == FF_MAC) {
+                               if (first_cr) {
+                                       next = first_cr + 1;
+                                       count++;
+                               }
+                       } else if (newline_format == FF_UNIX) {
+                               if (first_nl) {
+                                       next = first_nl + 1;
+                                       count++;
+                               }
+                       }
+               }
+       }
+       fclose(ff);
+
+       return count;
+}
+
+static int file_count_line(struct ast_channel *chan, const char *cmd, char *data, struct ast_str **buf, ssize_t len)
 {
+       enum file_format newline_format = FF_UNKNOWN;
+       int64_t count;
+       AST_DECLARE_APP_ARGS(args,
+               AST_APP_ARG(filename);
+               AST_APP_ARG(format);
+       );
+
+       AST_STANDARD_APP_ARGS(args, data);
+       if (args.argc > 1) {
+               if (tolower(args.format[0]) == 'd') {
+                       newline_format = FF_DOS;
+               } else if (tolower(args.format[0]) == 'm') {
+                       newline_format = FF_MAC;
+               } else if (tolower(args.format[0]) == 'u') {
+                       newline_format = FF_UNIX;
+               }
+       }
+
+       count = count_lines(args.filename, newline_format);
+       ast_str_set(buf, len, "%" PRId64, count);
+       return 0;
+}
+
+#define LINE_COUNTER(cptr, term, counter) \
+       if (*cptr == '\n' && term == FF_UNIX) { \
+               counter++; \
+       } else if (*cptr == '\n' && term == FF_DOS && dos_state == 0) { \
+               dos_state = 1; \
+       } else if (*cptr == '\r' && term == FF_DOS && dos_state == 1) { \
+               dos_state = 0; \
+               counter++; \
+       } else if (*cptr == '\r' && term == FF_MAC) { \
+               counter++; \
+       } else if (term == FF_DOS) { \
+               dos_state = 0; \
+       }
+
+static enum file_format file2format(const char *filename)
+{
+       FILE *ff;
+       char fbuf[4096];
+       char *first_cr, *first_nl;
+       enum file_format newline_format = FF_UNKNOWN;
+
+       if (!(ff = fopen(filename, "r"))) {
+               ast_log(LOG_ERROR, "Cannot open '%s': %s\n", filename, strerror(errno));
+               return -1;
+       }
+
+       while (fgets(fbuf, sizeof(fbuf), ff)) {
+               first_cr = strchr(fbuf, '\r');
+               first_nl = strchr(fbuf, '\n');
+
+               if (!first_cr && !first_nl) {
+                       continue;
+               }
+
+               if ((first_cr && !first_nl) || (first_cr && first_cr < first_nl)) {
+
+                       if (first_nl && first_nl == first_cr + 1) {
+                               newline_format = FF_DOS;
+                       } else if (first_cr && first_cr == &fbuf[sizeof(fbuf) - 2]) {
+                               /* Edge case: get it on the next pass */
+                               fseek(ff, -1, SEEK_CUR);
+                               continue;
+                       } else {
+                               newline_format = FF_MAC;
+                       }
+               } else {
+                       newline_format = FF_UNIX;
+               }
+               break;
+       }
+       fclose(ff);
+       return newline_format;
+}
+
+static int file_format(struct ast_channel *chan, const char *cmd, char *data, struct ast_str **buf, ssize_t len)
+{
+       enum file_format newline_format = file2format(data);
+       ast_str_set(buf, len, "%c", newline_format == FF_UNIX ? 'u' : newline_format == FF_DOS ? 'd' : newline_format == FF_MAC ? 'm' : 'x');
+       return 0;
+}
+
+static int file_read(struct ast_channel *chan, const char *cmd, char *data, struct ast_str **buf, ssize_t len)
+{
+       FILE *ff;
+       int64_t offset = 0, length = LLONG_MAX;
+       enum file_format format = FF_UNKNOWN;
+       char fbuf[4096];
+       int64_t flength, i; /* iterator needs to be signed, so it can go negative and terminate the loop */
+       int64_t offset_offset = -1, length_offset = -1;
+       char dos_state = 0;
+       size_t readlen;
        AST_DECLARE_APP_ARGS(args,
                AST_APP_ARG(filename);
                AST_APP_ARG(offset);
                AST_APP_ARG(length);
+               AST_APP_ARG(options);
+               AST_APP_ARG(fileformat);
        );
-       int offset = 0, length, res = 0;
-       char *contents;
-       size_t contents_len;
 
        AST_STANDARD_APP_ARGS(args, data);
+
        if (args.argc > 1) {
-               offset = atoi(args.offset);
+               sscanf(args.offset, "%" SCNd64, &offset);
        }
-
        if (args.argc > 2) {
-               /* The +1/-1 in this code section is to accomodate for the terminating NULL. */
-               if ((length = atoi(args.length) + 1) > len) {
-                       ast_log(LOG_WARNING, "Length %d is greater than the max (%d).  Truncating output.\n", length - 1, (int)len - 1);
-                       length = len;
+               sscanf(args.length, "%" SCNd64, &length);
+       }
+
+       if (args.argc < 4 || !strchr(args.options, 'l')) {
+               /* Character-based mode */
+               off_t off_i;
+
+               if (!(ff = fopen(args.filename, "r"))) {
+                       ast_log(LOG_WARNING, "Cannot open file '%s' for reading: %s\n", args.filename, strerror(errno));
+                       return 0;
                }
-       } else {
-               length = len;
+
+               fseeko(ff, 0, SEEK_END);
+               flength = ftello(ff);
+
+               if (offset < 0) {
+                       fseeko(ff, offset, SEEK_END);
+                       offset = ftello(ff);
+               }
+               if (length < 0) {
+                       fseeko(ff, length, SEEK_END);
+                       if ((length = ftello(ff)) - offset < 0) {
+                               /* Eliminates all results */
+                               return -1;
+                       }
+               } else if (length == LLONG_MAX) {
+                       fseeko(ff, 0, SEEK_END);
+                       length = ftello(ff);
+               }
+
+               ast_str_reset(*buf);
+
+               fseeko(ff, offset, SEEK_SET);
+               for (off_i = ftello(ff); off_i < flength && off_i < offset + length; off_i += sizeof(fbuf)) {
+                       /* Calculate if we need to retrieve just a portion of the file in memory */
+                       size_t toappend = sizeof(fbuf);
+
+                       if (fread(fbuf, 1, sizeof(fbuf), ff) < sizeof(fbuf) && !feof(ff)) {
+                               ast_log(LOG_ERROR, "Short read?!!\n");
+                               break;
+                       }
+
+                       /* Don't go past the length requested */
+                       if (off_i + toappend > offset + length) {
+                               toappend = length - off_i;
+                       }
+
+                       ast_str_append_substr(buf, len, fbuf, toappend);
+               }
+               return 0;
        }
 
-       if (!(contents = ast_read_textfile(args.filename))) {
+       /* Line-based read */
+       if (args.argc == 5) {
+               if (tolower(args.fileformat[0]) == 'd') {
+                       format = FF_DOS;
+               } else if (tolower(args.fileformat[0]) == 'm') {
+                       format = FF_MAC;
+               } else if (tolower(args.fileformat[0]) == 'u') {
+                       format = FF_UNIX;
+               }
+       }
+
+       if (format == FF_UNKNOWN) {
+               if ((format = file2format(args.filename)) == FF_UNKNOWN) {
+                       ast_log(LOG_WARNING, "'%s' is not a line-based file\n", args.filename);
+                       return -1;
+               }
+       }
+
+       if (offset < 0 && length <= offset) {
+               /* Length eliminates all content */
                return -1;
+       } else if (offset == 0) {
+               offset_offset = 0;
        }
 
-       do {
-               contents_len = strlen(contents);
-               if (offset > contents_len) {
-                       res = -1;
-                       break;
+       if (!(ff = fopen(args.filename, "r"))) {
+               ast_log(LOG_ERROR, "Cannot open '%s': %s\n", args.filename, strerror(errno));
+               return -1;
+       }
+
+       if (fseek(ff, 0, SEEK_END)) {
+               ast_log(LOG_ERROR, "Cannot seek to end of file '%s': %s\n", args.filename, strerror(errno));
+               fclose(ff);
+               return -1;
+       }
+       flength = ftello(ff);
+
+       if (length == LLONG_MAX) {
+               length_offset = flength;
+       }
+
+       /* For negative offset and/or negative length */
+       if (offset < 0 || length < 0) {
+               int64_t count = 0;
+               /* Start with an even multiple of fbuf, so at the end of reading with a
+                * 0 offset, we don't try to go past the beginning of the file. */
+               for (i = (flength / sizeof(fbuf)) * sizeof(fbuf); i >= 0; i -= sizeof(fbuf)) {
+                       size_t end;
+                       char *pos;
+                       if (fseeko(ff, i, SEEK_SET)) {
+                               ast_log(LOG_ERROR, "Cannot seek to offset %" PRId64 ": %s\n", i, strerror(errno));
+                       }
+                       end = fread(fbuf, 1, sizeof(fbuf), ff);
+                       for (pos = end < sizeof(fbuf) ? fbuf + end - 1 : fbuf + sizeof(fbuf) - 1; pos > fbuf - 1; pos--) {
+                               LINE_COUNTER(pos, format, count);
+
+                               if (length < 0 && count * -1 == length) {
+                                       length_offset = i + (pos - fbuf);
+                               } else if (offset < 0 && count * -1 == (offset - 1)) {
+                                       /* Found our initial offset.  We're done with reverse motion! */
+                                       if (format == FF_DOS) {
+                                               offset_offset = i + (pos - fbuf) + 2;
+                                       } else {
+                                               offset_offset = i + (pos - fbuf) + 1;
+                                       }
+                                       break;
+                               }
+                       }
+                       if ((offset < 0 && offset_offset >= 0) || (offset >= 0 && length_offset >= 0)) {
+                               break;
+                       }
                }
+               /* We're at the beginning, and the negative offset indicates the exact number of lines in the file */
+               if (offset < 0 && offset_offset < 0 && offset == count * -1) {
+                       offset_offset = 0;
+               }
+       }
 
-               if (offset >= 0) {
-                       if (length < 0) {
-                               if (contents_len - offset + length < 0) {
-                                       /* Nothing left after trimming */
-                                       res = -1;
+       /* Positve line offset */
+       if (offset > 0) {
+               int64_t count = 0;
+               fseek(ff, 0, SEEK_SET);
+               for (i = 0; i < flength; i += sizeof(fbuf)) {
+                       char *pos;
+                       if (i + sizeof(fbuf) <= flength) {
+                               /* Don't let previous values influence current counts, due to short reads */
+                               memset(fbuf, 0, sizeof(fbuf));
+                       }
+                       if (fread(fbuf, 1, sizeof(fbuf), ff) && !feof(ff)) {
+                               ast_log(LOG_ERROR, "Short read?!!\n");
+                               fclose(ff);
+                               return -1;
+                       }
+                       for (pos = fbuf; pos < fbuf + sizeof(fbuf); pos++) {
+                               LINE_COUNTER(pos, format, count);
+
+                               if (count == offset) {
+                                       offset_offset = i + (pos - fbuf) + 1;
                                        break;
                                }
-                               ast_copy_string(buf, &contents[offset], contents_len + length);
-                       } else {
-                               ast_copy_string(buf, &contents[offset], length);
+                       }
+                       if (offset_offset >= 0) {
+                               break;
+                       }
+               }
+       }
+
+       if (offset_offset < 0) {
+               ast_log(LOG_ERROR, "Offset '%s' refers to before the beginning of the file!\n", args.offset);
+               fclose(ff);
+               return -1;
+       }
+
+       ast_str_reset(*buf);
+       if (fseeko(ff, offset_offset, SEEK_SET)) {
+               ast_log(LOG_ERROR, "fseeko failed: %s\n", strerror(errno));
+       }
+
+       /* If we have both offset_offset and length_offset, then grabbing the
+        * buffer is simply a matter of just retrieving the file and adding it
+        * to buf.  Otherwise, we need to run byte-by-byte forward until the
+        * length is complete. */
+       if (length_offset >= 0) {
+               ast_debug(3, "offset=%" PRId64 ", length=%" PRId64 ", offset_offset=%" PRId64 ", length_offset=%" PRId64 "\n", offset, length, offset_offset, length_offset);
+               for (i = offset_offset; i < length_offset; i += sizeof(fbuf)) {
+                       if (fread(fbuf, 1, i + sizeof(fbuf) > flength ? flength - i : sizeof(fbuf), ff) < (i + sizeof(fbuf) > flength ? flength - i : sizeof(fbuf))) {
+                               ast_log(LOG_ERROR, "Short read?!!\n");
+                       }
+                       ast_debug(3, "Appending first %" PRId64" bytes of fbuf=%s\n", i + sizeof(fbuf) > length_offset ? length_offset - i : sizeof(fbuf), fbuf);
+                       ast_str_append_substr(buf, len, fbuf, i + sizeof(fbuf) > length_offset ? length_offset - i : sizeof(fbuf));
+               }
+       } else if (length == 0) {
+               /* Nothing to do */
+       } else {
+               /* Positive line offset */
+               int64_t current_length = 0;
+               char dos_state = 0;
+               ast_debug(3, "offset=%" PRId64 ", length=%" PRId64 ", offset_offset=%" PRId64 ", length_offset=%" PRId64 "\n", offset, length, offset_offset, length_offset);
+               for (i = offset_offset; i < flength; i += sizeof(fbuf)) {
+                       char *pos;
+                       if ((readlen = fread(fbuf, 1, sizeof(fbuf), ff)) < sizeof(fbuf) && !feof(ff)) {
+                               ast_log(LOG_ERROR, "Short read?!!\n");
+                       }
+                       for (pos = fbuf; pos < fbuf + sizeof(fbuf); pos++) {
+                               LINE_COUNTER(pos, format, current_length);
+
+                               if (current_length == length) {
+                                       length_offset = i + (pos - fbuf) + 1;
+                                       break;
+                               }
+                       }
+                       ast_debug(3, "length_offset=%" PRId64 ", length_offset - i=%" PRId64 "\n", length_offset, length_offset - i);
+                       ast_str_append_substr(buf, len, fbuf, length_offset >= 0 ? length_offset - i : flength > i + sizeof(fbuf)) ? sizeof(fbuf) : flength - i;
+
+                       if (length_offset >= 0) {
+                               break;
+                       }
+               }
+       }
+
+       return 0;
+}
+
+const char *format2term(enum file_format f) __attribute__((const));
+const char *format2term(enum file_format f)
+{
+       const char *term[] = { "", "\n", "\r\n", "\r" };
+       return term[f + 1];
+}
+
+static int file_write(struct ast_channel *chan, const char *cmd, char *data, const char *value)
+{
+       AST_DECLARE_APP_ARGS(args,
+               AST_APP_ARG(filename);
+               AST_APP_ARG(offset);
+               AST_APP_ARG(length);
+               AST_APP_ARG(options);
+               AST_APP_ARG(format);
+       );
+       int64_t offset = 0, length = LLONG_MAX;
+       off_t flength, vlength;
+       size_t foplen;
+       FILE *ff;
+
+       AST_STANDARD_APP_ARGS(args, data);
+
+       if (args.argc > 1) {
+               sscanf(args.offset, "%" SCNd64, &offset);
+       }
+       if (args.argc > 2) {
+               sscanf(args.length, "%" SCNd64, &length);
+       }
+
+       vlength = strlen(value);
+
+       if (args.argc < 4 || !strchr(args.options, 'l')) {
+               /* Character-based mode */
+
+               if (args.argc > 3 && strchr(args.options, 'a')) {
+                       /* Append mode */
+                       if (!(ff = fopen(args.filename, "a"))) {
+                               ast_log(LOG_WARNING, "Cannot open file '%s' for appending: %s\n", args.filename, strerror(errno));
+                               return 0;
+                       }
+                       if (fwrite(value, 1, vlength, ff) < vlength) {
+                               ast_log(LOG_ERROR, "Short write?!!\n");
+                       }
+                       fclose(ff);
+                       return 0;
+               } else if (offset == 0 && length == LLONG_MAX) {
+                       if (!(ff = fopen(args.filename, "w"))) {
+                               ast_log(LOG_WARNING, "Cannot open file '%s' for writing: %s\n", args.filename, strerror(errno));
+                               return 0;
+                       }
+                       if (fwrite(value, 1, vlength, ff) < vlength) {
+                               ast_log(LOG_ERROR, "Short write?!!\n");
+                       }
+                       fclose(ff);
+                       return 0;
+               }
+
+               if (!(ff = fopen(args.filename, "r+"))) {
+                       ast_log(LOG_WARNING, "Cannot open file '%s' for modification: %s\n", args.filename, strerror(errno));
+                       return 0;
+               }
+               fseeko(ff, 0, SEEK_END);
+               flength = ftello(ff);
+
+               if (offset < 0) {
+                       if (fseeko(ff, offset, SEEK_END)) {
+                               ast_log(LOG_ERROR, "Cannot seek to offset: %s\n", strerror(errno));
+                       }
+                       offset = ftello(ff);
+               }
+
+               if (length < 0) {
+                       length = flength - offset + length;
+                       if (length < 0) {
+                               ast_log(LOG_ERROR, "Length '%s' exceeds the file length.  No data will be written.\n", args.length);
+                               fclose(ff);
+                               return -1;
+                       }
+               }
+
+               fseeko(ff, offset, SEEK_SET);
+
+               ast_debug(3, "offset=%s/%" PRId64 ", length=%s/%" PRId64 ", vlength=%" PRId64 ", flength=%" PRId64 "\n",
+                       args.offset, offset, args.length, length, vlength, flength);
+
+               if (length == vlength) {
+                       /* Simplest case, a straight replace */
+                       if (fwrite(value, 1, vlength, ff) < vlength) {
+                               ast_log(LOG_ERROR, "Short write?!!\n");
+                       }
+                       fclose(ff);
+               } else if (length == LLONG_MAX) {
+                       /* Simple truncation */
+                       if (fwrite(value, 1, vlength, ff) < vlength) {
+                               ast_log(LOG_ERROR, "Short write?!!\n");
+                       }
+                       fclose(ff);
+                       if (truncate(args.filename, offset + vlength)) {
+                               ast_log(LOG_ERROR, "Unable to truncate the file: %s\n", strerror(errno));
+                       }
+               } else if (length > vlength) {
+                       /* More complex -- need to close a gap */
+                       char fbuf[4096];
+                       off_t cur;
+                       if (fwrite(value, 1, vlength, ff) < vlength) {
+                               ast_log(LOG_ERROR, "Short write?!!\n");
+                       }
+                       fseeko(ff, length - vlength, SEEK_CUR);
+                       while ((cur = ftello(ff)) < flength) {
+                               if (fread(fbuf, 1, sizeof(fbuf), ff) < sizeof(fbuf) && !feof(ff)) {
+                                       ast_log(LOG_ERROR, "Short read?!!\n");
+                               }
+                               fseeko(ff, cur + vlength - length, SEEK_SET);
+                               if (fwrite(fbuf, 1, sizeof(fbuf), ff) < sizeof(fbuf)) {
+                                       ast_log(LOG_ERROR, "Short write?!!\n");
+                               }
+                       }
+                       fclose(ff);
+                       if (truncate(args.filename, flength - (length - vlength))) {
+                               ast_log(LOG_ERROR, "Unable to truncate the file: %s\n", strerror(errno));
                        }
                } else {
-                       if (offset * -1 > contents_len) {
-                               ast_log(LOG_WARNING, "Offset is larger than the file size.\n");
-                               offset = contents_len * -1;
+                       /* Most complex -- need to open a gap */
+                       char fbuf[4096];
+                       off_t lastwritten = flength + vlength - length;
+
+                       /* Start reading exactly the buffer size back from the end. */
+                       fseeko(ff, flength - sizeof(fbuf), SEEK_SET);
+                       while (offset < ftello(ff)) {
+                               if (fread(fbuf, 1, sizeof(fbuf), ff) < sizeof(fbuf)) {
+                                       ast_log(LOG_ERROR, "Short read?!!\n");
+                                       fclose(ff);
+                                       return -1;
+                               }
+                               /* Since the read moved our file ptr forward, we reverse, but
+                                * seek an offset equal to the amount we want to extend the
+                                * file by */
+                               fseeko(ff, vlength - length - sizeof(fbuf), SEEK_CUR);
+
+                               /* Note the location of this buffer -- we must not overwrite this position. */
+                               lastwritten = ftello(ff);
+
+                               if (fwrite(fbuf, 1, sizeof(fbuf), ff) < sizeof(fbuf)) {
+                                       ast_log(LOG_ERROR, "Short write?!!\n");
+                                       fclose(ff);
+                                       return -1;
+                               }
+
+                               if (lastwritten < offset + sizeof(fbuf)) {
+                                       break;
+                               }
+                               /* Our file pointer is now either pointing to the end of the
+                                * file (new position) or a multiple of the fbuf size back from
+                                * that point.  Move back to where we want to start reading
+                                * again.  We never actually try to read beyond the end of the
+                                * file, so we don't have do deal with short reads, as we would
+                                * when we're shortening the file. */
+                               fseeko(ff, 2 * sizeof(fbuf) + vlength - length, SEEK_CUR);
+                       }
+
+                       /* Last part of the file that we need to preserve */
+                       if (fseeko(ff, offset + length, SEEK_SET)) {
+                               ast_log(LOG_WARNING, "Unable to seek to %" PRId64 " + %" PRId64 " != %" PRId64 "?)\n", offset, length, ftello(ff));
+                       }
+
+                       /* Doesn't matter how much we read -- just need to restrict the write */
+                       ast_debug(1, "Reading at %" PRId64 "\n", ftello(ff));
+                       if (fread(fbuf, 1, sizeof(fbuf), ff) < sizeof(fbuf) && !feof(ff)) {
+                               ast_log(LOG_ERROR, "Short read?!!\n");
+                       }
+                       fseek(ff, offset, SEEK_SET);
+                       /* Write out the value, then write just up until where we last moved some data */
+                       if (fwrite(value, 1, vlength, ff) < vlength) {
+                               ast_log(LOG_ERROR, "Short write?!!\n");
+                       } else if (fwrite(fbuf, 1, (foplen = lastwritten - ftello(ff)), ff) < foplen) {
+                               ast_log(LOG_ERROR, "Short write?!!\n");
                        }
-                       ast_copy_string(buf, &contents[contents_len + offset], length);
+                       fclose(ff);
                }
-       } while (0);
+       } else {
+               enum file_format newline_format = FF_UNKNOWN;
 
-       ast_free(contents);
+               /* Line mode */
+               if (args.argc == 5) {
+                       if (tolower(args.format[0]) == 'u') {
+                               newline_format = FF_UNIX;
+                       } else if (tolower(args.format[0]) == 'm') {
+                               newline_format = FF_MAC;
+                       } else if (tolower(args.format[0]) == 'd') {
+                               newline_format = FF_DOS;
+                       }
+               }
+               if (newline_format == FF_UNKNOWN && (newline_format = file2format(args.filename)) == FF_UNKNOWN) {
+                       ast_log(LOG_ERROR, "File '%s' not in line format\n", args.filename);
+                       return -1;
+               }
 
-       return res;
+               if (strchr(args.options, 'a')) {
+                       /* Append to file */
+                       if (!(ff = fopen(args.filename, "a"))) {
+                               ast_log(LOG_ERROR, "Unable to open '%s' for appending: %s\n", args.filename, strerror(errno));
+                               return -1;
+                       }
+                       if (fwrite(value, 1, vlength, ff) < vlength) {
+                               ast_log(LOG_ERROR, "Short write?!!\n");
+                       } else if (!strchr(args.options, 'd') && fwrite(format2term(newline_format), 1, strlen(format2term(newline_format)), ff) < strlen(format2term(newline_format))) {
+                               ast_log(LOG_ERROR, "Short write?!!\n");
+                       }
+                       fclose(ff);
+               } else if (offset == 0 && length == LLONG_MAX) {
+                       /* Overwrite file */
+                       off_t truncsize;
+                       if (!(ff = fopen(args.filename, "w"))) {
+                               ast_log(LOG_ERROR, "Unable to open '%s' for writing: %s\n", args.filename, strerror(errno));
+                               return -1;
+                       }
+                       if (fwrite(value, 1, vlength, ff) < vlength) {
+                               ast_log(LOG_ERROR, "Short write?!!\n");
+                       } else if (!strchr(args.options, 'd') && fwrite(format2term(newline_format), 1, strlen(format2term(newline_format)), ff) < strlen(format2term(newline_format))) {
+                               ast_log(LOG_ERROR, "Short write?!!\n");
+                       }
+                       truncsize = ftello(ff);
+                       fclose(ff);
+                       if (truncate(args.filename, truncsize)) {
+                               ast_log(LOG_ERROR, "Unable to truncate file: %s\n", strerror(errno));
+                       }
+               } else {
+                       int64_t offset_offset = (offset == 0 ? 0 : -1), length_offset = -1, flength, i, current_length = 0;
+                       char dos_state = 0, fbuf[4096];
+
+                       if (offset < 0 && length < offset) {
+                               /* Nonsense! */
+                               ast_log(LOG_ERROR, "Length cannot specify a position prior to the offset\n");
+                               return -1;
+                       }
+
+                       if (!(ff = fopen(args.filename, "r+"))) {
+                               ast_log(LOG_ERROR, "Cannot open '%s' for modification: %s\n", args.filename, strerror(errno));
+                               return -1;
+                       }
+
+                       if (fseek(ff, 0, SEEK_END)) {
+                               ast_log(LOG_ERROR, "Cannot seek to end of file '%s': %s\n", args.filename, strerror(errno));
+                               fclose(ff);
+                               return -1;
+                       }
+                       flength = ftello(ff);
+
+                       /* For negative offset and/or negative length */
+                       if (offset < 0 || length < 0) {
+                               int64_t count = 0;
+                               for (i = (flength / sizeof(fbuf)) * sizeof(fbuf); i >= 0; i -= sizeof(fbuf)) {
+                                       char *pos;
+                                       if (fseeko(ff, i, SEEK_SET)) {
+                                               ast_log(LOG_ERROR, "Cannot seek to offset %" PRId64 ": %s\n", i, strerror(errno));
+                                       }
+                                       if (i + sizeof(fbuf) >= flength) {
+                                               memset(fbuf, 0, sizeof(fbuf));
+                                       }
+                                       if (fread(fbuf, 1, sizeof(fbuf), ff) < sizeof(fbuf) && !feof(ff)) {
+                                               ast_log(LOG_ERROR, "Short read: %s\n", strerror(errno));
+                                               fclose(ff);
+                                               return -1;
+                                       }
+                                       for (pos = fbuf + sizeof(fbuf) - 1; pos > fbuf - 1; pos--) {
+                                               LINE_COUNTER(pos, newline_format, count);
+
+                                               if (length < 0 && count * -1 == length) {
+                                                       length_offset = i + (pos - fbuf);
+                                               } else if (offset < 0 && count * -1 == (offset - 1)) {
+                                                       /* Found our initial offset.  We're done with reverse motion! */
+                                                       if (newline_format == FF_DOS) {
+                                                               offset_offset = i + (pos - fbuf) + 2;
+                                                       } else {
+                                                               offset_offset = i + (pos - fbuf) + 1;
+                                                       }
+                                                       break;
+                                               }
+                                       }
+                                       if ((offset < 0 && offset_offset >= 0) || (offset >= 0 && length_offset >= 0)) {
+                                               break;
+                                       }
+                               }
+                               /* We're at the beginning, and the negative offset indicates the exact number of lines in the file */
+                               if (offset < 0 && offset_offset < 0 && offset == count * -1) {
+                                       offset_offset = 0;
+                               }
+                       }
+
+                       /* Positve line offset */
+                       if (offset > 0) {
+                               int64_t count = 0;
+                               fseek(ff, 0, SEEK_SET);
+                               for (i = 0; i < flength; i += sizeof(fbuf)) {
+                                       char *pos;
+                                       if (i + sizeof(fbuf) >= flength) {
+                                               memset(fbuf, 0, sizeof(fbuf));
+                                       }
+                                       if (fread(fbuf, 1, sizeof(fbuf), ff) < sizeof(fbuf) && !feof(ff)) {
+                                               ast_log(LOG_ERROR, "Short read?!!\n");
+                                               fclose(ff);
+                                               return -1;
+                                       }
+                                       for (pos = fbuf; pos < fbuf + sizeof(fbuf); pos++) {
+                                               LINE_COUNTER(pos, newline_format, count);
+
+                                               if (count == offset) {
+                                                       offset_offset = i + (pos - fbuf) + 1;
+                                                       break;
+                                               }
+                                       }
+                                       if (offset_offset >= 0) {
+                                               break;
+                                       }
+                               }
+                       }
+
+                       if (offset_offset < 0) {
+                               ast_log(LOG_ERROR, "Offset '%s' refers to before the beginning of the file!\n", args.offset);
+                               fclose(ff);
+                               return -1;
+                       }
+
+                       if (length == 0) {
+                               length_offset = offset_offset;
+                       } else if (length == LLONG_MAX) {
+                               length_offset = flength;
+                       }
+
+                       /* Positive line length */
+                       if (length_offset < 0) {
+                               fseeko(ff, offset_offset, SEEK_SET);
+                               for (i = offset_offset; i < flength; i += sizeof(fbuf)) {
+                                       char *pos;
+                                       if (i + sizeof(fbuf) >= flength) {
+                                               memset(fbuf, 0, sizeof(fbuf));
+                                       }
+                                       if (fread(fbuf, 1, sizeof(fbuf), ff) < sizeof(fbuf) && !feof(ff)) {
+                                               ast_log(LOG_ERROR, "Short read?!!\n");
+                                               fclose(ff);
+                                               return -1;
+                                       }
+                                       for (pos = fbuf; pos < fbuf + sizeof(fbuf); pos++) {
+                                               LINE_COUNTER(pos, newline_format, current_length);
+
+                                               if (current_length == length) {
+                                                       length_offset = i + (pos - fbuf) + 1;
+                                                       break;
+                                               }
+                                       }
+                                       if (length_offset >= 0) {
+                                               break;
+                                       }
+                               }
+                               if (length_offset < 0) {
+                                       /* Exceeds length of file */
+                                       ast_debug(3, "Exceeds length of file? length=%" PRId64 ", count=%" PRId64 ", flength=%" PRId64 "\n", length, current_length, flength);
+                                       length_offset = flength;
+                               }
+                       }
+
+                       /* Have offset_offset and length_offset now */
+                       if (length_offset - offset_offset == vlength + (strchr(args.options, 'd') ? 0 : strlen(format2term(newline_format)))) {
+                               /* Simple case - replacement of text inline */
+                               fseeko(ff, offset_offset, SEEK_SET);
+                               if (fwrite(value, 1, vlength, ff) < vlength) {
+                                       ast_log(LOG_ERROR, "Short write?!!\n");
+                               } else if (!strchr(args.options, 'd') && fwrite(format2term(newline_format), 1, strlen(format2term(newline_format)), ff) < strlen(format2term(newline_format))) {
+                                       ast_log(LOG_ERROR, "Short write?!!\n");
+                               }
+                               fclose(ff);
+                       } else if (length_offset - offset_offset > vlength + (strchr(args.options, 'd') ? 0 : strlen(format2term(newline_format)))) {
+                               /* More complex case - need to shorten file */
+                               off_t cur;
+                               int64_t length_length = length_offset - offset_offset;
+                               size_t vlen = vlength + (strchr(args.options, 'd') ? 0 : strlen(format2term(newline_format)));
+
+                               ast_debug(3, "offset=%s/%" PRId64 ", length=%s/%" PRId64 " (%" PRId64 "), vlength=%" PRId64 ", flength=%" PRId64 "\n",
+                                       args.offset, offset_offset, args.length, length_offset, length_length, vlength, flength);
+
+                               fseeko(ff, offset_offset, SEEK_SET);
+                               if (fwrite(value, 1, vlength, ff) < vlength) {
+                                       ast_log(LOG_ERROR, "Short write?!!\n");
+                                       fclose(ff);
+                                       return -1;
+                               } else if (!strchr(args.options, 'd') && fwrite(format2term(newline_format), 1, vlen - vlength, ff) < vlen - vlength) {
+                                       ast_log(LOG_ERROR, "Short write?!!\n");
+                                       fclose(ff);
+                                       return -1;
+                               }
+                               while ((cur = ftello(ff)) < flength) {
+                                       fseeko(ff, length_length - vlen, SEEK_CUR);
+                                       if (fread(fbuf, 1, sizeof(fbuf), ff) < sizeof(fbuf) && !feof(ff)) {
+                                               ast_log(LOG_ERROR, "Short read?!!\n");
+                                               fclose(ff);
+                                               return -1;
+                                       }
+                                       /* Seek to where we last stopped writing */
+                                       fseeko(ff, cur, SEEK_SET);
+                                       if (fwrite(fbuf, 1, sizeof(fbuf), ff) < sizeof(fbuf)) {
+                                               ast_log(LOG_ERROR, "Short write?!!\n");
+                                               fclose(ff);
+                                               return -1;
+                                       }
+                               }
+                               fclose(ff);
+                               if (truncate(args.filename, flength - (length_length - vlen))) {
+                                       ast_log(LOG_ERROR, "Truncation of file failed: %s\n", strerror(errno));
+                               }
+                       } else {
+                               /* Most complex case - need to lengthen file */
+                               size_t vlen = vlength + (strchr(args.options, 'd') ? 0 : strlen(format2term(newline_format)));
+                               int64_t origlen = length_offset - offset_offset;
+                               off_t lastwritten = flength + vlen - origlen;
+
+                               ast_debug(3, "offset=%s/%" PRId64 ", length=%s/%" PRId64 ", vlength=%" PRId64 ", flength=%" PRId64 "\n",
+                                       args.offset, offset_offset, args.length, length_offset, vlength, flength);
+
+                               fseeko(ff, flength - sizeof(fbuf), SEEK_SET);
+                               while (offset_offset + sizeof(fbuf) < ftello(ff)) {
+                                       if (fread(fbuf, 1, sizeof(fbuf), ff) < sizeof(fbuf)) {
+                                               ast_log(LOG_ERROR, "Short read?!!\n");
+                                               fclose(ff);
+                                               return -1;
+                                       }
+                                       fseeko(ff, sizeof(fbuf) - vlen - origlen, SEEK_CUR);
+                                       if (fwrite(fbuf, 1, sizeof(fbuf), ff) < sizeof(fbuf)) {
+                                               ast_log(LOG_ERROR, "Short write?!!\n");
+                                               fclose(ff);
+                                               return -1;
+                                       }
+                                       if ((lastwritten = ftello(ff) - sizeof(fbuf)) < offset_offset + sizeof(fbuf)) {
+                                               break;
+                                       }
+                                       fseeko(ff, 2 * sizeof(fbuf) + vlen - origlen, SEEK_CUR);
+                               }
+                               fseek(ff, length_offset, SEEK_SET);
+                               if (fread(fbuf, 1, sizeof(fbuf), ff) < sizeof(fbuf) && !feof(ff)) {
+                                       ast_log(LOG_ERROR, "Short read?!!\n");
+                                       fclose(ff);
+                                       return -1;
+                               }
+                               fseek(ff, offset_offset, SEEK_SET);
+                               if (fwrite(value, 1, vlength, ff) < vlength) {
+                                       ast_log(LOG_ERROR, "Short write?!!\n");
+                                       fclose(ff);
+                                       return -1;
+                               } else if (!strchr(args.options, 'd') && fwrite(format2term(newline_format), 1, strlen(format2term(newline_format)), ff) < strlen(format2term(newline_format))) {
+                                       ast_log(LOG_ERROR, "Short write?!!\n");
+                                       fclose(ff);
+                                       return -1;
+                               } else if (fwrite(fbuf, 1, (foplen = lastwritten - ftello(ff)), ff) < foplen) {
+                                       ast_log(LOG_ERROR, "Short write?!!\n");
+                               }
+                               fclose(ff);
+                       }
+               }
+       }
+
+       return 0;
 }
 
 static struct ast_custom_function env_function = {
@@ -237,12 +1178,20 @@ static struct ast_custom_function stat_function = {
 
 static struct ast_custom_function file_function = {
        .name = "FILE",
-       .read = file_read
-       /*
-        * Some enterprising programmer could probably add write functionality
-        * to FILE(), although I'm not sure how useful it would be.  Hence why
-        * it's called FILE and not READFILE (like the app was).
-        */
+       .read2 = file_read,
+       .write = file_write,
+};
+
+static struct ast_custom_function file_count_line_function = {
+       .name = "FILE_COUNT_LINE",
+       .read2 = file_count_line,
+       .read_max = 12,
+};
+
+static struct ast_custom_function file_format_function = {
+       .name = "FILE_FORMAT",
+       .read2 = file_format,
+       .read_max = 2,
 };
 
 static int unload_module(void)
@@ -252,6 +1201,8 @@ static int unload_module(void)
        res |= ast_custom_function_unregister(&env_function);
        res |= ast_custom_function_unregister(&stat_function);
        res |= ast_custom_function_unregister(&file_function);
+       res |= ast_custom_function_unregister(&file_count_line_function);
+       res |= ast_custom_function_unregister(&file_format_function);
 
        return res;
 }
@@ -263,6 +1214,8 @@ static int load_module(void)
        res |= ast_custom_function_register(&env_function);
        res |= ast_custom_function_register(&stat_function);
        res |= ast_custom_function_register(&file_function);
+       res |= ast_custom_function_register(&file_count_line_function);
+       res |= ast_custom_function_register(&file_format_function);
 
        return res;
 }
diff --git a/tests/test_func_file.c b/tests/test_func_file.c
new file mode 100644 (file)
index 0000000..8aa315f
--- /dev/null
@@ -0,0 +1,394 @@
+/*
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * Copyright (C) 2010, Digium, Inc.
+ *
+ * Tilghman Lesher <tlesher AT digium DOT com>
+ *
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
+ */
+
+/*!
+ * \file
+ * \brief Function FILE tests
+ *
+ * \author\verbatim Tilghman Lesher <tlesher AT digium DOT com> \endverbatim
+ *
+ * \ingroup tests
+ */
+
+/*** MODULEINFO
+       <depend>TEST_FRAMEWORK</depend>
+ ***/
+
+#include "asterisk.h"
+
+ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
+
+#include "asterisk/utils.h"
+#include "asterisk/app.h"
+#include "asterisk/module.h"
+#include "asterisk/test.h"
+#include "asterisk/pbx.h"
+
+#define C1024 \
+               "1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF"
+
+static struct {
+       const char *contents;
+       const char *args;
+       const char *value;
+} read_tests[] = {
+       /* 4 different ways of specifying the first character */
+       { "123456789", "0,1", "1" },
+       { "123456789", "0,-8", "1" },
+       { "123456789", "-9,1", "1" },
+       { "123456789", "-9,-8", "1" },
+       /* Does 0-length work? */
+       { "123456789", "0,0", "" },
+       { "123456789", "-9,0", "" },
+       { "123456789", "-9,-9", "" },
+       /* Does negative length work? */
+       { "123456789", "5,-6", "" },
+       { "123456789", "-5,-6", "" },
+       /* No length */
+       { "123456789", "-5", "56789" },
+       { "123456789", "4", "56789" },
+       /* Line mode, 4 ways of specifying the first character */
+       { "123\n456\n789\n", "0,1,l", "123\n" },
+       { "123\n456\n789\n", "-3,1,l", "123\n" },
+       { "123\n456\n789\n", "0,-2,l", "123\n" },
+       { "123\n456\n789\n", "-3,-2,l", "123\n" },
+       /* Line mode, 0-length */
+       { "123\n456\n789\n", "0,0,l", "" },
+       { "123\n456\n789\n", "-3,0,l", "" },
+       { "123\n456\n789\n", "-3,-3,l", "" },
+       /* Line mode, negative length */
+       { "123\n456\n789\n", "2,-2,l", "" },
+       { "123\n456\n789\n", "-2,-3,l", "" },
+       /* No length */
+       { "123\n456\n789\n", "1,,l", "456\n789\n" },
+       { "123\n456\n789\n", "-2,,l", "456\n789\n" },
+};
+
+static struct {
+       const char *contents;
+       const char *args;
+       const char *value;
+       const char *contents2;
+} write_tests[] = {
+       /* Single character replace */
+       { "123456789", "0,1", "a", "a23456789" },
+       { "123456789", "-9,1", "a", "a23456789" },
+       { "123456789", "0,-8", "a", "a23456789" },
+       { "123456789", "-9,-8", "a", "a23456789" },
+       { "123456789", "5,1", "b", "12345b789" },
+       { "123456789", "-4,1", "b", "12345b789" },
+       { "123456789", "5,-3", "b", "12345b789" },
+       { "123456789", "-4,-3", "b", "12345b789" },
+       /* Replace 2 characters with 1 */
+       { "123456789", "0,2", "c", "c3456789" },
+       { "123456789", "-9,2", "c", "c3456789" },
+       { "123456789", "0,-7", "c", "c3456789" },
+       { "123456789", "-9,-7", "c", "c3456789" },
+       { "123456789", "4,2", "d", "1234d789" },
+       { "123456789", "-5,2", "d", "1234d789" },
+       { "123456789", "4,-3", "d", "1234d789" },
+       { "123456789", "-5,-3", "d", "1234d789" },
+       /* Truncate file */
+       { "123456789", "5", "e", "12345e" },
+       { "123456789", "5", "", "12345" },
+       { "123456789", "-4", "e", "12345e" },
+       { "123456789", "-4", "", "12345" },
+       /* Replace 1 character with 2 */
+       { "123456789", "0,1", "fg", "fg23456789" },
+       { "123456789", "0,-8", "fg", "fg23456789" },
+       { "123456789", "-9,1", "fg", "fg23456789" },
+       { "123456789", "-9,-8", "fg", "fg23456789" },
+       /* Overwrite file */
+       { "123456789", "", "h", "h" },
+       { "123456789", ",,,", "h", "h" },
+       { "123\n456\n789\n", ",,l", "h", "h\n" },
+       { "123\n456\n789\n", ",,ld", "h", "h" },
+       /* Single line replace, same length */
+       { "123\n456\n789\n", "0,1,l", "abc", "abc\n456\n789\n" },
+       { "123\n456\n789\n", "-3,1,l", "abc", "abc\n456\n789\n" },
+       { "123\n456\n789\n", "0,-2,l", "abc", "abc\n456\n789\n" },
+       { "123\n456\n789\n", "-3,-2,l", "abc", "abc\n456\n789\n" },
+       { "123\n456\n789\n", "1,1,l", "abc", "123\nabc\n789\n" },
+       { "123\n456\n789\n", "1,-1,l", "abc", "123\nabc\n789\n" },
+       { "123\n456\n789\n", "-2,1,l", "abc", "123\nabc\n789\n" },
+       { "123\n456\n789\n", "-2,-1,l", "abc", "123\nabc\n789\n" },
+       /* Single line replace, one character short */
+       { "123\n456\n789\n", "0,1,l", "ab", "ab\n456\n789\n" },
+       { "123\n456\n789\n", "-3,1,l", "ab", "ab\n456\n789\n" },
+       { "123\n456\n789\n", "0,-2,l", "ab", "ab\n456\n789\n" },
+       { "123\n456\n789\n", "-3,-2,l", "ab", "ab\n456\n789\n" },
+       { "123\n456\n789\n", "1,1,l", "ab", "123\nab\n789\n" },
+       { "123\n456\n789\n", "1,-1,l", "ab", "123\nab\n789\n" },
+       { "123\n456\n789\n", "-2,1,l", "ab", "123\nab\n789\n" },
+       { "123\n456\n789\n", "-2,-1,l", "ab", "123\nab\n789\n" },
+       /* Single line replace, one character long */
+       { "123\n456\n789\n", "0,1,l", "abcd", "abcd\n456\n789\n" },
+       { "123\n456\n789\n", "-3,1,l", "abcd", "abcd\n456\n789\n" },
+       { "123\n456\n789\n", "0,-2,l", "abcd", "abcd\n456\n789\n" },
+       { "123\n456\n789\n", "-3,-2,l", "abcd", "abcd\n456\n789\n" },
+       { "123\n456\n789\n", "1,1,l", "abcd", "123\nabcd\n789\n" },
+       { "123\n456\n789\n", "1,-1,l", "abcd", "123\nabcd\n789\n" },
+       { "123\n456\n789\n", "-2,1,l", "abcd", "123\nabcd\n789\n" },
+       { "123\n456\n789\n", "-2,-1,l", "abcd", "123\nabcd\n789\n" },
+       /* Multi-line replace, same number of characters, 2 lines for 1 */
+       { "123\n456\n789\n", "0,2,l", "abcdefg", "abcdefg\n789\n" },
+       { "123\n456\n789\n", "-3,2,l", "abcdefg", "abcdefg\n789\n" },
+       { "123\n456\n789\n", "0,-1,l", "abcdefg", "abcdefg\n789\n" },
+       { "123\n456\n789\n", "-3,-1,l", "abcdefg", "abcdefg\n789\n" },
+       { "123\n456\n789\n", "1,2,l", "abcdefg", "123\nabcdefg\n" },
+       { "123\n456\n789\n", "1,,l", "abcdefg", "123\nabcdefg\n" },
+       { "123\n456\n789\n", "-2,2,l", "abcdefg", "123\nabcdefg\n" },
+       { "123\n456\n789\n", "-2,,l", "abcdefg", "123\nabcdefg\n" },
+       /* Multi-line replace, shorter number of characters, 2 lines for 1 */
+       { "123\n456\n789\n", "0,2,l", "abcd", "abcd\n789\n" },
+       { "123\n456\n789\n", "-3,2,l", "abcd", "abcd\n789\n" },
+       { "123\n456\n789\n", "0,-1,l", "abcd", "abcd\n789\n" },
+       { "123\n456\n789\n", "-3,-1,l", "abcd", "abcd\n789\n" },
+       { "123\n456\n789\n", "1,2,l", "abcd", "123\nabcd\n" },
+       { "123\n456\n789\n", "1,,l", "abcd", "123\nabcd\n" },
+       { "123\n456\n789\n", "-2,2,l", "abcd", "123\nabcd\n" },
+       { "123\n456\n789\n", "-2,,l", "abcd", "123\nabcd\n" },
+       /* Multi-line replace, longer number of characters, 2 lines for 1 */
+       { "123\n456\n789\n", "0,2,l", "abcdefghijklmnop", "abcdefghijklmnop\n789\n" },
+       { "123\n456\n789\n", "-3,2,l", "abcdefghijklmnop", "abcdefghijklmnop\n789\n" },
+       { "123\n456\n789\n", "0,-1,l", "abcdefghijklmnop", "abcdefghijklmnop\n789\n" },
+       { "123\n456\n789\n", "-3,-1,l", "abcdefghijklmnop", "abcdefghijklmnop\n789\n" },
+       { "123\n456\n789\n", "1,2,l", "abcdefghijklmnop", "123\nabcdefghijklmnop\n" },
+       { "123\n456\n789\n", "1,,l", "abcdefghijklmnop", "123\nabcdefghijklmnop\n" },
+       { "123\n456\n789\n", "-2,2,l", "abcdefghijklmnop", "123\nabcdefghijklmnop\n" },
+       { "123\n456\n789\n", "-2,,l", "abcdefghijklmnop", "123\nabcdefghijklmnop\n" },
+       /* Insert line */
+       { "123\n456\n789\n", "0,0,l", "abcd", "abcd\n123\n456\n789\n" },
+       { "123\n456\n789\n", "-3,0,l", "abcd", "abcd\n123\n456\n789\n" },
+       { "123\n456\n789\n", "1,0,l", "abcd", "123\nabcd\n456\n789\n" },
+       { "123\n456\n789\n", "-2,0,l", "abcd", "123\nabcd\n456\n789\n" },
+       { "123\n456\n789\n", "2,0,l", "abcd", "123\n456\nabcd\n789\n" },
+       { "123\n456\n789\n", "-1,0,l", "abcd", "123\n456\nabcd\n789\n" },
+       { "123\n456\n789\n", "3,0,l", "abcd", "123\n456\n789\nabcd\n" },
+       { "123\n456\n789\n", ",,la", "abcd", "123\n456\n789\nabcd\n" },
+       /* Single line, replace with blank line */
+       { "123\n456\n789\n", "0,1,l", "", "\n456\n789\n" },
+       { "123\n456\n789\n", "-3,1,l", "", "\n456\n789\n" },
+       { "123\n456\n789\n", "0,-2,l", "", "\n456\n789\n" },
+       { "123\n456\n789\n", "-3,-2,l", "", "\n456\n789\n" },
+       { "123\n456\n789\n", "1,1,l", "", "123\n\n789\n" },
+       { "123\n456\n789\n", "1,-1,l", "", "123\n\n789\n" },
+       { "123\n456\n789\n", "-2,1,l", "", "123\n\n789\n" },
+       { "123\n456\n789\n", "-2,-1,l", "", "123\n\n789\n" },
+       /* Single line, delete */
+       { "123\n456\n789\n", "0,1,ld", "", "456\n789\n" },
+       { "123\n456\n789\n", "-3,1,ld", "", "456\n789\n" },
+       { "123\n456\n789\n", "0,-2,ld", "", "456\n789\n" },
+       { "123\n456\n789\n", "-3,-2,ld", "", "456\n789\n" },
+       { "123\n456\n789\n", "1,1,ld", "", "123\n789\n" },
+       { "123\n456\n789\n", "1,-1,ld", "", "123\n789\n" },
+       { "123\n456\n789\n", "-2,1,ld", "", "123\n789\n" },
+       { "123\n456\n789\n", "-2,-1,ld", "", "123\n789\n" },
+       /* Really long tests */
+       { "1234567890ABCDEF" C1024 C1024 C1024 C1024 C1024,
+               "0,1", "a",
+               "a234567890ABCDEF" C1024 C1024 C1024 C1024 C1024 },
+       { "1234567890ABCDEF" C1024 C1024 C1024 C1024 C1024,
+               "0,1", "abcd",
+               "abcd234567890ABCDEF" C1024 C1024 C1024 C1024 C1024 },
+       { "1234567890ABCDEF" C1024 C1024 C1024 C1024 C1024,
+               "0,10", "abcd",
+               "abcdABCDEF" C1024 C1024 C1024 C1024 C1024 },
+       { "1" C1024 "\n2" C1024 "\n3" C1024 "\n4" C1024 "\n5" C1024 "\n6" C1024 "\n",
+               "0,1,l", "abcd",
+               "abcd\n2" C1024 "\n3" C1024 "\n4" C1024 "\n5" C1024 "\n6" C1024 "\n" },
+       { "1234\n1" C1024 "\n2" C1024 "\n3" C1024 "\n4" C1024 "\n5" C1024 "\n6" C1024 "\n",
+               "0,1,l", "abcd",
+               "abcd\n1" C1024 "\n2" C1024 "\n3" C1024 "\n4" C1024 "\n5" C1024 "\n6" C1024 "\n" },
+       { "1234\n1" C1024 "\n2" C1024 "\n3" C1024 "\n4" C1024 "\n5" C1024 "\n6" C1024 "\n",
+               "0,1,l", "a",
+               "a\n1" C1024 "\n2" C1024 "\n3" C1024 "\n4" C1024 "\n5" C1024 "\n6" C1024 "\n" },
+};
+
+static char *file2display(struct ast_str **buf, ssize_t len, const char *input)
+{
+       const char *ptr;
+       ast_str_reset(*buf);
+       for (ptr = input; *ptr; ptr++) {
+               if (*ptr == '\n') {
+                       ast_str_append(buf, len, "\\n");
+               } else if (*ptr == '\r') {
+                       ast_str_append(buf, len, "\\r");
+               } else if (*ptr == '\t') {
+                       ast_str_append(buf, len, "\\t");
+               } else if (*ptr < ' ' || *ptr > 125) {
+                       ast_str_append(buf, len, "\\x%hhX", *ptr);
+               } else {
+                       ast_str_append(buf, len, "%c", *ptr);
+               }
+       }
+       return ast_str_buffer(*buf);
+}
+
+AST_TEST_DEFINE(test_func_file)
+{
+       int res = AST_TEST_PASS;
+       int i;
+       char dir[] = "/tmp/test_func_file.XXXXXX";
+       char file[80], expression[256];
+       struct ast_str *buf, *disp[2] = { NULL, NULL };
+       char fbuf[8192];
+       FILE *fh;
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "func_file";
+               info->category = "funcs/func_env";
+               info->summary = "Verify behavior of the FILE() dialplan function";
+               info->description =
+                       "Verifies that the examples of the FILE() dialplan function documentation work as described.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       if (!mkdtemp(dir)) {
+               ast_test_status_update(test, "Cannot create temporary directory: %s\n", strerror(errno));
+               return AST_TEST_FAIL;
+       }
+
+       disp[0] = ast_str_create(16);
+       disp[1] = ast_str_create(16);
+       if (!(buf = ast_str_create(16)) || !disp[0] || !disp[1]) {
+               ast_free(buf);
+               ast_free(disp[0]);
+               ast_free(disp[1]);
+               rmdir(dir);
+               return AST_TEST_FAIL;
+       }
+
+       snprintf(file, sizeof(file), "%s/test.txt", dir);
+
+       for (i = 0; i < ARRAY_LEN(read_tests); i++) {
+               if (!(fh = fopen(file, "w"))) {
+                       ast_test_status_update(test, "Cannot open test file: %s\n", strerror(errno));
+                       ast_free(buf);
+                       ast_free(disp[0]);
+                       ast_free(disp[1]);
+                       unlink(file);
+                       rmdir(dir);
+                       return AST_TEST_FAIL;
+               }
+
+               if (fwrite(read_tests[i].contents, 1, strlen(read_tests[i].contents), fh) < strlen(read_tests[i].contents)) {
+                       ast_test_status_update(test, "Cannot write initial values into test file: %s\n", strerror(errno));
+                       ast_free(buf);
+                       ast_free(disp[0]);
+                       ast_free(disp[1]);
+                       fclose(fh);
+                       unlink(file);
+                       rmdir(dir);
+                       return AST_TEST_FAIL;
+               }
+
+               fclose(fh);
+
+               snprintf(expression, sizeof(expression), "${FILE(%s,%s)}", file, read_tests[i].args);
+               ast_str_substitute_variables(&buf, 0, NULL, expression);
+
+               if (strcmp(ast_str_buffer(buf), read_tests[i].value)) {
+                       ast_test_status_update(test, "Expression '${FILE(...,%s)}' did not produce ('%s') the expected value ('%s')\n",
+                               read_tests[i].args, file2display(&disp[0], 0, ast_str_buffer(buf)), file2display(&disp[1], 0, read_tests[i].value));
+                       res = AST_TEST_FAIL;
+               }
+       }
+
+       ast_free(buf);
+
+       for (i = 0; i < ARRAY_LEN(write_tests); i++) {
+               if (!(fh = fopen(file, "w"))) {
+                       ast_test_status_update(test, "Cannot open test file: %s\n", strerror(errno));
+                       ast_free(disp[0]);
+                       ast_free(disp[1]);
+                       unlink(file);
+                       rmdir(dir);
+                       return AST_TEST_FAIL;
+               }
+
+               if (fwrite(write_tests[i].contents, 1, strlen(write_tests[i].contents), fh) < strlen(write_tests[i].contents)) {
+                       ast_test_status_update(test, "Cannot write initial values into test file: %s\n", strerror(errno));
+                       ast_free(disp[0]);
+                       ast_free(disp[1]);
+                       fclose(fh);
+                       unlink(file);
+                       rmdir(dir);
+                       return AST_TEST_FAIL;
+               }
+
+               fclose(fh);
+
+               snprintf(expression, sizeof(expression), "FILE(%s,%s)", file, write_tests[i].args);
+               ast_func_write(NULL, expression, write_tests[i].value);
+
+               if (!(fh = fopen(file, "r"))) {
+                       ast_test_status_update(test, "Cannot open test file: %s\n", strerror(errno));
+                       ast_free(disp[0]);
+                       ast_free(disp[1]);
+                       unlink(file);
+                       rmdir(dir);
+                       return AST_TEST_FAIL;
+               }
+
+               memset(fbuf, 0, sizeof(fbuf));
+               if (!fread(fbuf, 1, sizeof(fbuf), fh)) {
+                       ast_test_status_update(test, "Cannot read write results from test file: %s\n", strerror(errno));
+                       ast_free(disp[0]);
+                       ast_free(disp[1]);
+                       fclose(fh);
+                       unlink(file);
+                       rmdir(dir);
+                       return AST_TEST_FAIL;
+               }
+
+               fclose(fh);
+
+               if (strcmp(fbuf, write_tests[i].contents2)) {
+                       ast_test_status_update(test, "Expression 'FILE(...,%s)=%s' did not produce ('%s') the expected result ('%s')\n",
+                               write_tests[i].args, write_tests[i].value, file2display(&disp[0], 0, fbuf), file2display(&disp[1], 0, write_tests[i].contents2));
+                       res = AST_TEST_FAIL;
+               } else {
+                       ast_test_status_update(test, "Expression 'FILE(...,%s)=%s'... OK!\n", write_tests[i].args, write_tests[i].value);
+               }
+       }
+
+       ast_free(disp[0]);
+       ast_free(disp[1]);
+       unlink(file);
+       rmdir(dir);
+
+       return res;
+}
+
+static int unload_module(void)
+{
+       AST_TEST_UNREGISTER(test_func_file);
+       return 0;
+}
+
+static int load_module(void)
+{
+       AST_TEST_REGISTER(test_func_file);
+       return AST_MODULE_LOAD_SUCCESS;
+}
+
+AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "FILE() Tests");