Thu Sep 7 01:03:29 2017

Asterisk developer's documentation


func_cut.c File Reference

CUT function. More...

#include "asterisk.h"
#include "asterisk/file.h"
#include "asterisk/channel.h"
#include "asterisk/pbx.h"
#include "asterisk/module.h"
#include "asterisk/app.h"

Go to the source code of this file.

Data Structures

struct  sortable_keys

Defines

#define ERROR_NOARG   (-1)
#define ERROR_NOMEM   (-2)
#define ERROR_USAGE   (-3)

Functions

static int acf_cut_exec (struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
static int acf_cut_exec2 (struct ast_channel *chan, const char *cmd, char *data, struct ast_str **buf, ssize_t len)
static int acf_sort_exec (struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
 AST_MODULE_INFO_STANDARD (ASTERISK_GPL_KEY,"Cut out information from a string")
static int cut_internal (struct ast_channel *chan, char *data, struct ast_str **buf, ssize_t buflen)
static int load_module (void)
static int sort_internal (struct ast_channel *chan, char *data, char *buffer, size_t buflen)
static int sort_subroutine (const void *arg1, const void *arg2)
static int unload_module (void)

Variables

static struct ast_custom_function acf_cut
static struct ast_custom_function acf_sort

Detailed Description

CUT function.

Author:
Tilghman Lesher <app_cut__v003@the-tilghman.com>

Definition in file func_cut.c.


Define Documentation

#define ERROR_NOARG   (-1)

Definition at line 100 of file func_cut.c.

Referenced by acf_cut_exec(), acf_cut_exec2(), acf_sort_exec(), cut_internal(), and sort_internal().

#define ERROR_NOMEM   (-2)

Definition at line 101 of file func_cut.c.

Referenced by acf_cut_exec(), acf_cut_exec2(), and acf_sort_exec().

#define ERROR_USAGE   (-3)

Definition at line 102 of file func_cut.c.

Referenced by acf_cut_exec(), acf_cut_exec2(), and cut_internal().


Function Documentation

static int acf_cut_exec ( struct ast_channel chan,
const char *  cmd,
char *  data,
char *  buf,
size_t  len 
) [static]

Definition at line 258 of file func_cut.c.

References ast_copy_string(), ast_free, ast_log(), ast_str_buffer(), ast_str_create(), cut_internal(), ERROR_NOARG, ERROR_NOMEM, ERROR_USAGE, LOG_ERROR, and str.

00259 {
00260    int ret = -1;
00261    struct ast_str *str = ast_str_create(16);
00262 
00263    switch (cut_internal(chan, data, &str, len)) {
00264    case ERROR_NOARG:
00265       ast_log(LOG_ERROR, "Syntax: CUT(<varname>,<char-delim>,<range-spec>) - missing argument!\n");
00266       break;
00267    case ERROR_NOMEM:
00268       ast_log(LOG_ERROR, "Out of memory\n");
00269       break;
00270    case ERROR_USAGE:
00271       ast_log(LOG_ERROR, "Usage: CUT(<varname>,<char-delim>,<range-spec>)\n");
00272       break;
00273    case 0:
00274       ret = 0;
00275       ast_copy_string(buf, ast_str_buffer(str), len);
00276       break;
00277    default:
00278       ast_log(LOG_ERROR, "Unknown internal error\n");
00279    }
00280    ast_free(str);
00281    return ret;
00282 }

static int acf_cut_exec2 ( struct ast_channel chan,
const char *  cmd,
char *  data,
struct ast_str **  buf,
ssize_t  len 
) [static]

Definition at line 284 of file func_cut.c.

References ast_log(), cut_internal(), ERROR_NOARG, ERROR_NOMEM, ERROR_USAGE, and LOG_ERROR.

00285 {
00286    int ret = -1;
00287 
00288    switch (cut_internal(chan, data, buf, len)) {
00289    case ERROR_NOARG:
00290       ast_log(LOG_ERROR, "Syntax: CUT(<varname>,<char-delim>,<range-spec>) - missing argument!\n");
00291       break;
00292    case ERROR_NOMEM:
00293       ast_log(LOG_ERROR, "Out of memory\n");
00294       break;
00295    case ERROR_USAGE:
00296       ast_log(LOG_ERROR, "Usage: CUT(<varname>,<char-delim>,<range-spec>)\n");
00297       break;
00298    case 0:
00299       ret = 0;
00300       break;
00301    default:
00302       ast_log(LOG_ERROR, "Unknown internal error\n");
00303    }
00304 
00305    return ret;
00306 }

static int acf_sort_exec ( struct ast_channel chan,
const char *  cmd,
char *  data,
char *  buf,
size_t  len 
) [static]

Definition at line 237 of file func_cut.c.

References ast_log(), ERROR_NOARG, ERROR_NOMEM, LOG_ERROR, and sort_internal().

00238 {
00239    int ret = -1;
00240 
00241    switch (sort_internal(chan, data, buf, len)) {
00242    case ERROR_NOARG:
00243       ast_log(LOG_ERROR, "SORT() requires an argument\n");
00244       break;
00245    case ERROR_NOMEM:
00246       ast_log(LOG_ERROR, "Out of memory\n");
00247       break;
00248    case 0:
00249       ret = 0;
00250       break;
00251    default:
00252       ast_log(LOG_ERROR, "Unknown internal error\n");
00253    }
00254 
00255    return ret;
00256 }

AST_MODULE_INFO_STANDARD ( ASTERISK_GPL_KEY  ,
"Cut out information from a string  
)
static int cut_internal ( struct ast_channel chan,
char *  data,
struct ast_str **  buf,
ssize_t  buflen 
) [static]

Definition at line 155 of file func_cut.c.

References args, ast_alloca, AST_APP_ARG, ast_copy_string(), AST_DECLARE_APP_ARGS, ast_free, ast_get_encoded_char(), ast_log(), AST_STANDARD_APP_ARGS, ast_str_append(), ast_str_buffer(), ast_str_create(), ast_str_strlen(), ast_str_substitute_variables(), ast_strdupa, ERROR_NOARG, ERROR_USAGE, LOG_WARNING, and parse().

Referenced by acf_cut_exec(), and acf_cut_exec2().

00156 {
00157    char *parse, ds[2], *var_expr;
00158    size_t delim_consumed;
00159    struct ast_str *var_value;
00160    AST_DECLARE_APP_ARGS(args,
00161       AST_APP_ARG(varname);
00162       AST_APP_ARG(delimiter);
00163       AST_APP_ARG(field);
00164    );
00165 
00166    parse = ast_strdupa(data);
00167 
00168    AST_STANDARD_APP_ARGS(args, parse);
00169 
00170    /* Check arguments */
00171    if (args.argc < 3) {
00172       return ERROR_NOARG;
00173    }
00174    var_expr = ast_alloca(strlen(args.varname) + 4);
00175 
00176    /* Get the value of the variable named in the 1st argument */
00177    snprintf(var_expr, strlen(args.varname) + 4, "${%s}", args.varname);
00178    var_value = ast_str_create(16);
00179    ast_str_substitute_variables(&var_value, 0, chan, var_expr);
00180 
00181    /* Copy delimiter from 2nd argument to ds[] possibly decoding backslash escapes */
00182    if (ast_get_encoded_char(args.delimiter, ds, &delim_consumed)) {
00183       ast_copy_string(ds, "-", sizeof(ds));
00184    }
00185    ds[1] = '\0';
00186 
00187    if (ast_str_strlen(var_value)) {
00188       int curfieldnum = 1;
00189       char *curfieldptr = ast_str_buffer(var_value);
00190       int out_field_count = 0;
00191 
00192       while (curfieldptr != NULL && args.field != NULL) {
00193          char *next_range = strsep(&(args.field), "&");
00194          int start_field, stop_field;
00195          char trashchar;
00196 
00197          if (sscanf(next_range, "%30d-%30d", &start_field, &stop_field) == 2) {
00198             /* range with both start and end */
00199          } else if (sscanf(next_range, "-%30d", &stop_field) == 1) {
00200             /* range with end only */
00201             start_field = 1;
00202          } else if ((sscanf(next_range, "%30d%1c", &start_field, &trashchar) == 2) && (trashchar == '-')) {
00203             /* range with start only */
00204             stop_field = INT_MAX;
00205          } else if (sscanf(next_range, "%30d", &start_field) == 1) {
00206             /* single number */
00207             stop_field = start_field;
00208          } else {
00209             /* invalid field spec */
00210             ast_free(var_value);
00211             return ERROR_USAGE;
00212          }
00213 
00214          /* Get to start, if not there already */
00215          while (curfieldptr != NULL && curfieldnum < start_field) {
00216             strsep(&curfieldptr, ds);
00217             curfieldnum++;
00218          }
00219 
00220          /* Most frequent problem is the expectation of reordering fields */
00221          if (curfieldnum > start_field) {
00222             ast_log(LOG_WARNING, "We're already past the field you wanted?\n");
00223          }
00224 
00225          /* Output fields until we either run out of fields or stop_field is reached */
00226          while (curfieldptr != NULL && curfieldnum <= stop_field) {
00227             char *field_value = strsep(&curfieldptr, ds);
00228             ast_str_append(buf, buflen, "%s%s", out_field_count++ ? ds : "", field_value);
00229             curfieldnum++;
00230          }
00231       }
00232    }
00233    ast_free(var_value);
00234    return 0;
00235 }

static int load_module ( void   )  [static]

Definition at line 329 of file func_cut.c.

References ast_custom_function_register.

00330 {
00331    int res = 0;
00332 
00333    res |= ast_custom_function_register(&acf_cut);
00334    res |= ast_custom_function_register(&acf_sort);
00335 
00336    return res;
00337 }

static int sort_internal ( struct ast_channel chan,
char *  data,
char *  buffer,
size_t  buflen 
) [static]

Definition at line 104 of file func_cut.c.

References ast_alloca, ast_strdupa, ERROR_NOARG, sortable_keys::key, sort_subroutine(), and value.

Referenced by acf_sort_exec().

00105 {
00106    char *strings, *ptrkey, *ptrvalue;
00107    int count=1, count2, element_count=0;
00108    struct sortable_keys *sortable_keys;
00109 
00110    *buffer = '\0';
00111 
00112    if (!data)
00113       return ERROR_NOARG;
00114 
00115    strings = ast_strdupa(data);
00116 
00117    for (ptrkey = strings; *ptrkey; ptrkey++) {
00118       if (*ptrkey == ',')
00119          count++;
00120    }
00121 
00122    sortable_keys = ast_alloca(count * sizeof(struct sortable_keys));
00123 
00124    memset(sortable_keys, 0, count * sizeof(struct sortable_keys));
00125 
00126    /* Parse each into a struct */
00127    count2 = 0;
00128    while ((ptrkey = strsep(&strings, ","))) {
00129       ptrvalue = strchr(ptrkey, ':');
00130       if (!ptrvalue) {
00131          count--;
00132          continue;
00133       }
00134       *ptrvalue++ = '\0';
00135       sortable_keys[count2].key = ptrkey;
00136       sscanf(ptrvalue, "%30f", &sortable_keys[count2].value);
00137       count2++;
00138    }
00139 
00140    /* Sort the structs */
00141    qsort(sortable_keys, count, sizeof(struct sortable_keys), sort_subroutine);
00142 
00143    for (count2 = 0; count2 < count; count2++) {
00144       int blen = strlen(buffer);
00145       if (element_count++) {
00146          strncat(buffer + blen, ",", buflen - blen - 1);
00147          blen++;
00148       }
00149       strncat(buffer + blen, sortable_keys[count2].key, buflen - blen - 1);
00150    }
00151 
00152    return 0;
00153 }

static int sort_subroutine ( const void *  arg1,
const void *  arg2 
) [static]

Definition at line 89 of file func_cut.c.

References sortable_keys::value.

Referenced by sort_internal().

00090 {
00091    const struct sortable_keys *one=arg1, *two=arg2;
00092    if (one->value < two->value)
00093       return -1;
00094    else if (one->value == two->value)
00095       return 0;
00096    else
00097       return 1;
00098 }

static int unload_module ( void   )  [static]

Definition at line 319 of file func_cut.c.

References ast_custom_function_unregister().

00320 {
00321    int res = 0;
00322 
00323    res |= ast_custom_function_unregister(&acf_cut);
00324    res |= ast_custom_function_unregister(&acf_sort);
00325 
00326    return res;
00327 }


Variable Documentation

struct ast_custom_function acf_cut [static]
Initial value:
 {
   .name = "CUT",
   .read = acf_cut_exec,
   .read2 = acf_cut_exec2,
}

Definition at line 313 of file func_cut.c.

struct ast_custom_function acf_sort [static]
Initial value:
 {
   .name = "SORT",
   .read = acf_sort_exec,
}

Definition at line 308 of file func_cut.c.


Generated on 7 Sep 2017 for Asterisk - The Open Source Telephony Project by  doxygen 1.6.1