funcs/func_cut.c

   1 /*
   2  * Asterisk -- An open source telephony toolkit.
   3  *
   4  * Copyright (c) 2003-2006 Tilghman Lesher.  All rights reserved.
   5  *
   6  * Tilghman Lesher <app_cut__v003@the-tilghman.com>
   7  *
   8  * This code is released by the author with no restrictions on usage.
   9  *
  10  * See http://www.asterisk.org for more information about
  11  * the Asterisk project. Please do not directly contact
  12  * any of the maintainers of this project for assistance;
  13  * the project provides a web site, mailing lists and IRC
  14  * channels for your use.
  15  *
  16  */
  17
  18 /*! \file
  19  *
  20  * \brief CUT function
  21  *
  22  * \author Tilghman Lesher <app_cut__v003@the-tilghman.com>
  23  *
  24  * \ingroup functions
  25  */
  26
  27 #include "asterisk.h"
  28
  29 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
  30
  31 #include "asterisk/file.h"
  32 #include "asterisk/channel.h"
  33 #include "asterisk/pbx.h"
  34 #include "asterisk/module.h"
  35 #include "asterisk/app.h"
  36
  37 /*** DOCUMENTATION
  38         <function name="SORT" language="en_US">
  39                 <synopsis>
  40                         Sorts a list of key/vals into a list of keys, based upon the vals.
  41                 </synopsis>
  42                 <syntax>
  43                         <parameter name="keyval" required="true" argsep=":">
  44                                 <argument name="key1" required="true" />
  45                                 <argument name="val1" required="true" />
  46                         </parameter>
  47                         <parameter name="keyvaln" multiple="true" argsep=":">
  48                                 <argument name="key2" required="true" />
  49                                 <argument name="val2" required="true" />
  50                         </parameter>
  51                 </syntax>
  52                 <description>
  53                         <para>Takes a comma-separated list of keys and values, each separated by a colon, and returns a
  54                         comma-separated list of the keys, sorted by their values.  Values will be evaluated as
  55                         floating-point numbers.</para>
  56                 </description>
  57         </function>
  58         <function name="CUT" language="en_US">
  59                 <synopsis>
  60                         Slices and dices strings, based upon a named delimiter.
  61                 </synopsis>
  62                 <syntax>
  63                         <parameter name="varname" required="true">
  64                                 <para>Variable you want cut</para>
  65                         </parameter>
  66                         <parameter name="char-delim" required="true">
  67                                 <para>Delimiter, defaults to <literal>-</literal></para>
  68                         </parameter>
  69                         <parameter name="range-spec" required="true">
  70                                 <para>Number of the field you want (1-based offset), may also be specified as a range (with <literal>-</literal>)
  71                                 or group of ranges and fields (with <literal>&amp;</literal>)</para>
  72                         </parameter>
  73                 </syntax>
  74                 <description>
  75                         <para>Cut out information from a string (<replaceable>varname</replaceable>), based upon a named delimiter.</para>
  76                 </description>
  77         </function>
  78  ***/
  79
  80 struct sortable_keys {
  81         char *key;
  82         float value;
  83 };
  84
  85 static int sort_subroutine(const void *arg1, const void *arg2)
  86 {
  87         const struct sortable_keys *one=arg1, *two=arg2;
  88         if (one->value < two->value)
  89                 return -1;
  90         else if (one->value == two->value)
  91                 return 0;
  92         else
  93                 return 1;
  94 }
  95
  96 #define ERROR_NOARG     (-1)
  97 #define ERROR_NOMEM     (-2)
  98 #define ERROR_USAGE     (-3)
  99
 100 static int sort_internal(struct ast_channel *chan, char *data, char *buffer, size_t buflen)
 101 {
 102         char *strings, *ptrkey, *ptrvalue;
 103         int count=1, count2, element_count=0;
 104         struct sortable_keys *sortable_keys;
 105
 106         *buffer = '\0';
 107
 108         if (!data)
 109                 return ERROR_NOARG;
 110
 111         strings = ast_strdupa(data);
 112
 113         for (ptrkey = strings; *ptrkey; ptrkey++) {
 114                 if (*ptrkey == ',')
 115                         count++;
 116         }
 117
 118         sortable_keys = alloca(count * sizeof(struct sortable_keys));
 119
 120         memset(sortable_keys, 0, count * sizeof(struct sortable_keys));
 121
 122         /* Parse each into a struct */
 123         count2 = 0;
 124         while ((ptrkey = strsep(&strings, ","))) {
 125                 ptrvalue = strchr(ptrkey, ':');
 126                 if (!ptrvalue) {
 127                         count--;
 128                         continue;
 129                 }
 130                 *ptrvalue++ = '\0';
 131                 sortable_keys[count2].key = ptrkey;
 132                 sscanf(ptrvalue, "%f", &sortable_keys[count2].value);
 133                 count2++;
 134         }
 135
 136         /* Sort the structs */
 137         qsort(sortable_keys, count, sizeof(struct sortable_keys), sort_subroutine);
 138
 139         for (count2 = 0; count2 < count; count2++) {
 140                 int blen = strlen(buffer);
 141                 if (element_count++) {
 142                         strncat(buffer + blen, ",", buflen - blen - 1);
 143                         blen++;
 144                 }
 145                 strncat(buffer + blen, sortable_keys[count2].key, buflen - blen - 1);
 146         }
 147
 148         return 0;
 149 }
 150
 151 static int cut_internal(struct ast_channel *chan, char *data, struct ast_str **buf, ssize_t buflen)
 152 {
 153         char *parse, ds[2], *var_expr;
 154         size_t delim_consumed;
 155         struct ast_str *var_value;
 156         AST_DECLARE_APP_ARGS(args,
 157                 AST_APP_ARG(varname);
 158                 AST_APP_ARG(delimiter);
 159                 AST_APP_ARG(field);
 160         );
 161
 162         parse = ast_strdupa(data);
 163
 164         AST_STANDARD_APP_ARGS(args, parse);
 165
 166         /* Check arguments */
 167         if (args.argc < 3) {
 168                 return ERROR_NOARG;
 169         } else if (!(var_expr = alloca(strlen(args.varname) + 4))) {
 170                 return ERROR_NOMEM;
 171         }
 172
 173         /* Get the value of the variable named in the 1st argument */
 174         snprintf(var_expr, strlen(args.varname) + 4, "${%s}", args.varname);
 175         var_value = ast_str_create(16);
 176         ast_str_substitute_variables(&var_value, 0, chan, var_expr);
 177
 178         /* Copy delimiter from 2nd argument to ds[] possibly decoding backslash escapes */
 179         if (ast_get_encoded_char(args.delimiter, ds, &delim_consumed)) {
 180                 ast_copy_string(ds, "-", sizeof(ds));
 181         }
 182         ds[1] = '\0';
 183
 184         if (ast_str_strlen(var_value)) {
 185                 int curfieldnum = 1;
 186                 char *curfieldptr = ast_str_buffer(var_value);
 187                 int out_field_count = 0;
 188
 189                 while (curfieldptr != NULL && args.field != NULL) {
 190                         char *next_range = strsep(&(args.field), "&");
 191                         int start_field, stop_field;
 192                         char trashchar;
 193
 194                         if (sscanf(next_range, "%d-%d", &start_field, &stop_field) == 2) {
 195                                 /* range with both start and end */
 196                         } else if (sscanf(next_range, "-%d", &stop_field) == 1) {
 197                                 /* range with end only */
 198                                 start_field = 1;
 199                         } else if ((sscanf(next_range, "%d%c", &start_field, &trashchar) == 2) && (trashchar == '-')) {
 200                                 /* range with start only */
 201                                 stop_field = INT_MAX;
 202                         } else if (sscanf(next_range, "%d", &start_field) == 1) {
 203                                 /* single number */
 204                                 stop_field = start_field;
 205                         } else {
 206                                 /* invalid field spec */
 207                                 ast_free(var_value);
 208                                 return ERROR_USAGE;
 209                         }
 210
 211                         /* Get to start, if not there already */
 212                         while (curfieldptr != NULL && curfieldnum < start_field) {
 213                                 strsep(&curfieldptr, ds);
 214                                 curfieldnum++;
 215                         }
 216
 217                         /* Most frequent problem is the expectation of reordering fields */
 218                         if (curfieldnum > start_field) {
 219                                 ast_log(LOG_WARNING, "We're already past the field you wanted?\n");
 220                         }
 221
 222                         /* Output fields until we either run out of fields or stop_field is reached */
 223                         while (curfieldptr != NULL && curfieldnum <= stop_field) {
 224                                 char *field_value = strsep(&curfieldptr, ds);
 225                                 ast_str_append(buf, buflen, "%s%s", out_field_count++ ? ds : "", field_value);
 226                                 curfieldnum++;
 227                         }
 228                 }
 229         }
 230         ast_free(var_value);
 231         return 0;
 232 }
 233
 234 static int acf_sort_exec(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
 235 {
 236         int ret = -1;
 237
 238         switch (sort_internal(chan, data, buf, len)) {
 239         case ERROR_NOARG:
 240                 ast_log(LOG_ERROR, "SORT() requires an argument\n");
 241                 break;
 242         case ERROR_NOMEM:
 243                 ast_log(LOG_ERROR, "Out of memory\n");
 244                 break;
 245         case 0:
 246                 ret = 0;
 247                 break;
 248         default:
 249                 ast_log(LOG_ERROR, "Unknown internal error\n");
 250         }
 251
 252         return ret;
 253 }
 254
 255 static int acf_cut_exec(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
 256 {
 257         int ret = -1;
 258         struct ast_str *str = ast_str_create(16);
 259
 260         switch (cut_internal(chan, data, &str, len)) {
 261         case ERROR_NOARG:
 262                 ast_log(LOG_ERROR, "Syntax: CUT(<varname>,<char-delim>,<range-spec>) - missing argument!\n");
 263                 break;
 264         case ERROR_NOMEM:
 265                 ast_log(LOG_ERROR, "Out of memory\n");
 266                 break;
 267         case ERROR_USAGE:
 268                 ast_log(LOG_ERROR, "Usage: CUT(<varname>,<char-delim>,<range-spec>)\n");
 269                 break;
 270         case 0:
 271                 ret = 0;
 272                 ast_copy_string(buf, ast_str_buffer(str), len);
 273                 break;
 274         default:
 275                 ast_log(LOG_ERROR, "Unknown internal error\n");
 276         }
 277         ast_free(str);
 278         return ret;
 279 }
 280
 281 static int acf_cut_exec2(struct ast_channel *chan, const char *cmd, char *data, struct ast_str **buf, ssize_t len)
 282 {
 283         int ret = -1;
 284
 285         switch (cut_internal(chan, data, buf, len)) {
 286         case ERROR_NOARG:
 287                 ast_log(LOG_ERROR, "Syntax: CUT(<varname>,<char-delim>,<range-spec>) - missing argument!\n");
 288                 break;
 289         case ERROR_NOMEM:
 290                 ast_log(LOG_ERROR, "Out of memory\n");
 291                 break;
 292         case ERROR_USAGE:
 293                 ast_log(LOG_ERROR, "Usage: CUT(<varname>,<char-delim>,<range-spec>)\n");
 294                 break;
 295         case 0:
 296                 ret = 0;
 297                 break;
 298         default:
 299                 ast_log(LOG_ERROR, "Unknown internal error\n");
 300         }
 301
 302         return ret;
 303 }
 304
 305 static struct ast_custom_function acf_sort = {
 306         .name = "SORT",
 307         .read = acf_sort_exec,
 308 };
 309
 310 static struct ast_custom_function acf_cut = {
 311         .name = "CUT",
 312         .read = acf_cut_exec,
 313         .read2 = acf_cut_exec2,
 314 };
 315
 316 static int unload_module(void)
 317 {
 318         int res = 0;
 319
 320         res |= ast_custom_function_unregister(&acf_cut);
 321         res |= ast_custom_function_unregister(&acf_sort);
 322
 323         return res;
 324 }
 325
 326 static int load_module(void)
 327 {
 328         int res = 0;
 329
 330         res |= ast_custom_function_register(&acf_cut);
 331         res |= ast_custom_function_register(&acf_sort);
 332
 333         return res;
 334 }
 335
 336 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Cut out information from a string");