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
00028
00029
00030
00031 #include "asterisk.h"
00032
00033 ASTERISK_FILE_VERSION(__FILE__, "$Revision: 411313 $")
00034
00035 #include "asterisk/module.h"
00036 #include "asterisk/channel.h"
00037 #include "asterisk/pbx.h"
00038 #include "asterisk/utils.h"
00039 #include "asterisk/app.h"
00040 #include "asterisk/callerid.h"
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088
00089
00090
00091
00092
00093
00094
00095
00096
00097
00098
00099
00100
00101
00102
00103
00104
00105
00106
00107
00108
00109
00110
00111
00112
00113
00114
00115
00116
00117
00118
00119
00120
00121
00122
00123
00124
00125
00126
00127
00128
00129
00130
00131
00132
00133
00134
00135
00136
00137
00138
00139
00140
00141
00142
00143
00144
00145
00146
00147
00148
00149
00150
00151
00152
00153
00154
00155
00156
00157
00158
00159
00160
00161
00162
00163
00164
00165
00166
00167
00168
00169
00170
00171
00172
00173
00174
00175
00176
00177
00178
00179
00180
00181
00182
00183
00184
00185
00186
00187
00188
00189
00190
00191
00192
00193
00194
00195
00196
00197
00198
00199
00200
00201
00202
00203
00204
00205
00206
00207
00208
00209
00210
00211
00212
00213
00214
00215
00216
00217
00218
00219
00220
00221
00222
00223
00224
00225
00226
00227
00228
00229
00230
00231
00232
00233
00234
00235
00236
00237
00238
00239
00240
00241
00242
00243
00244
00245
00246
00247
00248
00249
00250
00251
00252
00253
00254
00255
00256
00257
00258
00259
00260
00261
00262
00263
00264
00265
00266
00267
00268
00269
00270
00271
00272
00273
00274
00275
00276
00277
00278
00279
00280
00281
00282
00283
00284
00285
00286
00287
00288
00289
00290
00291
00292
00293
00294
00295
00296
00297
00298
00299
00300
00301
00302
00303
00304
00305
00306
00307
00308
00309
00310
00311
00312
00313
00314
00315 enum ID_FIELD_STATUS {
00316 ID_FIELD_VALID,
00317 ID_FIELD_INVALID,
00318 ID_FIELD_UNKNOWN
00319 };
00320
00321 AST_DEFINE_APP_ARGS_TYPE(ast_party_func_args,
00322 AST_APP_ARG(member);
00323 AST_APP_ARG(opts);
00324 AST_APP_ARG(other);
00325 );
00326
00327 AST_DEFINE_APP_ARGS_TYPE(ast_party_members,
00328 AST_APP_ARG(subnames[10]);
00329 );
00330
00331 enum CONNECTED_LINE_OPT_FLAGS {
00332 CONNECTED_LINE_OPT_INHIBIT = (1 << 0),
00333 };
00334 enum CONNECTED_LINE_OPT_ARGS {
00335 CONNECTED_LINE_OPT_DUMMY,
00336
00337
00338 CONNECTED_LINE_OPT_ARG_ARRAY_SIZE
00339 };
00340
00341 AST_APP_OPTIONS(connectedline_opts, BEGIN_OPTIONS
00342 AST_APP_OPTION('i', CONNECTED_LINE_OPT_INHIBIT),
00343 END_OPTIONS);
00344
00345 enum REDIRECTING_OPT_FLAGS {
00346 REDIRECTING_OPT_INHIBIT = (1 << 0),
00347 };
00348 enum REDIRECTING_OPT_ARGS {
00349 REDIRECTING_OPT_DUMMY,
00350
00351
00352 REDIRECTING_OPT_ARG_ARRAY_SIZE
00353 };
00354
00355 AST_APP_OPTIONS(redirecting_opts, BEGIN_OPTIONS
00356 AST_APP_OPTION('i', REDIRECTING_OPT_INHIBIT),
00357 END_OPTIONS);
00358
00359
00360
00361
00362
00363
00364
00365
00366
00367
00368
00369
00370
00371
00372
00373 static enum ID_FIELD_STATUS party_name_read(char *buf, size_t len, int argc, char *argv[], const struct ast_party_name *name)
00374 {
00375 enum ID_FIELD_STATUS status;
00376
00377 status = ID_FIELD_VALID;
00378
00379 if (argc == 0) {
00380
00381 if (name->valid && name->str) {
00382 ast_copy_string(buf, name->str, len);
00383 }
00384 } else if (argc == 1 && !strcasecmp("valid", argv[0])) {
00385 snprintf(buf, len, "%d", name->valid);
00386 } else if (argc == 1 && !strcasecmp("charset", argv[0])) {
00387 ast_copy_string(buf, ast_party_name_charset_str(name->char_set), len);
00388 } else if (argc == 1 && !strncasecmp("pres", argv[0], 4)) {
00389
00390 ast_copy_string(buf, ast_named_caller_presentation(name->presentation), len);
00391 } else {
00392 status = ID_FIELD_UNKNOWN;
00393 }
00394
00395 return status;
00396 }
00397
00398
00399
00400
00401
00402
00403
00404
00405
00406
00407
00408
00409
00410
00411
00412 static enum ID_FIELD_STATUS party_number_read(char *buf, size_t len, int argc, char *argv[], const struct ast_party_number *number)
00413 {
00414 enum ID_FIELD_STATUS status;
00415
00416 status = ID_FIELD_VALID;
00417
00418 if (argc == 0) {
00419
00420 if (number->valid && number->str) {
00421 ast_copy_string(buf, number->str, len);
00422 }
00423 } else if (argc == 1 && !strcasecmp("valid", argv[0])) {
00424 snprintf(buf, len, "%d", number->valid);
00425 } else if (argc == 1 && !strcasecmp("plan", argv[0])) {
00426 snprintf(buf, len, "%d", number->plan);
00427 } else if (argc == 1 && !strncasecmp("pres", argv[0], 4)) {
00428
00429 ast_copy_string(buf, ast_named_caller_presentation(number->presentation), len);
00430 } else {
00431 status = ID_FIELD_UNKNOWN;
00432 }
00433
00434 return status;
00435 }
00436
00437
00438
00439
00440
00441
00442
00443
00444
00445
00446
00447
00448
00449
00450
00451 static enum ID_FIELD_STATUS party_subaddress_read(char *buf, size_t len, int argc, char *argv[], const struct ast_party_subaddress *subaddress)
00452 {
00453 enum ID_FIELD_STATUS status;
00454
00455 status = ID_FIELD_VALID;
00456
00457 if (argc == 0) {
00458
00459 if (subaddress->str) {
00460 ast_copy_string(buf, subaddress->str, len);
00461 }
00462 } else if (argc == 1 && !strcasecmp("valid", argv[0])) {
00463 snprintf(buf, len, "%d", subaddress->valid);
00464 } else if (argc == 1 && !strcasecmp("type", argv[0])) {
00465 snprintf(buf, len, "%d", subaddress->type);
00466 } else if (argc == 1 && !strcasecmp("odd", argv[0])) {
00467 snprintf(buf, len, "%d", subaddress->odd_even_indicator);
00468 } else {
00469 status = ID_FIELD_UNKNOWN;
00470 }
00471
00472 return status;
00473 }
00474
00475
00476
00477
00478
00479
00480
00481
00482
00483
00484
00485
00486
00487
00488
00489 static enum ID_FIELD_STATUS party_id_read(char *buf, size_t len, int argc, char *argv[], const struct ast_party_id *id)
00490 {
00491 enum ID_FIELD_STATUS status;
00492
00493 if (argc == 0) {
00494
00495 return ID_FIELD_UNKNOWN;
00496 }
00497
00498 status = ID_FIELD_VALID;
00499
00500 if (argc == 1 && !strcasecmp("all", argv[0])) {
00501 snprintf(buf, len, "\"%s\" <%s>",
00502 S_COR(id->name.valid, id->name.str, ""),
00503 S_COR(id->number.valid, id->number.str, ""));
00504 } else if (!strcasecmp("name", argv[0])) {
00505 status = party_name_read(buf, len, argc - 1, argv + 1, &id->name);
00506 } else if (!strncasecmp("num", argv[0], 3)) {
00507
00508 status = party_number_read(buf, len, argc - 1, argv + 1, &id->number);
00509 } else if (!strncasecmp("subaddr", argv[0], 7)) {
00510
00511 status = party_subaddress_read(buf, len, argc - 1, argv + 1, &id->subaddress);
00512 } else if (argc == 1 && !strcasecmp("tag", argv[0])) {
00513 if (id->tag) {
00514 ast_copy_string(buf, id->tag, len);
00515 }
00516 } else if (argc == 1 && !strcasecmp("ton", argv[0])) {
00517
00518 snprintf(buf, len, "%d", id->number.plan);
00519 } else if (argc == 1 && !strncasecmp("pres", argv[0], 4)) {
00520
00521
00522
00523
00524 ast_copy_string(buf,
00525 ast_named_caller_presentation(ast_party_id_presentation(id)), len);
00526 } else {
00527 status = ID_FIELD_UNKNOWN;
00528 }
00529
00530 return status;
00531 }
00532
00533
00534
00535
00536
00537
00538
00539
00540
00541
00542
00543
00544
00545
00546
00547 static enum ID_FIELD_STATUS party_name_write(struct ast_party_name *name, int argc, char *argv[], const char *value)
00548 {
00549 char *val;
00550 enum ID_FIELD_STATUS status;
00551
00552 status = ID_FIELD_VALID;
00553
00554 if (argc == 0) {
00555
00556 name->valid = 1;
00557 name->str = ast_strdup(value);
00558 ast_trim_blanks(name->str);
00559 } else if (argc == 1 && !strcasecmp("valid", argv[0])) {
00560 name->valid = atoi(value) ? 1 : 0;
00561 } else if (argc == 1 && !strcasecmp("charset", argv[0])) {
00562 int char_set;
00563
00564 val = ast_strdupa(value);
00565 ast_trim_blanks(val);
00566
00567 if (('0' <= val[0]) && (val[0] <= '9')) {
00568 char_set = atoi(val);
00569 } else {
00570 char_set = ast_party_name_charset_parse(val);
00571 }
00572
00573 if (char_set < 0) {
00574 ast_log(LOG_ERROR,
00575 "Unknown name char-set '%s', value unchanged\n", val);
00576 status = ID_FIELD_INVALID;
00577 } else {
00578 name->char_set = char_set;
00579 }
00580 } else if (argc == 1 && !strncasecmp("pres", argv[0], 4)) {
00581 int pres;
00582
00583
00584 val = ast_strdupa(value);
00585 ast_trim_blanks(val);
00586
00587 if (('0' <= val[0]) && (val[0] <= '9')) {
00588 pres = atoi(val);
00589 } else {
00590 pres = ast_parse_caller_presentation(val);
00591 }
00592
00593 if (pres < 0) {
00594 ast_log(LOG_ERROR,
00595 "Unknown name presentation '%s', value unchanged\n", val);
00596 status = ID_FIELD_INVALID;
00597 } else {
00598 name->presentation = pres;
00599 }
00600 } else {
00601 status = ID_FIELD_UNKNOWN;
00602 }
00603
00604 return status;
00605 }
00606
00607
00608
00609
00610
00611
00612
00613
00614
00615
00616
00617
00618
00619
00620
00621 static enum ID_FIELD_STATUS party_number_write(struct ast_party_number *number, int argc, char *argv[], const char *value)
00622 {
00623 char *val;
00624 enum ID_FIELD_STATUS status;
00625
00626 status = ID_FIELD_VALID;
00627
00628 if (argc == 0) {
00629
00630 number->valid = 1;
00631 number->str = ast_strdup(value);
00632 ast_trim_blanks(number->str);
00633 } else if (argc == 1 && !strcasecmp("valid", argv[0])) {
00634 number->valid = atoi(value) ? 1 : 0;
00635 } else if (argc == 1 && !strcasecmp("plan", argv[0])) {
00636 val = ast_strdupa(value);
00637 ast_trim_blanks(val);
00638
00639 if (('0' <= val[0]) && (val[0] <= '9')) {
00640 number->plan = atoi(val);
00641 } else {
00642 ast_log(LOG_ERROR,
00643 "Unknown type-of-number/numbering-plan '%s', value unchanged\n", val);
00644 status = ID_FIELD_INVALID;
00645 }
00646 } else if (argc == 1 && !strncasecmp("pres", argv[0], 4)) {
00647 int pres;
00648
00649
00650 val = ast_strdupa(value);
00651 ast_trim_blanks(val);
00652
00653 if (('0' <= val[0]) && (val[0] <= '9')) {
00654 pres = atoi(val);
00655 } else {
00656 pres = ast_parse_caller_presentation(val);
00657 }
00658
00659 if (pres < 0) {
00660 ast_log(LOG_ERROR,
00661 "Unknown number presentation '%s', value unchanged\n", val);
00662 status = ID_FIELD_INVALID;
00663 } else {
00664 number->presentation = pres;
00665 }
00666 } else {
00667 status = ID_FIELD_UNKNOWN;
00668 }
00669
00670 return status;
00671 }
00672
00673
00674
00675
00676
00677
00678
00679
00680
00681
00682
00683
00684
00685
00686
00687 static enum ID_FIELD_STATUS party_subaddress_write(struct ast_party_subaddress *subaddress, int argc, char *argv[], const char *value)
00688 {
00689 enum ID_FIELD_STATUS status;
00690
00691 status = ID_FIELD_VALID;
00692
00693 if (argc == 0) {
00694
00695 subaddress->str = ast_strdup(value);
00696 ast_trim_blanks(subaddress->str);
00697 } else if (argc == 1 && !strcasecmp("valid", argv[0])) {
00698 subaddress->valid = atoi(value) ? 1 : 0;
00699 } else if (argc == 1 && !strcasecmp("type", argv[0])) {
00700 subaddress->type = atoi(value) ? 2 : 0;
00701 } else if (argc == 1 && !strcasecmp("odd", argv[0])) {
00702 subaddress->odd_even_indicator = atoi(value) ? 1 : 0;
00703 } else {
00704 status = ID_FIELD_UNKNOWN;
00705 }
00706
00707 return status;
00708 }
00709
00710
00711
00712
00713
00714
00715
00716
00717
00718
00719
00720
00721
00722
00723
00724 static enum ID_FIELD_STATUS party_id_write(struct ast_party_id *id, int argc, char *argv[], const char *value)
00725 {
00726 char *val;
00727 enum ID_FIELD_STATUS status;
00728
00729 if (argc == 0) {
00730
00731 return ID_FIELD_UNKNOWN;
00732 }
00733
00734 status = ID_FIELD_VALID;
00735
00736 if (argc == 1 && !strcasecmp("all", argv[0])) {
00737 char name[256];
00738 char num[256];
00739
00740 ast_callerid_split(value, name, sizeof(name), num, sizeof(num));
00741 id->name.valid = 1;
00742 id->name.str = ast_strdup(name);
00743 if (!id->name.str) {
00744 return ID_FIELD_INVALID;
00745 }
00746 id->number.valid = 1;
00747 id->number.str = ast_strdup(num);
00748 if (!id->number.str) {
00749 return ID_FIELD_INVALID;
00750 }
00751 } else if (!strcasecmp("name", argv[0])) {
00752 status = party_name_write(&id->name, argc - 1, argv + 1, value);
00753 } else if (!strncasecmp("num", argv[0], 3)) {
00754
00755 status = party_number_write(&id->number, argc - 1, argv + 1, value);
00756 } else if (!strncasecmp("subaddr", argv[0], 7)) {
00757
00758 status = party_subaddress_write(&id->subaddress, argc - 1, argv + 1, value);
00759 } else if (argc == 1 && !strcasecmp("tag", argv[0])) {
00760 id->tag = ast_strdup(value);
00761 ast_trim_blanks(id->tag);
00762 } else if (argc == 1 && !strcasecmp("ton", argv[0])) {
00763
00764 argv[0] = "plan";
00765 status = party_number_write(&id->number, argc, argv, value);
00766 } else if (argc == 1 && !strncasecmp("pres", argv[0], 4)) {
00767 int pres;
00768
00769
00770
00771
00772
00773 val = ast_strdupa(value);
00774 ast_trim_blanks(val);
00775
00776 if (('0' <= val[0]) && (val[0] <= '9')) {
00777 pres = atoi(val);
00778 } else {
00779 pres = ast_parse_caller_presentation(val);
00780 }
00781
00782 if (pres < 0) {
00783 ast_log(LOG_ERROR,
00784 "Unknown combined presentation '%s', value unchanged\n", val);
00785 status = ID_FIELD_INVALID;
00786 } else {
00787 id->name.presentation = pres;
00788 id->number.presentation = pres;
00789 }
00790 } else {
00791 status = ID_FIELD_UNKNOWN;
00792 }
00793
00794 return status;
00795 }
00796
00797
00798 static int callerpres_deprecate_notify;
00799
00800
00801
00802
00803
00804
00805
00806
00807
00808
00809
00810
00811
00812
00813 static int callerpres_read(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
00814 {
00815 if (!chan) {
00816 ast_log(LOG_WARNING, "No channel was provided to %s function.\n", cmd);
00817 return -1;
00818 }
00819
00820 if (!callerpres_deprecate_notify) {
00821 callerpres_deprecate_notify = 1;
00822 ast_log(LOG_WARNING, "CALLERPRES is deprecated."
00823 " Use CALLERID(name-pres) or CALLERID(num-pres) instead.\n");
00824 }
00825 ast_copy_string(buf,
00826 ast_named_caller_presentation(ast_party_id_presentation(&chan->caller.id)), len);
00827 return 0;
00828 }
00829
00830
00831
00832
00833
00834
00835
00836
00837
00838
00839
00840
00841
00842 static int callerpres_write(struct ast_channel *chan, const char *cmd, char *data, const char *value)
00843 {
00844 int pres;
00845
00846 if (!chan) {
00847 ast_log(LOG_WARNING, "No channel was provided to %s function.\n", cmd);
00848 return -1;
00849 }
00850
00851 if (!callerpres_deprecate_notify) {
00852 callerpres_deprecate_notify = 1;
00853 ast_log(LOG_WARNING, "CALLERPRES is deprecated."
00854 " Use CALLERID(name-pres) or CALLERID(num-pres) instead.\n");
00855 }
00856
00857 pres = ast_parse_caller_presentation(value);
00858 if (pres < 0) {
00859 ast_log(LOG_WARNING, "'%s' is not a valid presentation (see 'show function CALLERPRES')\n", value);
00860 } else {
00861 chan->caller.id.name.presentation = pres;
00862 chan->caller.id.number.presentation = pres;
00863 }
00864 return 0;
00865 }
00866
00867
00868
00869
00870
00871
00872
00873
00874
00875
00876
00877
00878
00879
00880 static int callerid_read(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
00881 {
00882 enum ID_FIELD_STATUS status;
00883 char *parms;
00884 struct ast_party_members member;
00885 AST_DECLARE_APP_ARGS(args,
00886 AST_APP_ARG(member);
00887 AST_APP_ARG(cid);
00888 );
00889
00890
00891 *buf = 0;
00892
00893 if (!chan) {
00894 return -1;
00895 }
00896
00897 parms = ast_strdupa(data);
00898 AST_STANDARD_APP_ARGS(args, parms);
00899 if (args.argc == 0) {
00900
00901 return -1;
00902 }
00903
00904 AST_NONSTANDARD_APP_ARGS(member, args.member, '-');
00905 if (member.argc == 0 || ARRAY_LEN(member.subnames) <= member.argc) {
00906
00907 return -1;
00908 }
00909
00910 if (args.argc == 2) {
00911 char name[80];
00912 char num[80];
00913
00914 ast_callerid_split(args.cid, name, sizeof(name), num, sizeof(num));
00915
00916 if (member.argc == 1 && !strcasecmp("all", member.argv[0])) {
00917 snprintf(buf, len, "\"%s\" <%s>", name, num);
00918 } else if (member.argc == 1 && !strcasecmp("name", member.argv[0])) {
00919 ast_copy_string(buf, name, len);
00920 } else if (member.argc == 1 && !strncasecmp("num", member.argv[0], 3)) {
00921
00922 ast_copy_string(buf, num, len);
00923 } else {
00924 ast_log(LOG_ERROR, "Unknown callerid data type '%s'.\n", data);
00925 }
00926 } else {
00927 ast_channel_lock(chan);
00928
00929 if (member.argc == 1 && !strcasecmp("rdnis", member.argv[0])) {
00930 if (chan->redirecting.from.number.valid
00931 && chan->redirecting.from.number.str) {
00932 ast_copy_string(buf, chan->redirecting.from.number.str, len);
00933 }
00934 } else if (!strcasecmp("dnid", member.argv[0])) {
00935 if (member.argc == 1) {
00936
00937 member.argc = 2;
00938 member.argv[1] = "num";
00939 }
00940 if (!strncasecmp("num", member.argv[1], 3)) {
00941
00942
00943
00944
00945 if (member.argc == 2) {
00946
00947 if (chan->dialed.number.str) {
00948 ast_copy_string(buf, chan->dialed.number.str, len);
00949 }
00950 } else if (member.argc == 3 && !strcasecmp("plan", member.argv[2])) {
00951
00952 snprintf(buf, len, "%d", chan->dialed.number.plan);
00953 } else {
00954 ast_log(LOG_ERROR, "Unknown callerid data type '%s'.\n", data);
00955 }
00956 } else if (!strncasecmp("subaddr", member.argv[1], 7)) {
00957
00958
00959
00960
00961 status = party_subaddress_read(buf, len, member.argc - 2, member.argv + 2,
00962 &chan->dialed.subaddress);
00963 switch (status) {
00964 case ID_FIELD_VALID:
00965 case ID_FIELD_INVALID:
00966 break;
00967 default:
00968 ast_log(LOG_ERROR, "Unknown callerid data type '%s'.\n", data);
00969 break;
00970 }
00971 } else {
00972 ast_log(LOG_ERROR, "Unknown callerid data type '%s'.\n", data);
00973 }
00974 } else if (member.argc == 1 && !strcasecmp("ani2", member.argv[0])) {
00975 snprintf(buf, len, "%d", chan->caller.ani2);
00976 } else if (!strcasecmp("ani", member.argv[0])) {
00977 if (member.argc == 1) {
00978
00979 member.argc = 2;
00980 member.argv[1] = "num";
00981 }
00982 status = party_id_read(buf, len, member.argc - 1, member.argv + 1,
00983 &chan->caller.ani);
00984 switch (status) {
00985 case ID_FIELD_VALID:
00986 case ID_FIELD_INVALID:
00987 break;
00988 default:
00989 ast_log(LOG_ERROR, "Unknown callerid data type '%s'.\n", data);
00990 break;
00991 }
00992 } else {
00993 status = party_id_read(buf, len, member.argc, member.argv, &chan->caller.id);
00994 switch (status) {
00995 case ID_FIELD_VALID:
00996 case ID_FIELD_INVALID:
00997 break;
00998 default:
00999 ast_log(LOG_ERROR, "Unknown callerid data type '%s'.\n", data);
01000 break;
01001 }
01002 }
01003
01004 ast_channel_unlock(chan);
01005 }
01006
01007 return 0;
01008 }
01009
01010
01011
01012
01013
01014
01015
01016
01017
01018
01019
01020
01021
01022 static int callerid_write(struct ast_channel *chan, const char *cmd, char *data, const char *value)
01023 {
01024 struct ast_party_caller caller;
01025 struct ast_party_dialed dialed;
01026 enum ID_FIELD_STATUS status;
01027 char *val;
01028 char *parms;
01029 struct ast_party_func_args args;
01030 struct ast_party_members member;
01031
01032 if (!value || !chan) {
01033 return -1;
01034 }
01035
01036 parms = ast_strdupa(data);
01037 AST_STANDARD_APP_ARGS(args, parms);
01038 if (args.argc == 0) {
01039
01040 return -1;
01041 }
01042
01043 AST_NONSTANDARD_APP_ARGS(member, args.member, '-');
01044 if (member.argc == 0 || ARRAY_LEN(member.subnames) <= member.argc) {
01045
01046 return -1;
01047 }
01048
01049 value = ast_skip_blanks(value);
01050
01051 ast_channel_lock(chan);
01052 if (member.argc == 1 && !strcasecmp("rdnis", member.argv[0])) {
01053 chan->redirecting.from.number.valid = 1;
01054 ast_free(chan->redirecting.from.number.str);
01055 chan->redirecting.from.number.str = ast_strdup(value);
01056 if (chan->cdr) {
01057 ast_cdr_setcid(chan->cdr, chan);
01058 }
01059 } else if (!strcasecmp("dnid", member.argv[0])) {
01060 ast_party_dialed_set_init(&dialed, &chan->dialed);
01061 if (member.argc == 1) {
01062
01063 member.argc = 2;
01064 member.argv[1] = "num";
01065 }
01066 if (!strncasecmp("num", member.argv[1], 3)) {
01067
01068
01069
01070
01071 if (member.argc == 2) {
01072
01073 dialed.number.str = ast_strdup(value);
01074 ast_trim_blanks(dialed.number.str);
01075 ast_party_dialed_set(&chan->dialed, &dialed);
01076 if (chan->cdr) {
01077 ast_cdr_setcid(chan->cdr, chan);
01078 }
01079 } else if (member.argc == 3 && !strcasecmp("plan", member.argv[2])) {
01080
01081 val = ast_strdupa(value);
01082 ast_trim_blanks(val);
01083
01084 if (('0' <= val[0]) && (val[0] <= '9')) {
01085 chan->dialed.number.plan = atoi(val);
01086 if (chan->cdr) {
01087 ast_cdr_setcid(chan->cdr, chan);
01088 }
01089 } else {
01090 ast_log(LOG_ERROR,
01091 "Unknown type-of-number/numbering-plan '%s', value unchanged\n", val);
01092 }
01093 } else {
01094 ast_log(LOG_ERROR, "Unknown callerid data type '%s'.\n", data);
01095 }
01096 } else if (!strncasecmp("subaddr", member.argv[1], 7)) {
01097
01098
01099
01100
01101 status = party_subaddress_write(&dialed.subaddress, member.argc - 2,
01102 member.argv + 2, value);
01103 switch (status) {
01104 case ID_FIELD_VALID:
01105 ast_party_dialed_set(&chan->dialed, &dialed);
01106 if (chan->cdr) {
01107 ast_cdr_setcid(chan->cdr, chan);
01108 }
01109 break;
01110 case ID_FIELD_INVALID:
01111 break;
01112 default:
01113 ast_log(LOG_ERROR, "Unknown callerid data type '%s'.\n", data);
01114 break;
01115 }
01116 } else {
01117 ast_log(LOG_ERROR, "Unknown callerid data type '%s'.\n", data);
01118 }
01119 ast_party_dialed_free(&dialed);
01120 } else if (member.argc == 1 && !strcasecmp("ani2", member.argv[0])) {
01121 val = ast_strdupa(value);
01122 ast_trim_blanks(val);
01123
01124 if (('0' <= val[0]) && (val[0] <= '9')) {
01125 chan->caller.ani2 = atoi(val);
01126 if (chan->cdr) {
01127 ast_cdr_setcid(chan->cdr, chan);
01128 }
01129 } else {
01130 ast_log(LOG_ERROR, "Unknown callerid ani2 '%s', value unchanged\n", val);
01131 }
01132 } else if (!strcasecmp("ani", member.argv[0])) {
01133 ast_party_caller_set_init(&caller, &chan->caller);
01134 if (member.argc == 1) {
01135
01136 member.argc = 2;
01137 member.argv[1] = "num";
01138 }
01139 status = party_id_write(&caller.ani, member.argc - 1, member.argv + 1, value);
01140 switch (status) {
01141 case ID_FIELD_VALID:
01142 ast_party_caller_set(&chan->caller, &caller, NULL);
01143 if (chan->cdr) {
01144 ast_cdr_setcid(chan->cdr, chan);
01145 }
01146 break;
01147 case ID_FIELD_INVALID:
01148 break;
01149 default:
01150 ast_log(LOG_ERROR, "Unknown callerid data type '%s'.\n", data);
01151 break;
01152 }
01153 ast_party_caller_free(&caller);
01154 } else {
01155 ast_party_caller_set_init(&caller, &chan->caller);
01156 status = party_id_write(&caller.id, member.argc, member.argv, value);
01157 switch (status) {
01158 case ID_FIELD_VALID:
01159 ast_channel_set_caller_event(chan, &caller, NULL);
01160 if (chan->cdr) {
01161 ast_cdr_setcid(chan->cdr, chan);
01162 }
01163 break;
01164 case ID_FIELD_INVALID:
01165 break;
01166 default:
01167 ast_log(LOG_ERROR, "Unknown callerid data type '%s'.\n", data);
01168 break;
01169 }
01170 ast_party_caller_free(&caller);
01171 }
01172 ast_channel_unlock(chan);
01173
01174 return 0;
01175 }
01176
01177
01178
01179
01180
01181
01182
01183
01184
01185
01186
01187
01188
01189
01190 static int connectedline_read(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
01191 {
01192 struct ast_party_members member;
01193 char *read_what;
01194 enum ID_FIELD_STATUS status;
01195
01196
01197 *buf = 0;
01198
01199 if (!chan) {
01200 return -1;
01201 }
01202
01203 read_what = ast_strdupa(data);
01204 AST_NONSTANDARD_APP_ARGS(member, read_what, '-');
01205 if (member.argc == 0 || ARRAY_LEN(member.subnames) <= member.argc) {
01206
01207 return -1;
01208 }
01209
01210 ast_channel_lock(chan);
01211
01212 if (member.argc == 1 && !strcasecmp("source", member.argv[0])) {
01213 ast_copy_string(buf, ast_connected_line_source_name(chan->connected.source), len);
01214 } else {
01215 status = party_id_read(buf, len, member.argc, member.argv, &chan->connected.id);
01216 switch (status) {
01217 case ID_FIELD_VALID:
01218 case ID_FIELD_INVALID:
01219 break;
01220 default:
01221 ast_log(LOG_ERROR, "Unknown connectedline data type '%s'.\n", data);
01222 break;
01223 }
01224 }
01225
01226 ast_channel_unlock(chan);
01227
01228 return 0;
01229 }
01230
01231
01232
01233
01234
01235
01236
01237
01238
01239
01240
01241
01242
01243 static int connectedline_write(struct ast_channel *chan, const char *cmd, char *data, const char *value)
01244 {
01245 struct ast_party_connected_line connected;
01246 enum ID_FIELD_STATUS status;
01247 char *val;
01248 char *parms;
01249 void (*set_it)(struct ast_channel *chan, const struct ast_party_connected_line *connected, const struct ast_set_party_connected_line *update);
01250 struct ast_party_func_args args;
01251 struct ast_party_members member;
01252 struct ast_flags opts;
01253 char *opt_args[CONNECTED_LINE_OPT_ARG_ARRAY_SIZE];
01254
01255 if (!value || !chan) {
01256 return -1;
01257 }
01258
01259 parms = ast_strdupa(data);
01260 AST_STANDARD_APP_ARGS(args, parms);
01261 if (args.argc == 0) {
01262
01263 return -1;
01264 }
01265
01266 AST_NONSTANDARD_APP_ARGS(member, args.member, '-');
01267 if (member.argc == 0 || ARRAY_LEN(member.subnames) <= member.argc) {
01268
01269 return -1;
01270 }
01271
01272 if (ast_app_parse_options(connectedline_opts, &opts, opt_args, args.opts)) {
01273
01274 return -1;
01275 }
01276
01277
01278 if (ast_test_flag(&opts, CONNECTED_LINE_OPT_INHIBIT)) {
01279 set_it = ast_channel_set_connected_line;
01280 } else {
01281 set_it = ast_channel_update_connected_line;
01282 }
01283
01284 ast_channel_lock(chan);
01285 ast_party_connected_line_set_init(&connected, &chan->connected);
01286 ast_channel_unlock(chan);
01287
01288 value = ast_skip_blanks(value);
01289
01290 if (member.argc == 1 && !strcasecmp("source", member.argv[0])) {
01291 int source;
01292
01293 val = ast_strdupa(value);
01294 ast_trim_blanks(val);
01295
01296 if (('0' <= val[0]) && (val[0] <= '9')) {
01297 source = atoi(val);
01298 } else {
01299 source = ast_connected_line_source_parse(val);
01300 }
01301
01302 if (source < 0) {
01303 ast_log(LOG_ERROR, "Unknown connectedline source '%s', value unchanged\n", val);
01304 } else {
01305 connected.source = source;
01306 set_it(chan, &connected, NULL);
01307 }
01308 } else {
01309 status = party_id_write(&connected.id, member.argc, member.argv, value);
01310 switch (status) {
01311 case ID_FIELD_VALID:
01312 set_it(chan, &connected, NULL);
01313 break;
01314 case ID_FIELD_INVALID:
01315 break;
01316 default:
01317 ast_log(LOG_ERROR, "Unknown connectedline data type '%s'.\n", data);
01318 break;
01319 }
01320 ast_party_connected_line_free(&connected);
01321 }
01322
01323 return 0;
01324 }
01325
01326
01327
01328
01329
01330
01331
01332
01333
01334
01335
01336
01337
01338
01339 static int redirecting_read(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
01340 {
01341 struct ast_party_members member;
01342 char *read_what;
01343 enum ID_FIELD_STATUS status;
01344
01345
01346 *buf = 0;
01347
01348 if (!chan) {
01349 return -1;
01350 }
01351
01352 read_what = ast_strdupa(data);
01353 AST_NONSTANDARD_APP_ARGS(member, read_what, '-');
01354 if (member.argc == 0 || ARRAY_LEN(member.subnames) <= member.argc) {
01355
01356 return -1;
01357 }
01358
01359 ast_channel_lock(chan);
01360
01361 if (!strcasecmp("from", member.argv[0])) {
01362 status = party_id_read(buf, len, member.argc - 1, member.argv + 1,
01363 &chan->redirecting.from);
01364 switch (status) {
01365 case ID_FIELD_VALID:
01366 case ID_FIELD_INVALID:
01367 break;
01368 default:
01369 ast_log(LOG_ERROR, "Unknown redirecting data type '%s'.\n", data);
01370 break;
01371 }
01372 } else if (!strcasecmp("to", member.argv[0])) {
01373 status = party_id_read(buf, len, member.argc - 1, member.argv + 1,
01374 &chan->redirecting.to);
01375 switch (status) {
01376 case ID_FIELD_VALID:
01377 case ID_FIELD_INVALID:
01378 break;
01379 default:
01380 ast_log(LOG_ERROR, "Unknown redirecting data type '%s'.\n", data);
01381 break;
01382 }
01383 } else if (member.argc == 1 && !strncasecmp("pres", member.argv[0], 4)) {
01384
01385
01386
01387
01388 ast_copy_string(buf,
01389 ast_named_caller_presentation(
01390 ast_party_id_presentation(&chan->redirecting.from)), len);
01391 } else if (member.argc == 1 && !strcasecmp("reason", member.argv[0])) {
01392 ast_copy_string(buf, ast_redirecting_reason_name(chan->redirecting.reason), len);
01393 } else if (member.argc == 1 && !strcasecmp("count", member.argv[0])) {
01394 snprintf(buf, len, "%d", chan->redirecting.count);
01395 } else {
01396 ast_log(LOG_ERROR, "Unknown redirecting data type '%s'.\n", data);
01397 }
01398
01399 ast_channel_unlock(chan);
01400
01401 return 0;
01402 }
01403
01404
01405
01406
01407
01408
01409
01410
01411
01412
01413
01414
01415
01416 static int redirecting_write(struct ast_channel *chan, const char *cmd, char *data, const char *value)
01417 {
01418 struct ast_party_redirecting redirecting;
01419 enum ID_FIELD_STATUS status;
01420 char *val;
01421 char *parms;
01422 void (*set_it)(struct ast_channel *chan, const struct ast_party_redirecting *redirecting, const struct ast_set_party_redirecting *update);
01423 struct ast_party_func_args args;
01424 struct ast_party_members member;
01425 struct ast_flags opts;
01426 char *opt_args[REDIRECTING_OPT_ARG_ARRAY_SIZE];
01427
01428 if (!value || !chan) {
01429 return -1;
01430 }
01431
01432 parms = ast_strdupa(data);
01433 AST_STANDARD_APP_ARGS(args, parms);
01434 if (args.argc == 0) {
01435
01436 return -1;
01437 }
01438
01439 AST_NONSTANDARD_APP_ARGS(member, args.member, '-');
01440 if (member.argc == 0 || ARRAY_LEN(member.subnames) <= member.argc) {
01441
01442 return -1;
01443 }
01444
01445 if (ast_app_parse_options(redirecting_opts, &opts, opt_args, args.opts)) {
01446
01447 return -1;
01448 }
01449
01450
01451 if (ast_test_flag(&opts, REDIRECTING_OPT_INHIBIT)) {
01452 set_it = ast_channel_set_redirecting;
01453 } else {
01454 set_it = ast_channel_update_redirecting;
01455 }
01456
01457 ast_channel_lock(chan);
01458 ast_party_redirecting_set_init(&redirecting, &chan->redirecting);
01459 ast_channel_unlock(chan);
01460
01461 value = ast_skip_blanks(value);
01462
01463 if (!strcasecmp("from", member.argv[0])) {
01464 status = party_id_write(&redirecting.from, member.argc - 1, member.argv + 1,
01465 value);
01466 switch (status) {
01467 case ID_FIELD_VALID:
01468 set_it(chan, &redirecting, NULL);
01469 break;
01470 case ID_FIELD_INVALID:
01471 break;
01472 default:
01473 ast_log(LOG_ERROR, "Unknown redirecting data type '%s'.\n", data);
01474 break;
01475 }
01476 ast_party_redirecting_free(&redirecting);
01477 } else if (!strcasecmp("to", member.argv[0])) {
01478 status = party_id_write(&redirecting.to, member.argc - 1, member.argv + 1, value);
01479 switch (status) {
01480 case ID_FIELD_VALID:
01481 set_it(chan, &redirecting, NULL);
01482 break;
01483 case ID_FIELD_INVALID:
01484 break;
01485 default:
01486 ast_log(LOG_ERROR, "Unknown redirecting data type '%s'.\n", data);
01487 break;
01488 }
01489 ast_party_redirecting_free(&redirecting);
01490 } else if (member.argc == 1 && !strncasecmp("pres", member.argv[0], 4)) {
01491 int pres;
01492
01493 val = ast_strdupa(value);
01494 ast_trim_blanks(val);
01495
01496 if (('0' <= val[0]) && (val[0] <= '9')) {
01497 pres = atoi(val);
01498 } else {
01499 pres = ast_parse_caller_presentation(val);
01500 }
01501
01502 if (pres < 0) {
01503 ast_log(LOG_ERROR,
01504 "Unknown redirecting combined presentation '%s', value unchanged\n", val);
01505 } else {
01506 redirecting.from.name.presentation = pres;
01507 redirecting.from.number.presentation = pres;
01508 redirecting.to.name.presentation = pres;
01509 redirecting.to.number.presentation = pres;
01510 set_it(chan, &redirecting, NULL);
01511 }
01512 } else if (member.argc == 1 && !strcasecmp("reason", member.argv[0])) {
01513 int reason;
01514
01515 val = ast_strdupa(value);
01516 ast_trim_blanks(val);
01517
01518 if (('0' <= val[0]) && (val[0] <= '9')) {
01519 reason = atoi(val);
01520 } else {
01521 reason = ast_redirecting_reason_parse(val);
01522 }
01523
01524 if (reason < 0) {
01525 ast_log(LOG_ERROR, "Unknown redirecting reason '%s', value unchanged\n", val);
01526 } else {
01527 redirecting.reason = reason;
01528 set_it(chan, &redirecting, NULL);
01529 }
01530 } else if (member.argc == 1 && !strcasecmp("count", member.argv[0])) {
01531 val = ast_strdupa(value);
01532 ast_trim_blanks(val);
01533
01534 if (('0' <= val[0]) && (val[0] <= '9')) {
01535 redirecting.count = atoi(val);
01536 set_it(chan, &redirecting, NULL);
01537 } else {
01538 ast_log(LOG_ERROR, "Unknown redirecting count '%s', value unchanged\n", val);
01539 }
01540 } else {
01541 ast_log(LOG_ERROR, "Unknown redirecting data type '%s'.\n", data);
01542 }
01543
01544 return 0;
01545 }
01546
01547 static struct ast_custom_function callerid_function = {
01548 .name = "CALLERID",
01549 .read = callerid_read,
01550 .read_max = 256,
01551 .write = callerid_write,
01552 };
01553
01554 static struct ast_custom_function callerpres_function = {
01555 .name = "CALLERPRES",
01556 .read = callerpres_read,
01557 .read_max = 50,
01558 .write = callerpres_write,
01559 };
01560
01561 static struct ast_custom_function connectedline_function = {
01562 .name = "CONNECTEDLINE",
01563 .read = connectedline_read,
01564 .write = connectedline_write,
01565 };
01566
01567 static struct ast_custom_function redirecting_function = {
01568 .name = "REDIRECTING",
01569 .read = redirecting_read,
01570 .write = redirecting_write,
01571 };
01572
01573
01574
01575
01576
01577
01578
01579
01580 static int unload_module(void)
01581 {
01582 int res;
01583
01584 res = ast_custom_function_unregister(&callerpres_function);
01585 res |= ast_custom_function_unregister(&callerid_function);
01586 res |= ast_custom_function_unregister(&connectedline_function);
01587 res |= ast_custom_function_unregister(&redirecting_function);
01588 return res;
01589 }
01590
01591
01592
01593
01594
01595
01596
01597
01598 static int load_module(void)
01599 {
01600 int res;
01601
01602 res = ast_custom_function_register(&callerpres_function);
01603 res |= ast_custom_function_register(&callerid_function);
01604 res |= ast_custom_function_register(&connectedline_function);
01605 res |= ast_custom_function_register(&redirecting_function);
01606 return res ? AST_MODULE_LOAD_DECLINE : AST_MODULE_LOAD_SUCCESS;
01607 }
01608
01609
01610 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Party ID related dialplan functions (Caller-ID, Connected-line, Redirecting)");