00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027 #include "asterisk.h"
00028
00029 ASTERISK_FILE_VERSION(__FILE__, "$Revision: 211528 $")
00030
00031 #include <stdio.h>
00032 #include <stdlib.h>
00033 #include <unistd.h>
00034 #include <string.h>
00035
00036 #include "asterisk/file.h"
00037 #include "asterisk/logger.h"
00038 #include "asterisk/options.h"
00039 #include "asterisk/channel.h"
00040 #include "asterisk/pbx.h"
00041 #include "asterisk/module.h"
00042 #include "asterisk/app.h"
00043
00044
00045 #define MAXRESULT 1024
00046
00047 struct sortable_keys {
00048 char *key;
00049 float value;
00050 };
00051
00052 static int sort_subroutine(const void *arg1, const void *arg2)
00053 {
00054 const struct sortable_keys *one=arg1, *two=arg2;
00055 if (one->value < two->value)
00056 return -1;
00057 else if (one->value == two->value)
00058 return 0;
00059 else
00060 return 1;
00061 }
00062
00063 #define ERROR_NOARG (-1)
00064 #define ERROR_NOMEM (-2)
00065 #define ERROR_USAGE (-3)
00066
00067 static int sort_internal(struct ast_channel *chan, char *data, char *buffer, size_t buflen)
00068 {
00069 char *strings, *ptrkey, *ptrvalue;
00070 int count=1, count2, element_count=0;
00071 struct sortable_keys *sortable_keys;
00072
00073 memset(buffer, 0, buflen);
00074
00075 if (!data)
00076 return ERROR_NOARG;
00077
00078 strings = ast_strdupa(data);
00079
00080 for (ptrkey = strings; *ptrkey; ptrkey++) {
00081 if (*ptrkey == '|')
00082 count++;
00083 }
00084
00085 sortable_keys = alloca(count * sizeof(struct sortable_keys));
00086
00087 memset(sortable_keys, 0, count * sizeof(struct sortable_keys));
00088
00089
00090 count2 = 0;
00091 while ((ptrkey = strsep(&strings, "|"))) {
00092 ptrvalue = strchr(ptrkey, ':');
00093 if (!ptrvalue) {
00094 count--;
00095 continue;
00096 }
00097 *ptrvalue++ = '\0';
00098 sortable_keys[count2].key = ptrkey;
00099 sscanf(ptrvalue, "%30f", &sortable_keys[count2].value);
00100 count2++;
00101 }
00102
00103
00104 qsort(sortable_keys, count, sizeof(struct sortable_keys), sort_subroutine);
00105
00106 for (count2 = 0; count2 < count; count2++) {
00107 int blen = strlen(buffer);
00108 if (element_count++) {
00109 strncat(buffer + blen, ",", buflen - blen - 1);
00110 blen++;
00111 }
00112 strncat(buffer + blen, sortable_keys[count2].key, buflen - blen - 1);
00113 }
00114
00115 return 0;
00116 }
00117
00118 static int cut_internal(struct ast_channel *chan, char *data, char *buffer, size_t buflen)
00119 {
00120 char *parse;
00121 AST_DECLARE_APP_ARGS(args,
00122 AST_APP_ARG(varname);
00123 AST_APP_ARG(delimiter);
00124 AST_APP_ARG(field);
00125 );
00126
00127 memset(buffer, 0, buflen);
00128
00129 parse = ast_strdupa(data);
00130
00131 AST_STANDARD_APP_ARGS(args, parse);
00132
00133
00134 if(args.argc < 3){
00135 return ERROR_NOARG;
00136 } else {
00137 char d, ds[2];
00138 char *tmp = alloca(strlen(args.varname) + 4);
00139 char varvalue[MAXRESULT], *tmp2=varvalue;
00140
00141 if (tmp) {
00142 snprintf(tmp, strlen(args.varname) + 4, "${%s}", args.varname);
00143 memset(varvalue, 0, sizeof(varvalue));
00144 } else {
00145 return ERROR_NOMEM;
00146 }
00147
00148 if (args.delimiter[0] == '\\') {
00149 if (args.delimiter[1] == 'n')
00150 d = '\n';
00151 else if (args.delimiter[1] == 't')
00152 d = '\t';
00153 else if (args.delimiter[1] == 'r')
00154 d = '\r';
00155 else if (args.delimiter[1])
00156 d = args.delimiter[1];
00157 else
00158 d = '-';
00159 } else if (args.delimiter[0])
00160 d = args.delimiter[0];
00161 else
00162 d = '-';
00163
00164
00165 snprintf(ds, sizeof(ds), "%c", d);
00166
00167 pbx_substitute_variables_helper(chan, tmp, tmp2, MAXRESULT - 1);
00168
00169 if (tmp2) {
00170 int curfieldnum = 1, firstfield = 1;
00171 while (tmp2 != NULL && args.field != NULL) {
00172 char *nextgroup = strsep(&(args.field), "&");
00173 int num1 = 0, num2 = MAXRESULT;
00174 char trashchar;
00175
00176 if (sscanf(nextgroup, "%30d-%30d", &num1, &num2) == 2) {
00177
00178 } else if (sscanf(nextgroup, "-%30d", &num2) == 1) {
00179
00180 num1 = 0;
00181 } else if ((sscanf(nextgroup, "%30d%1c", &num1, &trashchar) == 2) && (trashchar == '-')) {
00182
00183 num2 = MAXRESULT;
00184 } else if (sscanf(nextgroup, "%30d", &num1) == 1) {
00185
00186 num2 = num1;
00187 } else {
00188 return ERROR_USAGE;
00189 }
00190
00191
00192 if (num1 > 0) {
00193 while (tmp2 != (char *)NULL + 1 && curfieldnum < num1) {
00194 tmp2 = strchr(tmp2, d) + 1;
00195 curfieldnum++;
00196 }
00197 }
00198
00199
00200 if ((num1 > 0) && (curfieldnum > num1))
00201 ast_log(LOG_WARNING, "We're already past the field you wanted?\n");
00202
00203
00204 if (tmp2 == (char *)NULL + 1)
00205 tmp2 = NULL;
00206
00207
00208 while (tmp2 != NULL && curfieldnum <= num2) {
00209 char *tmp3 = strsep(&tmp2, ds);
00210 int curlen = strlen(buffer);
00211
00212 if (firstfield) {
00213 snprintf(buffer, buflen, "%s", tmp3);
00214 firstfield = 0;
00215 } else {
00216 snprintf(buffer + curlen, buflen - curlen, "%c%s", d, tmp3);
00217 }
00218 curfieldnum++;
00219 }
00220 }
00221 }
00222 }
00223 return 0;
00224 }
00225
00226 static int acf_sort_exec(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len)
00227 {
00228 struct ast_module_user *u;
00229 int ret = -1;
00230
00231 u = ast_module_user_add(chan);
00232
00233 switch (sort_internal(chan, data, buf, len)) {
00234 case ERROR_NOARG:
00235 ast_log(LOG_ERROR, "SORT() requires an argument\n");
00236 break;
00237 case ERROR_NOMEM:
00238 ast_log(LOG_ERROR, "Out of memory\n");
00239 break;
00240 case 0:
00241 ret = 0;
00242 break;
00243 default:
00244 ast_log(LOG_ERROR, "Unknown internal error\n");
00245 }
00246
00247 ast_module_user_remove(u);
00248
00249 return ret;
00250 }
00251
00252 static int acf_cut_exec(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len)
00253 {
00254 int ret = -1;
00255 struct ast_module_user *u = NULL;
00256
00257 if (chan) {
00258 u = ast_module_user_add(chan);
00259 }
00260
00261 switch (cut_internal(chan, data, buf, len)) {
00262 case ERROR_NOARG:
00263 ast_log(LOG_ERROR, "Syntax: CUT(<varname>,<char-delim>,<range-spec>) - missing argument!\n");
00264 break;
00265 case ERROR_NOMEM:
00266 ast_log(LOG_ERROR, "Out of memory\n");
00267 break;
00268 case ERROR_USAGE:
00269 ast_log(LOG_ERROR, "Usage: CUT(<varname>,<char-delim>,<range-spec>)\n");
00270 break;
00271 case 0:
00272 ret = 0;
00273 break;
00274 default:
00275 ast_log(LOG_ERROR, "Unknown internal error\n");
00276 }
00277
00278 if (chan) {
00279 ast_module_user_remove(u);
00280 }
00281
00282 return ret;
00283 }
00284
00285 struct ast_custom_function acf_sort = {
00286 .name = "SORT",
00287 .synopsis = "Sorts a list of key/vals into a list of keys, based upon the vals",
00288 .syntax = "SORT(key1:val1[...][,keyN:valN])",
00289 .desc =
00290 "Takes a comma-separated list of keys and values, each separated by a colon, and returns a\n"
00291 "comma-separated list of the keys, sorted by their values. Values will be evaluated as\n"
00292 "floating-point numbers.\n",
00293 .read = acf_sort_exec,
00294 };
00295
00296 struct ast_custom_function acf_cut = {
00297 .name = "CUT",
00298 .synopsis = "Slices and dices strings, based upon a named delimiter.",
00299 .syntax = "CUT(<varname>,<char-delim>,<range-spec>)",
00300 .desc =
00301 " varname - variable you want cut\n"
00302 " char-delim - defaults to '-'\n"
00303 " range-spec - number of the field you want (1-based offset)\n"
00304 " may also be specified as a range (with -)\n"
00305 " or group of ranges and fields (with &)\n",
00306 .read = acf_cut_exec,
00307 };
00308
00309 static int unload_module(void)
00310 {
00311 int res = 0;
00312
00313 res |= ast_custom_function_unregister(&acf_cut);
00314 res |= ast_custom_function_unregister(&acf_sort);
00315
00316 ast_module_user_hangup_all();
00317
00318 return res;
00319 }
00320
00321 static int load_module(void)
00322 {
00323 int res = 0;
00324
00325 res |= ast_custom_function_register(&acf_cut);
00326 res |= ast_custom_function_register(&acf_sort);
00327
00328 return res;
00329 }
00330
00331 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Cut out information from a string");