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: 341704 $")
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 (!callerpres_deprecate_notify) {
00816 callerpres_deprecate_notify = 1;
00817 ast_log(LOG_WARNING, "CALLERPRES is deprecated."
00818 " Use CALLERID(name-pres) or CALLERID(num-pres) instead.\n");
00819 }
00820 ast_copy_string(buf,
00821 ast_named_caller_presentation(ast_party_id_presentation(&chan->caller.id)), len);
00822 return 0;
00823 }
00824
00825
00826
00827
00828
00829
00830
00831
00832
00833
00834
00835
00836
00837 static int callerpres_write(struct ast_channel *chan, const char *cmd, char *data, const char *value)
00838 {
00839 int pres;
00840
00841 if (!callerpres_deprecate_notify) {
00842 callerpres_deprecate_notify = 1;
00843 ast_log(LOG_WARNING, "CALLERPRES is deprecated."
00844 " Use CALLERID(name-pres) or CALLERID(num-pres) instead.\n");
00845 }
00846
00847 pres = ast_parse_caller_presentation(value);
00848 if (pres < 0) {
00849 ast_log(LOG_WARNING, "'%s' is not a valid presentation (see 'show function CALLERPRES')\n", value);
00850 } else {
00851 chan->caller.id.name.presentation = pres;
00852 chan->caller.id.number.presentation = pres;
00853 }
00854 return 0;
00855 }
00856
00857
00858
00859
00860
00861
00862
00863
00864
00865
00866
00867
00868
00869
00870 static int callerid_read(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
00871 {
00872 enum ID_FIELD_STATUS status;
00873 char *parms;
00874 struct ast_party_members member;
00875 AST_DECLARE_APP_ARGS(args,
00876 AST_APP_ARG(member);
00877 AST_APP_ARG(cid);
00878 );
00879
00880
00881 *buf = 0;
00882
00883 if (!chan) {
00884 return -1;
00885 }
00886
00887 parms = ast_strdupa(data);
00888 AST_STANDARD_APP_ARGS(args, parms);
00889 if (args.argc == 0) {
00890
00891 return -1;
00892 }
00893
00894 AST_NONSTANDARD_APP_ARGS(member, args.member, '-');
00895 if (member.argc == 0 || ARRAY_LEN(member.subnames) <= member.argc) {
00896
00897 return -1;
00898 }
00899
00900 if (args.argc == 2) {
00901 char name[80];
00902 char num[80];
00903
00904 ast_callerid_split(args.cid, name, sizeof(name), num, sizeof(num));
00905
00906 if (member.argc == 1 && !strcasecmp("all", member.argv[0])) {
00907 snprintf(buf, len, "\"%s\" <%s>", name, num);
00908 } else if (member.argc == 1 && !strcasecmp("name", member.argv[0])) {
00909 ast_copy_string(buf, name, len);
00910 } else if (member.argc == 1 && !strncasecmp("num", member.argv[0], 3)) {
00911
00912 ast_copy_string(buf, num, len);
00913 } else {
00914 ast_log(LOG_ERROR, "Unknown callerid data type '%s'.\n", data);
00915 }
00916 } else {
00917 ast_channel_lock(chan);
00918
00919 if (member.argc == 1 && !strcasecmp("rdnis", member.argv[0])) {
00920 if (chan->redirecting.from.number.valid
00921 && chan->redirecting.from.number.str) {
00922 ast_copy_string(buf, chan->redirecting.from.number.str, len);
00923 }
00924 } else if (!strcasecmp("dnid", member.argv[0])) {
00925 if (member.argc == 1) {
00926
00927 member.argc = 2;
00928 member.argv[1] = "num";
00929 }
00930 if (!strncasecmp("num", member.argv[1], 3)) {
00931
00932
00933
00934
00935 if (member.argc == 2) {
00936
00937 if (chan->dialed.number.str) {
00938 ast_copy_string(buf, chan->dialed.number.str, len);
00939 }
00940 } else if (member.argc == 3 && !strcasecmp("plan", member.argv[2])) {
00941
00942 snprintf(buf, len, "%d", chan->dialed.number.plan);
00943 } else {
00944 ast_log(LOG_ERROR, "Unknown callerid data type '%s'.\n", data);
00945 }
00946 } else if (!strncasecmp("subaddr", member.argv[1], 7)) {
00947
00948
00949
00950
00951 status = party_subaddress_read(buf, len, member.argc - 2, member.argv + 2,
00952 &chan->dialed.subaddress);
00953 switch (status) {
00954 case ID_FIELD_VALID:
00955 case ID_FIELD_INVALID:
00956 break;
00957 default:
00958 ast_log(LOG_ERROR, "Unknown callerid data type '%s'.\n", data);
00959 break;
00960 }
00961 } else {
00962 ast_log(LOG_ERROR, "Unknown callerid data type '%s'.\n", data);
00963 }
00964 } else if (member.argc == 1 && !strcasecmp("ani2", member.argv[0])) {
00965 snprintf(buf, len, "%d", chan->caller.ani2);
00966 } else if (!strcasecmp("ani", member.argv[0])) {
00967 if (member.argc == 1) {
00968
00969 member.argc = 2;
00970 member.argv[1] = "num";
00971 }
00972 status = party_id_read(buf, len, member.argc - 1, member.argv + 1,
00973 &chan->caller.ani);
00974 switch (status) {
00975 case ID_FIELD_VALID:
00976 case ID_FIELD_INVALID:
00977 break;
00978 default:
00979 ast_log(LOG_ERROR, "Unknown callerid data type '%s'.\n", data);
00980 break;
00981 }
00982 } else {
00983 status = party_id_read(buf, len, member.argc, member.argv, &chan->caller.id);
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 }
00993
00994 ast_channel_unlock(chan);
00995 }
00996
00997 return 0;
00998 }
00999
01000
01001
01002
01003
01004
01005
01006
01007
01008
01009
01010
01011
01012 static int callerid_write(struct ast_channel *chan, const char *cmd, char *data, const char *value)
01013 {
01014 struct ast_party_caller caller;
01015 struct ast_party_dialed dialed;
01016 enum ID_FIELD_STATUS status;
01017 char *val;
01018 char *parms;
01019 struct ast_party_func_args args;
01020 struct ast_party_members member;
01021
01022 if (!value || !chan) {
01023 return -1;
01024 }
01025
01026 parms = ast_strdupa(data);
01027 AST_STANDARD_APP_ARGS(args, parms);
01028 if (args.argc == 0) {
01029
01030 return -1;
01031 }
01032
01033 AST_NONSTANDARD_APP_ARGS(member, args.member, '-');
01034 if (member.argc == 0 || ARRAY_LEN(member.subnames) <= member.argc) {
01035
01036 return -1;
01037 }
01038
01039 value = ast_skip_blanks(value);
01040
01041 ast_channel_lock(chan);
01042 if (member.argc == 1 && !strcasecmp("rdnis", member.argv[0])) {
01043 chan->redirecting.from.number.valid = 1;
01044 ast_free(chan->redirecting.from.number.str);
01045 chan->redirecting.from.number.str = ast_strdup(value);
01046 if (chan->cdr) {
01047 ast_cdr_setcid(chan->cdr, chan);
01048 }
01049 } else if (!strcasecmp("dnid", member.argv[0])) {
01050 ast_party_dialed_set_init(&dialed, &chan->dialed);
01051 if (member.argc == 1) {
01052
01053 member.argc = 2;
01054 member.argv[1] = "num";
01055 }
01056 if (!strncasecmp("num", member.argv[1], 3)) {
01057
01058
01059
01060
01061 if (member.argc == 2) {
01062
01063 dialed.number.str = ast_strdup(value);
01064 ast_trim_blanks(dialed.number.str);
01065 ast_party_dialed_set(&chan->dialed, &dialed);
01066 if (chan->cdr) {
01067 ast_cdr_setcid(chan->cdr, chan);
01068 }
01069 } else if (member.argc == 3 && !strcasecmp("plan", member.argv[2])) {
01070
01071 val = ast_strdupa(value);
01072 ast_trim_blanks(val);
01073
01074 if (('0' <= val[0]) && (val[0] <= '9')) {
01075 chan->dialed.number.plan = atoi(val);
01076 if (chan->cdr) {
01077 ast_cdr_setcid(chan->cdr, chan);
01078 }
01079 } else {
01080 ast_log(LOG_ERROR,
01081 "Unknown type-of-number/numbering-plan '%s', value unchanged\n", val);
01082 }
01083 } else {
01084 ast_log(LOG_ERROR, "Unknown callerid data type '%s'.\n", data);
01085 }
01086 } else if (!strncasecmp("subaddr", member.argv[1], 7)) {
01087
01088
01089
01090
01091 status = party_subaddress_write(&dialed.subaddress, member.argc - 2,
01092 member.argv + 2, value);
01093 switch (status) {
01094 case ID_FIELD_VALID:
01095 ast_party_dialed_set(&chan->dialed, &dialed);
01096 if (chan->cdr) {
01097 ast_cdr_setcid(chan->cdr, chan);
01098 }
01099 break;
01100 case ID_FIELD_INVALID:
01101 break;
01102 default:
01103 ast_log(LOG_ERROR, "Unknown callerid data type '%s'.\n", data);
01104 break;
01105 }
01106 } else {
01107 ast_log(LOG_ERROR, "Unknown callerid data type '%s'.\n", data);
01108 }
01109 ast_party_dialed_free(&dialed);
01110 } else if (member.argc == 1 && !strcasecmp("ani2", member.argv[0])) {
01111 val = ast_strdupa(value);
01112 ast_trim_blanks(val);
01113
01114 if (('0' <= val[0]) && (val[0] <= '9')) {
01115 chan->caller.ani2 = atoi(val);
01116 if (chan->cdr) {
01117 ast_cdr_setcid(chan->cdr, chan);
01118 }
01119 } else {
01120 ast_log(LOG_ERROR, "Unknown callerid ani2 '%s', value unchanged\n", val);
01121 }
01122 } else if (!strcasecmp("ani", member.argv[0])) {
01123 ast_party_caller_set_init(&caller, &chan->caller);
01124 if (member.argc == 1) {
01125
01126 member.argc = 2;
01127 member.argv[1] = "num";
01128 }
01129 status = party_id_write(&caller.ani, member.argc - 1, member.argv + 1, value);
01130 switch (status) {
01131 case ID_FIELD_VALID:
01132 ast_party_caller_set(&chan->caller, &caller, NULL);
01133 if (chan->cdr) {
01134 ast_cdr_setcid(chan->cdr, chan);
01135 }
01136 break;
01137 case ID_FIELD_INVALID:
01138 break;
01139 default:
01140 ast_log(LOG_ERROR, "Unknown callerid data type '%s'.\n", data);
01141 break;
01142 }
01143 ast_party_caller_free(&caller);
01144 } else {
01145 ast_party_caller_set_init(&caller, &chan->caller);
01146 status = party_id_write(&caller.id, member.argc, member.argv, value);
01147 switch (status) {
01148 case ID_FIELD_VALID:
01149 ast_channel_set_caller_event(chan, &caller, NULL);
01150 if (chan->cdr) {
01151 ast_cdr_setcid(chan->cdr, chan);
01152 }
01153 break;
01154 case ID_FIELD_INVALID:
01155 break;
01156 default:
01157 ast_log(LOG_ERROR, "Unknown callerid data type '%s'.\n", data);
01158 break;
01159 }
01160 ast_party_caller_free(&caller);
01161 }
01162 ast_channel_unlock(chan);
01163
01164 return 0;
01165 }
01166
01167
01168
01169
01170
01171
01172
01173
01174
01175
01176
01177
01178
01179
01180 static int connectedline_read(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
01181 {
01182 struct ast_party_members member;
01183 char *read_what;
01184 enum ID_FIELD_STATUS status;
01185
01186
01187 *buf = 0;
01188
01189 if (!chan) {
01190 return -1;
01191 }
01192
01193 read_what = ast_strdupa(data);
01194 AST_NONSTANDARD_APP_ARGS(member, read_what, '-');
01195 if (member.argc == 0 || ARRAY_LEN(member.subnames) <= member.argc) {
01196
01197 return -1;
01198 }
01199
01200 ast_channel_lock(chan);
01201
01202 if (member.argc == 1 && !strcasecmp("source", member.argv[0])) {
01203 ast_copy_string(buf, ast_connected_line_source_name(chan->connected.source), len);
01204 } else {
01205 status = party_id_read(buf, len, member.argc, member.argv, &chan->connected.id);
01206 switch (status) {
01207 case ID_FIELD_VALID:
01208 case ID_FIELD_INVALID:
01209 break;
01210 default:
01211 ast_log(LOG_ERROR, "Unknown connectedline data type '%s'.\n", data);
01212 break;
01213 }
01214 }
01215
01216 ast_channel_unlock(chan);
01217
01218 return 0;
01219 }
01220
01221
01222
01223
01224
01225
01226
01227
01228
01229
01230
01231
01232
01233 static int connectedline_write(struct ast_channel *chan, const char *cmd, char *data, const char *value)
01234 {
01235 struct ast_party_connected_line connected;
01236 enum ID_FIELD_STATUS status;
01237 char *val;
01238 char *parms;
01239 void (*set_it)(struct ast_channel *chan, const struct ast_party_connected_line *connected, const struct ast_set_party_connected_line *update);
01240 struct ast_party_func_args args;
01241 struct ast_party_members member;
01242 struct ast_flags opts;
01243 char *opt_args[CONNECTED_LINE_OPT_ARG_ARRAY_SIZE];
01244
01245 if (!value || !chan) {
01246 return -1;
01247 }
01248
01249 parms = ast_strdupa(data);
01250 AST_STANDARD_APP_ARGS(args, parms);
01251 if (args.argc == 0) {
01252
01253 return -1;
01254 }
01255
01256 AST_NONSTANDARD_APP_ARGS(member, args.member, '-');
01257 if (member.argc == 0 || ARRAY_LEN(member.subnames) <= member.argc) {
01258
01259 return -1;
01260 }
01261
01262 if (ast_app_parse_options(connectedline_opts, &opts, opt_args, args.opts)) {
01263
01264 return -1;
01265 }
01266
01267
01268 if (ast_test_flag(&opts, CONNECTED_LINE_OPT_INHIBIT)) {
01269 set_it = ast_channel_set_connected_line;
01270 } else {
01271 set_it = ast_channel_update_connected_line;
01272 }
01273
01274 ast_channel_lock(chan);
01275 ast_party_connected_line_set_init(&connected, &chan->connected);
01276 ast_channel_unlock(chan);
01277
01278 value = ast_skip_blanks(value);
01279
01280 if (member.argc == 1 && !strcasecmp("source", member.argv[0])) {
01281 int source;
01282
01283 val = ast_strdupa(value);
01284 ast_trim_blanks(val);
01285
01286 if (('0' <= val[0]) && (val[0] <= '9')) {
01287 source = atoi(val);
01288 } else {
01289 source = ast_connected_line_source_parse(val);
01290 }
01291
01292 if (source < 0) {
01293 ast_log(LOG_ERROR, "Unknown connectedline source '%s', value unchanged\n", val);
01294 } else {
01295 connected.source = source;
01296 set_it(chan, &connected, NULL);
01297 }
01298 } else {
01299 status = party_id_write(&connected.id, member.argc, member.argv, value);
01300 switch (status) {
01301 case ID_FIELD_VALID:
01302 set_it(chan, &connected, NULL);
01303 break;
01304 case ID_FIELD_INVALID:
01305 break;
01306 default:
01307 ast_log(LOG_ERROR, "Unknown connectedline data type '%s'.\n", data);
01308 break;
01309 }
01310 ast_party_connected_line_free(&connected);
01311 }
01312
01313 return 0;
01314 }
01315
01316
01317
01318
01319
01320
01321
01322
01323
01324
01325
01326
01327
01328
01329 static int redirecting_read(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
01330 {
01331 struct ast_party_members member;
01332 char *read_what;
01333 enum ID_FIELD_STATUS status;
01334
01335
01336 *buf = 0;
01337
01338 if (!chan) {
01339 return -1;
01340 }
01341
01342 read_what = ast_strdupa(data);
01343 AST_NONSTANDARD_APP_ARGS(member, read_what, '-');
01344 if (member.argc == 0 || ARRAY_LEN(member.subnames) <= member.argc) {
01345
01346 return -1;
01347 }
01348
01349 ast_channel_lock(chan);
01350
01351 if (!strcasecmp("from", member.argv[0])) {
01352 status = party_id_read(buf, len, member.argc - 1, member.argv + 1,
01353 &chan->redirecting.from);
01354 switch (status) {
01355 case ID_FIELD_VALID:
01356 case ID_FIELD_INVALID:
01357 break;
01358 default:
01359 ast_log(LOG_ERROR, "Unknown redirecting data type '%s'.\n", data);
01360 break;
01361 }
01362 } else if (!strcasecmp("to", member.argv[0])) {
01363 status = party_id_read(buf, len, member.argc - 1, member.argv + 1,
01364 &chan->redirecting.to);
01365 switch (status) {
01366 case ID_FIELD_VALID:
01367 case ID_FIELD_INVALID:
01368 break;
01369 default:
01370 ast_log(LOG_ERROR, "Unknown redirecting data type '%s'.\n", data);
01371 break;
01372 }
01373 } else if (member.argc == 1 && !strncasecmp("pres", member.argv[0], 4)) {
01374
01375
01376
01377
01378 ast_copy_string(buf,
01379 ast_named_caller_presentation(
01380 ast_party_id_presentation(&chan->redirecting.from)), len);
01381 } else if (member.argc == 1 && !strcasecmp("reason", member.argv[0])) {
01382 ast_copy_string(buf, ast_redirecting_reason_name(chan->redirecting.reason), len);
01383 } else if (member.argc == 1 && !strcasecmp("count", member.argv[0])) {
01384 snprintf(buf, len, "%d", chan->redirecting.count);
01385 } else {
01386 ast_log(LOG_ERROR, "Unknown redirecting data type '%s'.\n", data);
01387 }
01388
01389 ast_channel_unlock(chan);
01390
01391 return 0;
01392 }
01393
01394
01395
01396
01397
01398
01399
01400
01401
01402
01403
01404
01405
01406 static int redirecting_write(struct ast_channel *chan, const char *cmd, char *data, const char *value)
01407 {
01408 struct ast_party_redirecting redirecting;
01409 enum ID_FIELD_STATUS status;
01410 char *val;
01411 char *parms;
01412 void (*set_it)(struct ast_channel *chan, const struct ast_party_redirecting *redirecting, const struct ast_set_party_redirecting *update);
01413 struct ast_party_func_args args;
01414 struct ast_party_members member;
01415 struct ast_flags opts;
01416 char *opt_args[REDIRECTING_OPT_ARG_ARRAY_SIZE];
01417
01418 if (!value || !chan) {
01419 return -1;
01420 }
01421
01422 parms = ast_strdupa(data);
01423 AST_STANDARD_APP_ARGS(args, parms);
01424 if (args.argc == 0) {
01425
01426 return -1;
01427 }
01428
01429 AST_NONSTANDARD_APP_ARGS(member, args.member, '-');
01430 if (member.argc == 0 || ARRAY_LEN(member.subnames) <= member.argc) {
01431
01432 return -1;
01433 }
01434
01435 if (ast_app_parse_options(redirecting_opts, &opts, opt_args, args.opts)) {
01436
01437 return -1;
01438 }
01439
01440
01441 if (ast_test_flag(&opts, REDIRECTING_OPT_INHIBIT)) {
01442 set_it = ast_channel_set_redirecting;
01443 } else {
01444 set_it = ast_channel_update_redirecting;
01445 }
01446
01447 ast_channel_lock(chan);
01448 ast_party_redirecting_set_init(&redirecting, &chan->redirecting);
01449 ast_channel_unlock(chan);
01450
01451 value = ast_skip_blanks(value);
01452
01453 if (!strcasecmp("from", member.argv[0])) {
01454 status = party_id_write(&redirecting.from, member.argc - 1, member.argv + 1,
01455 value);
01456 switch (status) {
01457 case ID_FIELD_VALID:
01458 set_it(chan, &redirecting, NULL);
01459 break;
01460 case ID_FIELD_INVALID:
01461 break;
01462 default:
01463 ast_log(LOG_ERROR, "Unknown redirecting data type '%s'.\n", data);
01464 break;
01465 }
01466 ast_party_redirecting_free(&redirecting);
01467 } else if (!strcasecmp("to", member.argv[0])) {
01468 status = party_id_write(&redirecting.to, member.argc - 1, member.argv + 1, value);
01469 switch (status) {
01470 case ID_FIELD_VALID:
01471 set_it(chan, &redirecting, NULL);
01472 break;
01473 case ID_FIELD_INVALID:
01474 break;
01475 default:
01476 ast_log(LOG_ERROR, "Unknown redirecting data type '%s'.\n", data);
01477 break;
01478 }
01479 ast_party_redirecting_free(&redirecting);
01480 } else if (member.argc == 1 && !strncasecmp("pres", member.argv[0], 4)) {
01481 int pres;
01482
01483 val = ast_strdupa(value);
01484 ast_trim_blanks(val);
01485
01486 if (('0' <= val[0]) && (val[0] <= '9')) {
01487 pres = atoi(val);
01488 } else {
01489 pres = ast_parse_caller_presentation(val);
01490 }
01491
01492 if (pres < 0) {
01493 ast_log(LOG_ERROR,
01494 "Unknown redirecting combined presentation '%s', value unchanged\n", val);
01495 } else {
01496 redirecting.from.name.presentation = pres;
01497 redirecting.from.number.presentation = pres;
01498 redirecting.to.name.presentation = pres;
01499 redirecting.to.number.presentation = pres;
01500 set_it(chan, &redirecting, NULL);
01501 }
01502 } else if (member.argc == 1 && !strcasecmp("reason", member.argv[0])) {
01503 int reason;
01504
01505 val = ast_strdupa(value);
01506 ast_trim_blanks(val);
01507
01508 if (('0' <= val[0]) && (val[0] <= '9')) {
01509 reason = atoi(val);
01510 } else {
01511 reason = ast_redirecting_reason_parse(val);
01512 }
01513
01514 if (reason < 0) {
01515 ast_log(LOG_ERROR, "Unknown redirecting reason '%s', value unchanged\n", val);
01516 } else {
01517 redirecting.reason = reason;
01518 set_it(chan, &redirecting, NULL);
01519 }
01520 } else if (member.argc == 1 && !strcasecmp("count", member.argv[0])) {
01521 val = ast_strdupa(value);
01522 ast_trim_blanks(val);
01523
01524 if (('0' <= val[0]) && (val[0] <= '9')) {
01525 redirecting.count = atoi(val);
01526 set_it(chan, &redirecting, NULL);
01527 } else {
01528 ast_log(LOG_ERROR, "Unknown redirecting count '%s', value unchanged\n", val);
01529 }
01530 } else {
01531 ast_log(LOG_ERROR, "Unknown redirecting data type '%s'.\n", data);
01532 }
01533
01534 return 0;
01535 }
01536
01537 static struct ast_custom_function callerid_function = {
01538 .name = "CALLERID",
01539 .read = callerid_read,
01540 .read_max = 256,
01541 .write = callerid_write,
01542 };
01543
01544 static struct ast_custom_function callerpres_function = {
01545 .name = "CALLERPRES",
01546 .read = callerpres_read,
01547 .read_max = 50,
01548 .write = callerpres_write,
01549 };
01550
01551 static struct ast_custom_function connectedline_function = {
01552 .name = "CONNECTEDLINE",
01553 .read = connectedline_read,
01554 .write = connectedline_write,
01555 };
01556
01557 static struct ast_custom_function redirecting_function = {
01558 .name = "REDIRECTING",
01559 .read = redirecting_read,
01560 .write = redirecting_write,
01561 };
01562
01563
01564
01565
01566
01567
01568
01569
01570 static int unload_module(void)
01571 {
01572 int res;
01573
01574 res = ast_custom_function_unregister(&callerpres_function);
01575 res |= ast_custom_function_unregister(&callerid_function);
01576 res |= ast_custom_function_unregister(&connectedline_function);
01577 res |= ast_custom_function_unregister(&redirecting_function);
01578 return res;
01579 }
01580
01581
01582
01583
01584
01585
01586
01587
01588 static int load_module(void)
01589 {
01590 int res;
01591
01592 res = ast_custom_function_register(&callerpres_function);
01593 res |= ast_custom_function_register(&callerid_function);
01594 res |= ast_custom_function_register(&connectedline_function);
01595 res |= ast_custom_function_register(&redirecting_function);
01596 return res ? AST_MODULE_LOAD_DECLINE : AST_MODULE_LOAD_SUCCESS;
01597 }
01598
01599
01600 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Party ID related dialplan functions (Caller-ID, Connected-line, Redirecting)");