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 #include "asterisk/datastore.h"
00033 #include "asterisk/channel.h"
00034 #include "asterisk/logger.h"
00035 #include "asterisk/audiohook.h"
00036 #include "asterisk/pbx.h"
00037 #include "asterisk/module.h"
00038
00039
00040
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 struct inheritable_audiohook {
00092 AST_LIST_ENTRY(inheritable_audiohook) list;
00093 char source[1];
00094 };
00095
00096 struct audiohook_inheritance_datastore {
00097 AST_LIST_HEAD (, inheritable_audiohook) allowed_list;
00098 };
00099
00100 static void audiohook_inheritance_fixup(void *data, struct ast_channel *old_chan, struct ast_channel *new_chan);
00101 static void audiohook_inheritance_destroy (void *data);
00102 static const struct ast_datastore_info audiohook_inheritance_info = {
00103 .type = "audiohook inheritance",
00104 .destroy = audiohook_inheritance_destroy,
00105 .chan_fixup = audiohook_inheritance_fixup,
00106 };
00107
00108
00109
00110
00111
00112
00113
00114
00115
00116
00117 static void audiohook_inheritance_fixup(void *data, struct ast_channel *old_chan, struct ast_channel *new_chan)
00118 {
00119 struct inheritable_audiohook *audiohook = NULL;
00120 struct audiohook_inheritance_datastore *datastore = data;
00121
00122 ast_debug(2, "inheritance fixup occurring for channels %s(%p) and %s(%p)", old_chan->name, old_chan, new_chan->name, new_chan);
00123
00124 AST_LIST_TRAVERSE(&datastore->allowed_list, audiohook, list) {
00125 ast_audiohook_move_by_source(old_chan, new_chan, audiohook->source);
00126 ast_debug(3, "Moved audiohook %s from %s(%p) to %s(%p)\n",
00127 audiohook->source, old_chan->name, old_chan, new_chan->name, new_chan);
00128 }
00129 return;
00130 }
00131
00132
00133
00134
00135
00136
00137 static void audiohook_inheritance_destroy(void *data)
00138 {
00139 struct audiohook_inheritance_datastore *audiohook_inheritance_datastore = data;
00140 struct inheritable_audiohook *inheritable_audiohook = NULL;
00141
00142 while ((inheritable_audiohook = AST_LIST_REMOVE_HEAD(&audiohook_inheritance_datastore->allowed_list, list))) {
00143 ast_free(inheritable_audiohook);
00144 }
00145
00146 ast_free(audiohook_inheritance_datastore);
00147 }
00148
00149
00150
00151
00152
00153
00154 static struct audiohook_inheritance_datastore *setup_inheritance_datastore(struct ast_channel *chan)
00155 {
00156 struct ast_datastore *datastore = NULL;
00157 struct audiohook_inheritance_datastore *audiohook_inheritance_datastore = NULL;
00158
00159 if (!(datastore = ast_datastore_alloc(&audiohook_inheritance_info, NULL))) {
00160 return NULL;
00161 }
00162
00163 if (!(audiohook_inheritance_datastore = ast_calloc(1, sizeof(*audiohook_inheritance_datastore)))) {
00164 ast_datastore_free(datastore);
00165 return NULL;
00166 }
00167
00168 datastore->data = audiohook_inheritance_datastore;
00169 ast_channel_lock(chan);
00170 ast_channel_datastore_add(chan, datastore);
00171 ast_channel_unlock(chan);
00172 return audiohook_inheritance_datastore;
00173 }
00174
00175
00176
00177
00178
00179
00180
00181
00182 static int setup_inheritable_audiohook(struct audiohook_inheritance_datastore *audiohook_inheritance_datastore, const char *source)
00183 {
00184 struct inheritable_audiohook *inheritable_audiohook = NULL;
00185
00186 inheritable_audiohook = ast_calloc(1, sizeof(*inheritable_audiohook) + strlen(source));
00187
00188 if (!inheritable_audiohook) {
00189 return -1;
00190 }
00191
00192 strcpy(inheritable_audiohook->source, source);
00193 AST_LIST_INSERT_TAIL(&audiohook_inheritance_datastore->allowed_list, inheritable_audiohook, list);
00194 ast_debug(3, "Set audiohook %s to be inheritable\n", source);
00195 return 0;
00196 }
00197
00198
00199
00200
00201
00202
00203
00204
00205
00206
00207 static int func_inheritance_write(struct ast_channel *chan, const char *function, char *data, const char *value)
00208 {
00209 int allow;
00210 struct ast_datastore *datastore = NULL;
00211 struct audiohook_inheritance_datastore *inheritance_datastore = NULL;
00212 struct inheritable_audiohook *inheritable_audiohook;
00213
00214
00215 if (ast_strlen_zero(data)) {
00216 ast_log(LOG_WARNING, "No argument provided to INHERITANCE function.\n");
00217 return -1;
00218 }
00219
00220 if (ast_strlen_zero(value)) {
00221 ast_log(LOG_WARNING, "No value provided to INHERITANCE function.\n");
00222 return -1;
00223 }
00224
00225 allow = ast_true(value);
00226
00227
00228 ast_channel_lock(chan);
00229 if (!(datastore = ast_channel_datastore_find(chan, &audiohook_inheritance_info, NULL))) {
00230 ast_channel_unlock(chan);
00231
00232 if (!allow) {
00233 ast_debug(1, "Audiohook %s is already set to not be inheritable on channel %s\n", data, chan->name);
00234 return 0;
00235 } else if (!(inheritance_datastore = setup_inheritance_datastore(chan))) {
00236 ast_log(LOG_WARNING, "Unable to set up audiohook inheritance datastore on channel %s\n", chan->name);
00237 return -1;
00238 } else {
00239 return setup_inheritable_audiohook(inheritance_datastore, data);
00240 }
00241 } else {
00242 inheritance_datastore = datastore->data;
00243 }
00244 ast_channel_unlock(chan);
00245
00246
00247
00248 AST_LIST_TRAVERSE_SAFE_BEGIN(&inheritance_datastore->allowed_list, inheritable_audiohook, list) {
00249 if (!strcasecmp(inheritable_audiohook->source, data)) {
00250 if (allow) {
00251 ast_debug(2, "Audiohook source %s is already set up to be inherited from channel %s\n", data, chan->name);
00252 return 0;
00253 } else {
00254 ast_debug(2, "Removing inheritability of audiohook %s from channel %s\n", data, chan->name);
00255 AST_LIST_REMOVE_CURRENT(list);
00256 ast_free(inheritable_audiohook);
00257 return 0;
00258 }
00259 }
00260 }
00261 AST_LIST_TRAVERSE_SAFE_END;
00262
00263
00264
00265
00266
00267
00268
00269 if (allow) {
00270 return setup_inheritable_audiohook(inheritance_datastore, data);
00271 } else {
00272 ast_debug(1, "Audiohook %s is already set to not be inheritable on channel %s\n", data, chan->name);
00273 return 0;
00274 }
00275 }
00276
00277 static struct ast_custom_function inheritance_function = {
00278 .name = "AUDIOHOOK_INHERIT",
00279 .write = func_inheritance_write,
00280 };
00281
00282 static int unload_module(void)
00283 {
00284 return ast_custom_function_unregister(&inheritance_function);
00285 }
00286
00287 static int load_module(void)
00288 {
00289 if (ast_custom_function_register(&inheritance_function)) {
00290 return AST_MODULE_LOAD_DECLINE;
00291 } else {
00292 return AST_MODULE_LOAD_SUCCESS;
00293 }
00294 }
00295 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Audiohook inheritance function");