diff options
| -rw-r--r-- | CHANGES | 1 | ||||
| -rw-r--r-- | funcs/func_env.c | 1049 | ||||
| -rw-r--r-- | tests/test_func_file.c | 394 |
3 files changed, 1396 insertions, 48 deletions
@@ -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 ------------------ diff --git a/funcs/func_env.c b/funcs/func_env.c index e9ddd4163..f5814aec3 100644 --- a/funcs/func_env.c +++ b/funcs/func_env.c @@ -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 */ @@ -25,13 +25,14 @@ 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 index 000000000..8aa315f72 --- /dev/null +++ b/tests/test_func_file.c @@ -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"); |