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: 40722 $")
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 = index(ptrkey, ':');
00093 if (!ptrvalue) {
00094 count--;
00095 continue;
00096 }
00097 *ptrvalue++ = '\0';
00098 sortable_keys[count2].key = ptrkey;
00099 sscanf(ptrvalue, "%f", &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 d = args.delimiter[0] ? args.delimiter[0] : '-';
00149
00150
00151 snprintf(ds, sizeof(ds), "%c", d);
00152
00153 pbx_substitute_variables_helper(chan, tmp, tmp2, MAXRESULT - 1);
00154
00155 if (tmp2) {
00156 int curfieldnum = 1;
00157 while (tmp2 != NULL && args.field != NULL) {
00158 char *nextgroup = strsep(&(args.field), "&");
00159 int num1 = 0, num2 = MAXRESULT;
00160 char trashchar;
00161
00162 if (sscanf(nextgroup, "%d-%d", &num1, &num2) == 2) {
00163
00164 } else if (sscanf(nextgroup, "-%d", &num2) == 1) {
00165
00166 num1 = 0;
00167 } else if ((sscanf(nextgroup, "%d%c", &num1, &trashchar) == 2) && (trashchar == '-')) {
00168
00169 num2 = MAXRESULT;
00170 } else if (sscanf(nextgroup, "%d", &num1) == 1) {
00171
00172 num2 = num1;
00173 } else {
00174 return ERROR_USAGE;
00175 }
00176
00177
00178 if (num1 > 0) {
00179 while (tmp2 != (char *)NULL + 1 && curfieldnum < num1) {
00180 tmp2 = index(tmp2, d) + 1;
00181 curfieldnum++;
00182 }
00183 }
00184
00185
00186 if ((num1 > 0) && (curfieldnum > num1))
00187 ast_log(LOG_WARNING, "We're already past the field you wanted?\n");
00188
00189
00190 if (tmp2 == (char *)NULL + 1)
00191 tmp2 = NULL;
00192
00193
00194 while (tmp2 != NULL && curfieldnum <= num2) {
00195 char *tmp3 = strsep(&tmp2, ds);
00196 int curlen = strlen(buffer);
00197
00198 if (curlen)
00199 snprintf(buffer + curlen, buflen - curlen, "%c%s", d, tmp3);
00200 else
00201 snprintf(buffer, buflen, "%s", tmp3);
00202
00203 curfieldnum++;
00204 }
00205 }
00206 }
00207 }
00208 return 0;
00209 }
00210
00211 static int acf_sort_exec(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len)
00212 {
00213 struct ast_module_user *u;
00214 int ret = -1;
00215
00216 u = ast_module_user_add(chan);
00217
00218 switch (sort_internal(chan, data, buf, len)) {
00219 case ERROR_NOARG:
00220 ast_log(LOG_ERROR, "SORT() requires an argument\n");
00221 break;
00222 case ERROR_NOMEM:
00223 ast_log(LOG_ERROR, "Out of memory\n");
00224 break;
00225 case 0:
00226 ret = 0;
00227 break;
00228 default:
00229 ast_log(LOG_ERROR, "Unknown internal error\n");
00230 }
00231
00232 ast_module_user_remove(u);
00233
00234 return ret;
00235 }
00236
00237 static int acf_cut_exec(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len)
00238 {
00239 int ret = -1;
00240 struct ast_module_user *u;
00241
00242 u = ast_module_user_add(chan);
00243
00244 switch (cut_internal(chan, data, buf, len)) {
00245 case ERROR_NOARG:
00246 ast_log(LOG_ERROR, "Syntax: CUT(<varname>,<char-delim>,<range-spec>) - missing argument!\n");
00247 break;
00248 case ERROR_NOMEM:
00249 ast_log(LOG_ERROR, "Out of memory\n");
00250 break;
00251 case ERROR_USAGE:
00252 ast_log(LOG_ERROR, "Usage: CUT(<varname>,<char-delim>,<range-spec>)\n");
00253 break;
00254 case 0:
00255 ret = 0;
00256 break;
00257 default:
00258 ast_log(LOG_ERROR, "Unknown internal error\n");
00259 }
00260
00261 ast_module_user_remove(u);
00262
00263 return ret;
00264 }
00265
00266 struct ast_custom_function acf_sort = {
00267 .name = "SORT",
00268 .synopsis = "Sorts a list of key/vals into a list of keys, based upon the vals",
00269 .syntax = "SORT(key1:val1[...][,keyN:valN])",
00270 .desc =
00271 "Takes a comma-separated list of keys and values, each separated by a colon, and returns a\n"
00272 "comma-separated list of the keys, sorted by their values. Values will be evaluated as\n"
00273 "floating-point numbers.\n",
00274 .read = acf_sort_exec,
00275 };
00276
00277 struct ast_custom_function acf_cut = {
00278 .name = "CUT",
00279 .synopsis = "Slices and dices strings, based upon a named delimiter.",
00280 .syntax = "CUT(<varname>,<char-delim>,<range-spec>)",
00281 .desc =
00282 " varname - variable you want cut\n"
00283 " char-delim - defaults to '-'\n"
00284 " range-spec - number of the field you want (1-based offset)\n"
00285 " may also be specified as a range (with -)\n"
00286 " or group of ranges and fields (with &)\n",
00287 .read = acf_cut_exec,
00288 };
00289
00290 static int unload_module(void)
00291 {
00292 int res = 0;
00293
00294 res |= ast_custom_function_unregister(&acf_cut);
00295 res |= ast_custom_function_unregister(&acf_sort);
00296
00297 ast_module_user_hangup_all();
00298
00299 return res;
00300 }
00301
00302 static int load_module(void)
00303 {
00304 int res = 0;
00305
00306 res |= ast_custom_function_register(&acf_cut);
00307 res |= ast_custom_function_register(&acf_sort);
00308
00309 return res;
00310 }
00311
00312 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Cut out information from a string");