res/res_ari_channels.c

   1 /*
   2  * Asterisk -- An open source telephony toolkit.
   3  *
   4  * Copyright (C) 2012 - 2013, Digium, Inc.
   5  *
   6  * David M. Lee, II <dlee@digium.com>
   7  *
   8  * See http://www.asterisk.org for more information about
   9  * the Asterisk project. Please do not directly contact
  10  * any of the maintainers of this project for assistance;
  11  * the project provides a web site, mailing lists and IRC
  12  * channels for your use.
  13  *
  14  * This program is free software, distributed under the terms of
  15  * the GNU General Public License Version 2. See the LICENSE file
  16  * at the top of the source tree.
  17  */
  18
  19 /*
  20  * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  21  * !!!!!                               DO NOT EDIT                        !!!!!
  22  * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  23  * This file is generated by a mustache template. Please see the original
  24  * template in rest-api-templates/res_ari_resource.c.mustache
  25  */
  26
  27 /*! \file
  28  *
  29  * \brief Channel resources
  30  *
  31  * \author David M. Lee, II <dlee@digium.com>
  32  */
  33
  34 /*** MODULEINFO
  35         <depend type="module">res_ari</depend>
  36         <depend type="module">res_stasis</depend>
  37         <support_level>core</support_level>
  38  ***/
  39
  40 #include "asterisk.h"
  41
  42 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
  43
  44 #include "asterisk/app.h"
  45 #include "asterisk/module.h"
  46 #include "asterisk/stasis_app.h"
  47 #include "ari/resource_channels.h"
  48 #if defined(AST_DEVMODE)
  49 #include "ari/ari_model_validators.h"
  50 #endif
  51
  52 #define MAX_VALS 128
  53
  54 /*!
  55  * \brief Parameter parsing callback for /channels.
  56  * \param get_params GET parameters in the HTTP request.
  57  * \param path_vars Path variables extracted from the request.
  58  * \param headers HTTP headers.
  59  * \param[out] response Response to the HTTP request.
  60  */
  61 static void ast_ari_channels_list_cb(
  62         struct ast_variable *get_params, struct ast_variable *path_vars,
  63         struct ast_variable *headers, struct ast_ari_response *response)
  64 {
  65         struct ast_ari_channels_list_args args = {};
  66 #if defined(AST_DEVMODE)
  67         int is_valid;
  68         int code;
  69 #endif /* AST_DEVMODE */
  70
  71         ast_ari_channels_list(headers, &args, response);
  72 #if defined(AST_DEVMODE)
  73         code = response->response_code;
  74
  75         switch (code) {
  76         case 0: /* Implementation is still a stub, or the code wasn't set */
  77                 is_valid = response->message == NULL;
  78                 break;
  79         case 500: /* Internal Server Error */
  80         case 501: /* Not Implemented */
  81                 is_valid = 1;
  82                 break;
  83         default:
  84                 if (200 <= code && code <= 299) {
  85                         is_valid = ast_ari_validate_list(response->message,
  86                                 ast_ari_validate_channel_fn());
  87                 } else {
  88                         ast_log(LOG_ERROR, "Invalid error response %d for /channels\n", code);
  89                         is_valid = 0;
  90                 }
  91         }
  92
  93         if (!is_valid) {
  94                 ast_log(LOG_ERROR, "Response validation failed for /channels\n");
  95                 ast_ari_response_error(response, 500,
  96                         "Internal Server Error", "Response validation failed");
  97         }
  98 #endif /* AST_DEVMODE */
  99
 100 fin: __attribute__((unused))
 101         return;
 102 }
 103 /*!
 104  * \brief Parameter parsing callback for /channels.
 105  * \param get_params GET parameters in the HTTP request.
 106  * \param path_vars Path variables extracted from the request.
 107  * \param headers HTTP headers.
 108  * \param[out] response Response to the HTTP request.
 109  */
 110 static void ast_ari_channels_originate_cb(
 111         struct ast_variable *get_params, struct ast_variable *path_vars,
 112         struct ast_variable *headers, struct ast_ari_response *response)
 113 {
 114         struct ast_ari_channels_originate_args args = {};
 115         struct ast_variable *i;
 116 #if defined(AST_DEVMODE)
 117         int is_valid;
 118         int code;
 119 #endif /* AST_DEVMODE */
 120
 121         for (i = get_params; i; i = i->next) {
 122                 if (strcmp(i->name, "endpoint") == 0) {
 123                         args.endpoint = (i->value);
 124                 } else
 125                 if (strcmp(i->name, "extension") == 0) {
 126                         args.extension = (i->value);
 127                 } else
 128                 if (strcmp(i->name, "context") == 0) {
 129                         args.context = (i->value);
 130                 } else
 131                 if (strcmp(i->name, "priority") == 0) {
 132                         args.priority = atol(i->value);
 133                 } else
 134                 if (strcmp(i->name, "app") == 0) {
 135                         args.app = (i->value);
 136                 } else
 137                 if (strcmp(i->name, "appArgs") == 0) {
 138                         args.app_args = (i->value);
 139                 } else
 140                 if (strcmp(i->name, "callerId") == 0) {
 141                         args.caller_id = (i->value);
 142                 } else
 143                 if (strcmp(i->name, "timeout") == 0) {
 144                         args.timeout = atoi(i->value);
 145                 } else
 146                 {}
 147         }
 148         ast_ari_channels_originate(headers, &args, response);
 149 #if defined(AST_DEVMODE)
 150         code = response->response_code;
 151
 152         switch (code) {
 153         case 0: /* Implementation is still a stub, or the code wasn't set */
 154                 is_valid = response->message == NULL;
 155                 break;
 156         case 500: /* Internal Server Error */
 157         case 501: /* Not Implemented */
 158         case 400: /* Invalid parameters for originating a channel. */
 159                 is_valid = 1;
 160                 break;
 161         default:
 162                 if (200 <= code && code <= 299) {
 163                         is_valid = ast_ari_validate_channel(
 164                                 response->message);
 165                 } else {
 166                         ast_log(LOG_ERROR, "Invalid error response %d for /channels\n", code);
 167                         is_valid = 0;
 168                 }
 169         }
 170
 171         if (!is_valid) {
 172                 ast_log(LOG_ERROR, "Response validation failed for /channels\n");
 173                 ast_ari_response_error(response, 500,
 174                         "Internal Server Error", "Response validation failed");
 175         }
 176 #endif /* AST_DEVMODE */
 177
 178 fin: __attribute__((unused))
 179         return;
 180 }
 181 /*!
 182  * \brief Parameter parsing callback for /channels/{channelId}.
 183  * \param get_params GET parameters in the HTTP request.
 184  * \param path_vars Path variables extracted from the request.
 185  * \param headers HTTP headers.
 186  * \param[out] response Response to the HTTP request.
 187  */
 188 static void ast_ari_channels_get_cb(
 189         struct ast_variable *get_params, struct ast_variable *path_vars,
 190         struct ast_variable *headers, struct ast_ari_response *response)
 191 {
 192         struct ast_ari_channels_get_args args = {};
 193         struct ast_variable *i;
 194 #if defined(AST_DEVMODE)
 195         int is_valid;
 196         int code;
 197 #endif /* AST_DEVMODE */
 198
 199         for (i = path_vars; i; i = i->next) {
 200                 if (strcmp(i->name, "channelId") == 0) {
 201                         args.channel_id = (i->value);
 202                 } else
 203                 {}
 204         }
 205         ast_ari_channels_get(headers, &args, response);
 206 #if defined(AST_DEVMODE)
 207         code = response->response_code;
 208
 209         switch (code) {
 210         case 0: /* Implementation is still a stub, or the code wasn't set */
 211                 is_valid = response->message == NULL;
 212                 break;
 213         case 500: /* Internal Server Error */
 214         case 501: /* Not Implemented */
 215         case 404: /* Channel not found */
 216                 is_valid = 1;
 217                 break;
 218         default:
 219                 if (200 <= code && code <= 299) {
 220                         is_valid = ast_ari_validate_channel(
 221                                 response->message);
 222                 } else {
 223                         ast_log(LOG_ERROR, "Invalid error response %d for /channels/{channelId}\n", code);
 224                         is_valid = 0;
 225                 }
 226         }
 227
 228         if (!is_valid) {
 229                 ast_log(LOG_ERROR, "Response validation failed for /channels/{channelId}\n");
 230                 ast_ari_response_error(response, 500,
 231                         "Internal Server Error", "Response validation failed");
 232         }
 233 #endif /* AST_DEVMODE */
 234
 235 fin: __attribute__((unused))
 236         return;
 237 }
 238 /*!
 239  * \brief Parameter parsing callback for /channels/{channelId}.
 240  * \param get_params GET parameters in the HTTP request.
 241  * \param path_vars Path variables extracted from the request.
 242  * \param headers HTTP headers.
 243  * \param[out] response Response to the HTTP request.
 244  */
 245 static void ast_ari_channels_hangup_cb(
 246         struct ast_variable *get_params, struct ast_variable *path_vars,
 247         struct ast_variable *headers, struct ast_ari_response *response)
 248 {
 249         struct ast_ari_channels_hangup_args args = {};
 250         struct ast_variable *i;
 251 #if defined(AST_DEVMODE)
 252         int is_valid;
 253         int code;
 254 #endif /* AST_DEVMODE */
 255
 256         for (i = get_params; i; i = i->next) {
 257                 if (strcmp(i->name, "reason") == 0) {
 258                         args.reason = (i->value);
 259                 } else
 260                 {}
 261         }
 262         for (i = path_vars; i; i = i->next) {
 263                 if (strcmp(i->name, "channelId") == 0) {
 264                         args.channel_id = (i->value);
 265                 } else
 266                 {}
 267         }
 268         ast_ari_channels_hangup(headers, &args, response);
 269 #if defined(AST_DEVMODE)
 270         code = response->response_code;
 271
 272         switch (code) {
 273         case 0: /* Implementation is still a stub, or the code wasn't set */
 274                 is_valid = response->message == NULL;
 275                 break;
 276         case 500: /* Internal Server Error */
 277         case 501: /* Not Implemented */
 278         case 400: /* Invalid reason for hangup provided */
 279         case 404: /* Channel not found */
 280                 is_valid = 1;
 281                 break;
 282         default:
 283                 if (200 <= code && code <= 299) {
 284                         is_valid = ast_ari_validate_void(
 285                                 response->message);
 286                 } else {
 287                         ast_log(LOG_ERROR, "Invalid error response %d for /channels/{channelId}\n", code);
 288                         is_valid = 0;
 289                 }
 290         }
 291
 292         if (!is_valid) {
 293                 ast_log(LOG_ERROR, "Response validation failed for /channels/{channelId}\n");
 294                 ast_ari_response_error(response, 500,
 295                         "Internal Server Error", "Response validation failed");
 296         }
 297 #endif /* AST_DEVMODE */
 298
 299 fin: __attribute__((unused))
 300         return;
 301 }
 302 /*!
 303  * \brief Parameter parsing callback for /channels/{channelId}/continue.
 304  * \param get_params GET parameters in the HTTP request.
 305  * \param path_vars Path variables extracted from the request.
 306  * \param headers HTTP headers.
 307  * \param[out] response Response to the HTTP request.
 308  */
 309 static void ast_ari_channels_continue_in_dialplan_cb(
 310         struct ast_variable *get_params, struct ast_variable *path_vars,
 311         struct ast_variable *headers, struct ast_ari_response *response)
 312 {
 313         struct ast_ari_channels_continue_in_dialplan_args args = {};
 314         struct ast_variable *i;
 315 #if defined(AST_DEVMODE)
 316         int is_valid;
 317         int code;
 318 #endif /* AST_DEVMODE */
 319
 320         for (i = get_params; i; i = i->next) {
 321                 if (strcmp(i->name, "context") == 0) {
 322                         args.context = (i->value);
 323                 } else
 324                 if (strcmp(i->name, "extension") == 0) {
 325                         args.extension = (i->value);
 326                 } else
 327                 if (strcmp(i->name, "priority") == 0) {
 328                         args.priority = atoi(i->value);
 329                 } else
 330                 {}
 331         }
 332         for (i = path_vars; i; i = i->next) {
 333                 if (strcmp(i->name, "channelId") == 0) {
 334                         args.channel_id = (i->value);
 335                 } else
 336                 {}
 337         }
 338         ast_ari_channels_continue_in_dialplan(headers, &args, response);
 339 #if defined(AST_DEVMODE)
 340         code = response->response_code;
 341
 342         switch (code) {
 343         case 0: /* Implementation is still a stub, or the code wasn't set */
 344                 is_valid = response->message == NULL;
 345                 break;
 346         case 500: /* Internal Server Error */
 347         case 501: /* Not Implemented */
 348         case 404: /* Channel not found */
 349         case 409: /* Channel not in a Stasis application */
 350                 is_valid = 1;
 351                 break;
 352         default:
 353                 if (200 <= code && code <= 299) {
 354                         is_valid = ast_ari_validate_void(
 355                                 response->message);
 356                 } else {
 357                         ast_log(LOG_ERROR, "Invalid error response %d for /channels/{channelId}/continue\n", code);
 358                         is_valid = 0;
 359                 }
 360         }
 361
 362         if (!is_valid) {
 363                 ast_log(LOG_ERROR, "Response validation failed for /channels/{channelId}/continue\n");
 364                 ast_ari_response_error(response, 500,
 365                         "Internal Server Error", "Response validation failed");
 366         }
 367 #endif /* AST_DEVMODE */
 368
 369 fin: __attribute__((unused))
 370         return;
 371 }
 372 /*!
 373  * \brief Parameter parsing callback for /channels/{channelId}/answer.
 374  * \param get_params GET parameters in the HTTP request.
 375  * \param path_vars Path variables extracted from the request.
 376  * \param headers HTTP headers.
 377  * \param[out] response Response to the HTTP request.
 378  */
 379 static void ast_ari_channels_answer_cb(
 380         struct ast_variable *get_params, struct ast_variable *path_vars,
 381         struct ast_variable *headers, struct ast_ari_response *response)
 382 {
 383         struct ast_ari_channels_answer_args args = {};
 384         struct ast_variable *i;
 385 #if defined(AST_DEVMODE)
 386         int is_valid;
 387         int code;
 388 #endif /* AST_DEVMODE */
 389
 390         for (i = path_vars; i; i = i->next) {
 391                 if (strcmp(i->name, "channelId") == 0) {
 392                         args.channel_id = (i->value);
 393                 } else
 394                 {}
 395         }
 396         ast_ari_channels_answer(headers, &args, response);
 397 #if defined(AST_DEVMODE)
 398         code = response->response_code;
 399
 400         switch (code) {
 401         case 0: /* Implementation is still a stub, or the code wasn't set */
 402                 is_valid = response->message == NULL;
 403                 break;
 404         case 500: /* Internal Server Error */
 405         case 501: /* Not Implemented */
 406         case 404: /* Channel not found */
 407         case 409: /* Channel not in a Stasis application */
 408                 is_valid = 1;
 409                 break;
 410         default:
 411                 if (200 <= code && code <= 299) {
 412                         is_valid = ast_ari_validate_void(
 413                                 response->message);
 414                 } else {
 415                         ast_log(LOG_ERROR, "Invalid error response %d for /channels/{channelId}/answer\n", code);
 416                         is_valid = 0;
 417                 }
 418         }
 419
 420         if (!is_valid) {
 421                 ast_log(LOG_ERROR, "Response validation failed for /channels/{channelId}/answer\n");
 422                 ast_ari_response_error(response, 500,
 423                         "Internal Server Error", "Response validation failed");
 424         }
 425 #endif /* AST_DEVMODE */
 426
 427 fin: __attribute__((unused))
 428         return;
 429 }
 430 /*!
 431  * \brief Parameter parsing callback for /channels/{channelId}/ring.
 432  * \param get_params GET parameters in the HTTP request.
 433  * \param path_vars Path variables extracted from the request.
 434  * \param headers HTTP headers.
 435  * \param[out] response Response to the HTTP request.
 436  */
 437 static void ast_ari_channels_ring_cb(
 438         struct ast_variable *get_params, struct ast_variable *path_vars,
 439         struct ast_variable *headers, struct ast_ari_response *response)
 440 {
 441         struct ast_ari_channels_ring_args args = {};
 442         struct ast_variable *i;
 443 #if defined(AST_DEVMODE)
 444         int is_valid;
 445         int code;
 446 #endif /* AST_DEVMODE */
 447
 448         for (i = path_vars; i; i = i->next) {
 449                 if (strcmp(i->name, "channelId") == 0) {
 450                         args.channel_id = (i->value);
 451                 } else
 452                 {}
 453         }
 454         ast_ari_channels_ring(headers, &args, response);
 455 #if defined(AST_DEVMODE)
 456         code = response->response_code;
 457
 458         switch (code) {
 459         case 0: /* Implementation is still a stub, or the code wasn't set */
 460                 is_valid = response->message == NULL;
 461                 break;
 462         case 500: /* Internal Server Error */
 463         case 501: /* Not Implemented */
 464         case 404: /* Channel not found */
 465         case 409: /* Channel not in a Stasis application */
 466                 is_valid = 1;
 467                 break;
 468         default:
 469                 if (200 <= code && code <= 299) {
 470                         is_valid = ast_ari_validate_void(
 471                                 response->message);
 472                 } else {
 473                         ast_log(LOG_ERROR, "Invalid error response %d for /channels/{channelId}/ring\n", code);
 474                         is_valid = 0;
 475                 }
 476         }
 477
 478         if (!is_valid) {
 479                 ast_log(LOG_ERROR, "Response validation failed for /channels/{channelId}/ring\n");
 480                 ast_ari_response_error(response, 500,
 481                         "Internal Server Error", "Response validation failed");
 482         }
 483 #endif /* AST_DEVMODE */
 484
 485 fin: __attribute__((unused))
 486         return;
 487 }
 488 /*!
 489  * \brief Parameter parsing callback for /channels/{channelId}/ring.
 490  * \param get_params GET parameters in the HTTP request.
 491  * \param path_vars Path variables extracted from the request.
 492  * \param headers HTTP headers.
 493  * \param[out] response Response to the HTTP request.
 494  */
 495 static void ast_ari_channels_ring_stop_cb(
 496         struct ast_variable *get_params, struct ast_variable *path_vars,
 497         struct ast_variable *headers, struct ast_ari_response *response)
 498 {
 499         struct ast_ari_channels_ring_stop_args args = {};
 500         struct ast_variable *i;
 501 #if defined(AST_DEVMODE)
 502         int is_valid;
 503         int code;
 504 #endif /* AST_DEVMODE */
 505
 506         for (i = path_vars; i; i = i->next) {
 507                 if (strcmp(i->name, "channelId") == 0) {
 508                         args.channel_id = (i->value);
 509                 } else
 510                 {}
 511         }
 512         ast_ari_channels_ring_stop(headers, &args, response);
 513 #if defined(AST_DEVMODE)
 514         code = response->response_code;
 515
 516         switch (code) {
 517         case 0: /* Implementation is still a stub, or the code wasn't set */
 518                 is_valid = response->message == NULL;
 519                 break;
 520         case 500: /* Internal Server Error */
 521         case 501: /* Not Implemented */
 522         case 404: /* Channel not found */
 523         case 409: /* Channel not in a Stasis application */
 524                 is_valid = 1;
 525                 break;
 526         default:
 527                 if (200 <= code && code <= 299) {
 528                         is_valid = ast_ari_validate_void(
 529                                 response->message);
 530                 } else {
 531                         ast_log(LOG_ERROR, "Invalid error response %d for /channels/{channelId}/ring\n", code);
 532                         is_valid = 0;
 533                 }
 534         }
 535
 536         if (!is_valid) {
 537                 ast_log(LOG_ERROR, "Response validation failed for /channels/{channelId}/ring\n");
 538                 ast_ari_response_error(response, 500,
 539                         "Internal Server Error", "Response validation failed");
 540         }
 541 #endif /* AST_DEVMODE */
 542
 543 fin: __attribute__((unused))
 544         return;
 545 }
 546 /*!
 547  * \brief Parameter parsing callback for /channels/{channelId}/dtmf.
 548  * \param get_params GET parameters in the HTTP request.
 549  * \param path_vars Path variables extracted from the request.
 550  * \param headers HTTP headers.
 551  * \param[out] response Response to the HTTP request.
 552  */
 553 static void ast_ari_channels_send_dtmf_cb(
 554         struct ast_variable *get_params, struct ast_variable *path_vars,
 555         struct ast_variable *headers, struct ast_ari_response *response)
 556 {
 557         struct ast_ari_channels_send_dtmf_args args = {};
 558         struct ast_variable *i;
 559 #if defined(AST_DEVMODE)
 560         int is_valid;
 561         int code;
 562 #endif /* AST_DEVMODE */
 563
 564         for (i = get_params; i; i = i->next) {
 565                 if (strcmp(i->name, "dtmf") == 0) {
 566                         args.dtmf = (i->value);
 567                 } else
 568                 if (strcmp(i->name, "before") == 0) {
 569                         args.before = atoi(i->value);
 570                 } else
 571                 if (strcmp(i->name, "between") == 0) {
 572                         args.between = atoi(i->value);
 573                 } else
 574                 if (strcmp(i->name, "duration") == 0) {
 575                         args.duration = atoi(i->value);
 576                 } else
 577                 if (strcmp(i->name, "after") == 0) {
 578                         args.after = atoi(i->value);
 579                 } else
 580                 {}
 581         }
 582         for (i = path_vars; i; i = i->next) {
 583                 if (strcmp(i->name, "channelId") == 0) {
 584                         args.channel_id = (i->value);
 585                 } else
 586                 {}
 587         }
 588         ast_ari_channels_send_dtmf(headers, &args, response);
 589 #if defined(AST_DEVMODE)
 590         code = response->response_code;
 591
 592         switch (code) {
 593         case 0: /* Implementation is still a stub, or the code wasn't set */
 594                 is_valid = response->message == NULL;
 595                 break;
 596         case 500: /* Internal Server Error */
 597         case 501: /* Not Implemented */
 598         case 400: /* DTMF is required */
 599         case 404: /* Channel not found */
 600         case 409: /* Channel not in a Stasis application */
 601                 is_valid = 1;
 602                 break;
 603         default:
 604                 if (200 <= code && code <= 299) {
 605                         is_valid = ast_ari_validate_void(
 606                                 response->message);
 607                 } else {
 608                         ast_log(LOG_ERROR, "Invalid error response %d for /channels/{channelId}/dtmf\n", code);
 609                         is_valid = 0;
 610                 }
 611         }
 612
 613         if (!is_valid) {
 614                 ast_log(LOG_ERROR, "Response validation failed for /channels/{channelId}/dtmf\n");
 615                 ast_ari_response_error(response, 500,
 616                         "Internal Server Error", "Response validation failed");
 617         }
 618 #endif /* AST_DEVMODE */
 619
 620 fin: __attribute__((unused))
 621         return;
 622 }
 623 /*!
 624  * \brief Parameter parsing callback for /channels/{channelId}/mute.
 625  * \param get_params GET parameters in the HTTP request.
 626  * \param path_vars Path variables extracted from the request.
 627  * \param headers HTTP headers.
 628  * \param[out] response Response to the HTTP request.
 629  */
 630 static void ast_ari_channels_mute_cb(
 631         struct ast_variable *get_params, struct ast_variable *path_vars,
 632         struct ast_variable *headers, struct ast_ari_response *response)
 633 {
 634         struct ast_ari_channels_mute_args args = {};
 635         struct ast_variable *i;
 636 #if defined(AST_DEVMODE)
 637         int is_valid;
 638         int code;
 639 #endif /* AST_DEVMODE */
 640
 641         for (i = get_params; i; i = i->next) {
 642                 if (strcmp(i->name, "direction") == 0) {
 643                         args.direction = (i->value);
 644                 } else
 645                 {}
 646         }
 647         for (i = path_vars; i; i = i->next) {
 648                 if (strcmp(i->name, "channelId") == 0) {
 649                         args.channel_id = (i->value);
 650                 } else
 651                 {}
 652         }
 653         ast_ari_channels_mute(headers, &args, response);
 654 #if defined(AST_DEVMODE)
 655         code = response->response_code;
 656
 657         switch (code) {
 658         case 0: /* Implementation is still a stub, or the code wasn't set */
 659                 is_valid = response->message == NULL;
 660                 break;
 661         case 500: /* Internal Server Error */
 662         case 501: /* Not Implemented */
 663         case 404: /* Channel not found */
 664         case 409: /* Channel not in a Stasis application */
 665                 is_valid = 1;
 666                 break;
 667         default:
 668                 if (200 <= code && code <= 299) {
 669                         is_valid = ast_ari_validate_void(
 670                                 response->message);
 671                 } else {
 672                         ast_log(LOG_ERROR, "Invalid error response %d for /channels/{channelId}/mute\n", code);
 673                         is_valid = 0;
 674                 }
 675         }
 676
 677         if (!is_valid) {
 678                 ast_log(LOG_ERROR, "Response validation failed for /channels/{channelId}/mute\n");
 679                 ast_ari_response_error(response, 500,
 680                         "Internal Server Error", "Response validation failed");
 681         }
 682 #endif /* AST_DEVMODE */
 683
 684 fin: __attribute__((unused))
 685         return;
 686 }
 687 /*!
 688  * \brief Parameter parsing callback for /channels/{channelId}/mute.
 689  * \param get_params GET parameters in the HTTP request.
 690  * \param path_vars Path variables extracted from the request.
 691  * \param headers HTTP headers.
 692  * \param[out] response Response to the HTTP request.
 693  */
 694 static void ast_ari_channels_unmute_cb(
 695         struct ast_variable *get_params, struct ast_variable *path_vars,
 696         struct ast_variable *headers, struct ast_ari_response *response)
 697 {
 698         struct ast_ari_channels_unmute_args args = {};
 699         struct ast_variable *i;
 700 #if defined(AST_DEVMODE)
 701         int is_valid;
 702         int code;
 703 #endif /* AST_DEVMODE */
 704
 705         for (i = get_params; i; i = i->next) {
 706                 if (strcmp(i->name, "direction") == 0) {
 707                         args.direction = (i->value);
 708                 } else
 709                 {}
 710         }
 711         for (i = path_vars; i; i = i->next) {
 712                 if (strcmp(i->name, "channelId") == 0) {
 713                         args.channel_id = (i->value);
 714                 } else
 715                 {}
 716         }
 717         ast_ari_channels_unmute(headers, &args, response);
 718 #if defined(AST_DEVMODE)
 719         code = response->response_code;
 720
 721         switch (code) {
 722         case 0: /* Implementation is still a stub, or the code wasn't set */
 723                 is_valid = response->message == NULL;
 724                 break;
 725         case 500: /* Internal Server Error */
 726         case 501: /* Not Implemented */
 727         case 404: /* Channel not found */
 728         case 409: /* Channel not in a Stasis application */
 729                 is_valid = 1;
 730                 break;
 731         default:
 732                 if (200 <= code && code <= 299) {
 733                         is_valid = ast_ari_validate_void(
 734                                 response->message);
 735                 } else {
 736                         ast_log(LOG_ERROR, "Invalid error response %d for /channels/{channelId}/mute\n", code);
 737                         is_valid = 0;
 738                 }
 739         }
 740
 741         if (!is_valid) {
 742                 ast_log(LOG_ERROR, "Response validation failed for /channels/{channelId}/mute\n");
 743                 ast_ari_response_error(response, 500,
 744                         "Internal Server Error", "Response validation failed");
 745         }
 746 #endif /* AST_DEVMODE */
 747
 748 fin: __attribute__((unused))
 749         return;
 750 }
 751 /*!
 752  * \brief Parameter parsing callback for /channels/{channelId}/hold.
 753  * \param get_params GET parameters in the HTTP request.
 754  * \param path_vars Path variables extracted from the request.
 755  * \param headers HTTP headers.
 756  * \param[out] response Response to the HTTP request.
 757  */
 758 static void ast_ari_channels_hold_cb(
 759         struct ast_variable *get_params, struct ast_variable *path_vars,
 760         struct ast_variable *headers, struct ast_ari_response *response)
 761 {
 762         struct ast_ari_channels_hold_args args = {};
 763         struct ast_variable *i;
 764 #if defined(AST_DEVMODE)
 765         int is_valid;
 766         int code;
 767 #endif /* AST_DEVMODE */
 768
 769         for (i = path_vars; i; i = i->next) {
 770                 if (strcmp(i->name, "channelId") == 0) {
 771                         args.channel_id = (i->value);
 772                 } else
 773                 {}
 774         }
 775         ast_ari_channels_hold(headers, &args, response);
 776 #if defined(AST_DEVMODE)
 777         code = response->response_code;
 778
 779         switch (code) {
 780         case 0: /* Implementation is still a stub, or the code wasn't set */
 781                 is_valid = response->message == NULL;
 782                 break;
 783         case 500: /* Internal Server Error */
 784         case 501: /* Not Implemented */
 785         case 404: /* Channel not found */
 786         case 409: /* Channel not in a Stasis application */
 787                 is_valid = 1;
 788                 break;
 789         default:
 790                 if (200 <= code && code <= 299) {
 791                         is_valid = ast_ari_validate_void(
 792                                 response->message);
 793                 } else {
 794                         ast_log(LOG_ERROR, "Invalid error response %d for /channels/{channelId}/hold\n", code);
 795                         is_valid = 0;
 796                 }
 797         }
 798
 799         if (!is_valid) {
 800                 ast_log(LOG_ERROR, "Response validation failed for /channels/{channelId}/hold\n");
 801                 ast_ari_response_error(response, 500,
 802                         "Internal Server Error", "Response validation failed");
 803         }
 804 #endif /* AST_DEVMODE */
 805
 806 fin: __attribute__((unused))
 807         return;
 808 }
 809 /*!
 810  * \brief Parameter parsing callback for /channels/{channelId}/hold.
 811  * \param get_params GET parameters in the HTTP request.
 812  * \param path_vars Path variables extracted from the request.
 813  * \param headers HTTP headers.
 814  * \param[out] response Response to the HTTP request.
 815  */
 816 static void ast_ari_channels_unhold_cb(
 817         struct ast_variable *get_params, struct ast_variable *path_vars,
 818         struct ast_variable *headers, struct ast_ari_response *response)
 819 {
 820         struct ast_ari_channels_unhold_args args = {};
 821         struct ast_variable *i;
 822 #if defined(AST_DEVMODE)
 823         int is_valid;
 824         int code;
 825 #endif /* AST_DEVMODE */
 826
 827         for (i = path_vars; i; i = i->next) {
 828                 if (strcmp(i->name, "channelId") == 0) {
 829                         args.channel_id = (i->value);
 830                 } else
 831                 {}
 832         }
 833         ast_ari_channels_unhold(headers, &args, response);
 834 #if defined(AST_DEVMODE)
 835         code = response->response_code;
 836
 837         switch (code) {
 838         case 0: /* Implementation is still a stub, or the code wasn't set */
 839                 is_valid = response->message == NULL;
 840                 break;
 841         case 500: /* Internal Server Error */
 842         case 501: /* Not Implemented */
 843         case 404: /* Channel not found */
 844         case 409: /* Channel not in a Stasis application */
 845                 is_valid = 1;
 846                 break;
 847         default:
 848                 if (200 <= code && code <= 299) {
 849                         is_valid = ast_ari_validate_void(
 850                                 response->message);
 851                 } else {
 852                         ast_log(LOG_ERROR, "Invalid error response %d for /channels/{channelId}/hold\n", code);
 853                         is_valid = 0;
 854                 }
 855         }
 856
 857         if (!is_valid) {
 858                 ast_log(LOG_ERROR, "Response validation failed for /channels/{channelId}/hold\n");
 859                 ast_ari_response_error(response, 500,
 860                         "Internal Server Error", "Response validation failed");
 861         }
 862 #endif /* AST_DEVMODE */
 863
 864 fin: __attribute__((unused))
 865         return;
 866 }
 867 /*!
 868  * \brief Parameter parsing callback for /channels/{channelId}/moh.
 869  * \param get_params GET parameters in the HTTP request.
 870  * \param path_vars Path variables extracted from the request.
 871  * \param headers HTTP headers.
 872  * \param[out] response Response to the HTTP request.
 873  */
 874 static void ast_ari_channels_start_moh_cb(
 875         struct ast_variable *get_params, struct ast_variable *path_vars,
 876         struct ast_variable *headers, struct ast_ari_response *response)
 877 {
 878         struct ast_ari_channels_start_moh_args args = {};
 879         struct ast_variable *i;
 880 #if defined(AST_DEVMODE)
 881         int is_valid;
 882         int code;
 883 #endif /* AST_DEVMODE */
 884
 885         for (i = get_params; i; i = i->next) {
 886                 if (strcmp(i->name, "mohClass") == 0) {
 887                         args.moh_class = (i->value);
 888                 } else
 889                 {}
 890         }
 891         for (i = path_vars; i; i = i->next) {
 892                 if (strcmp(i->name, "channelId") == 0) {
 893                         args.channel_id = (i->value);
 894                 } else
 895                 {}
 896         }
 897         ast_ari_channels_start_moh(headers, &args, response);
 898 #if defined(AST_DEVMODE)
 899         code = response->response_code;
 900
 901         switch (code) {
 902         case 0: /* Implementation is still a stub, or the code wasn't set */
 903                 is_valid = response->message == NULL;
 904                 break;
 905         case 500: /* Internal Server Error */
 906         case 501: /* Not Implemented */
 907         case 404: /* Channel not found */
 908         case 409: /* Channel not in a Stasis application */
 909                 is_valid = 1;
 910                 break;
 911         default:
 912                 if (200 <= code && code <= 299) {
 913                         is_valid = ast_ari_validate_void(
 914                                 response->message);
 915                 } else {
 916                         ast_log(LOG_ERROR, "Invalid error response %d for /channels/{channelId}/moh\n", code);
 917                         is_valid = 0;
 918                 }
 919         }
 920
 921         if (!is_valid) {
 922                 ast_log(LOG_ERROR, "Response validation failed for /channels/{channelId}/moh\n");
 923                 ast_ari_response_error(response, 500,
 924                         "Internal Server Error", "Response validation failed");
 925         }
 926 #endif /* AST_DEVMODE */
 927
 928 fin: __attribute__((unused))
 929         return;
 930 }
 931 /*!
 932  * \brief Parameter parsing callback for /channels/{channelId}/moh.
 933  * \param get_params GET parameters in the HTTP request.
 934  * \param path_vars Path variables extracted from the request.
 935  * \param headers HTTP headers.
 936  * \param[out] response Response to the HTTP request.
 937  */
 938 static void ast_ari_channels_stop_moh_cb(
 939         struct ast_variable *get_params, struct ast_variable *path_vars,
 940         struct ast_variable *headers, struct ast_ari_response *response)
 941 {
 942         struct ast_ari_channels_stop_moh_args args = {};
 943         struct ast_variable *i;
 944 #if defined(AST_DEVMODE)
 945         int is_valid;
 946         int code;
 947 #endif /* AST_DEVMODE */
 948
 949         for (i = path_vars; i; i = i->next) {
 950                 if (strcmp(i->name, "channelId") == 0) {
 951                         args.channel_id = (i->value);
 952                 } else
 953                 {}
 954         }
 955         ast_ari_channels_stop_moh(headers, &args, response);
 956 #if defined(AST_DEVMODE)
 957         code = response->response_code;
 958
 959         switch (code) {
 960         case 0: /* Implementation is still a stub, or the code wasn't set */
 961                 is_valid = response->message == NULL;
 962                 break;
 963         case 500: /* Internal Server Error */
 964         case 501: /* Not Implemented */
 965         case 404: /* Channel not found */
 966         case 409: /* Channel not in a Stasis application */
 967                 is_valid = 1;
 968                 break;
 969         default:
 970                 if (200 <= code && code <= 299) {
 971                         is_valid = ast_ari_validate_void(
 972                                 response->message);
 973                 } else {
 974                         ast_log(LOG_ERROR, "Invalid error response %d for /channels/{channelId}/moh\n", code);
 975                         is_valid = 0;
 976                 }
 977         }
 978
 979         if (!is_valid) {
 980                 ast_log(LOG_ERROR, "Response validation failed for /channels/{channelId}/moh\n");
 981                 ast_ari_response_error(response, 500,
 982                         "Internal Server Error", "Response validation failed");
 983         }
 984 #endif /* AST_DEVMODE */
 985
 986 fin: __attribute__((unused))
 987         return;
 988 }
 989 /*!
 990  * \brief Parameter parsing callback for /channels/{channelId}/silence.
 991  * \param get_params GET parameters in the HTTP request.
 992  * \param path_vars Path variables extracted from the request.
 993  * \param headers HTTP headers.
 994  * \param[out] response Response to the HTTP request.
 995  */
 996 static void ast_ari_channels_start_silence_cb(
 997         struct ast_variable *get_params, struct ast_variable *path_vars,
 998         struct ast_variable *headers, struct ast_ari_response *response)
 999 {
1000         struct ast_ari_channels_start_silence_args args = {};
1001         struct ast_variable *i;
1002 #if defined(AST_DEVMODE)
1003         int is_valid;
1004         int code;
1005 #endif /* AST_DEVMODE */
1006
1007         for (i = path_vars; i; i = i->next) {
1008                 if (strcmp(i->name, "channelId") == 0) {
1009                         args.channel_id = (i->value);
1010                 } else
1011                 {}
1012         }
1013         ast_ari_channels_start_silence(headers, &args, response);
1014 #if defined(AST_DEVMODE)
1015         code = response->response_code;
1016
1017         switch (code) {
1018         case 0: /* Implementation is still a stub, or the code wasn't set */
1019                 is_valid = response->message == NULL;
1020                 break;
1021         case 500: /* Internal Server Error */
1022         case 501: /* Not Implemented */
1023         case 404: /* Channel not found */
1024         case 409: /* Channel not in a Stasis application */
1025                 is_valid = 1;
1026                 break;
1027         default:
1028                 if (200 <= code && code <= 299) {
1029                         is_valid = ast_ari_validate_void(
1030                                 response->message);
1031                 } else {
1032                         ast_log(LOG_ERROR, "Invalid error response %d for /channels/{channelId}/silence\n", code);
1033                         is_valid = 0;
1034                 }
1035         }
1036
1037         if (!is_valid) {
1038                 ast_log(LOG_ERROR, "Response validation failed for /channels/{channelId}/silence\n");
1039                 ast_ari_response_error(response, 500,
1040                         "Internal Server Error", "Response validation failed");
1041         }
1042 #endif /* AST_DEVMODE */
1043
1044 fin: __attribute__((unused))
1045         return;
1046 }
1047 /*!
1048  * \brief Parameter parsing callback for /channels/{channelId}/silence.
1049  * \param get_params GET parameters in the HTTP request.
1050  * \param path_vars Path variables extracted from the request.
1051  * \param headers HTTP headers.
1052  * \param[out] response Response to the HTTP request.
1053  */
1054 static void ast_ari_channels_stop_silence_cb(
1055         struct ast_variable *get_params, struct ast_variable *path_vars,
1056         struct ast_variable *headers, struct ast_ari_response *response)
1057 {
1058         struct ast_ari_channels_stop_silence_args args = {};
1059         struct ast_variable *i;
1060 #if defined(AST_DEVMODE)
1061         int is_valid;
1062         int code;
1063 #endif /* AST_DEVMODE */
1064
1065         for (i = path_vars; i; i = i->next) {
1066                 if (strcmp(i->name, "channelId") == 0) {
1067                         args.channel_id = (i->value);
1068                 } else
1069                 {}
1070         }
1071         ast_ari_channels_stop_silence(headers, &args, response);
1072 #if defined(AST_DEVMODE)
1073         code = response->response_code;
1074
1075         switch (code) {
1076         case 0: /* Implementation is still a stub, or the code wasn't set */
1077                 is_valid = response->message == NULL;
1078                 break;
1079         case 500: /* Internal Server Error */
1080         case 501: /* Not Implemented */
1081         case 404: /* Channel not found */
1082         case 409: /* Channel not in a Stasis application */
1083                 is_valid = 1;
1084                 break;
1085         default:
1086                 if (200 <= code && code <= 299) {
1087                         is_valid = ast_ari_validate_void(
1088                                 response->message);
1089                 } else {
1090                         ast_log(LOG_ERROR, "Invalid error response %d for /channels/{channelId}/silence\n", code);
1091                         is_valid = 0;
1092                 }
1093         }
1094
1095         if (!is_valid) {
1096                 ast_log(LOG_ERROR, "Response validation failed for /channels/{channelId}/silence\n");
1097                 ast_ari_response_error(response, 500,
1098                         "Internal Server Error", "Response validation failed");
1099         }
1100 #endif /* AST_DEVMODE */
1101
1102 fin: __attribute__((unused))
1103         return;
1104 }
1105 /*!
1106  * \brief Parameter parsing callback for /channels/{channelId}/play.
1107  * \param get_params GET parameters in the HTTP request.
1108  * \param path_vars Path variables extracted from the request.
1109  * \param headers HTTP headers.
1110  * \param[out] response Response to the HTTP request.
1111  */
1112 static void ast_ari_channels_play_cb(
1113         struct ast_variable *get_params, struct ast_variable *path_vars,
1114         struct ast_variable *headers, struct ast_ari_response *response)
1115 {
1116         struct ast_ari_channels_play_args args = {};
1117         struct ast_variable *i;
1118 #if defined(AST_DEVMODE)
1119         int is_valid;
1120         int code;
1121 #endif /* AST_DEVMODE */
1122
1123         for (i = get_params; i; i = i->next) {
1124                 if (strcmp(i->name, "media") == 0) {
1125                         args.media = (i->value);
1126                 } else
1127                 if (strcmp(i->name, "lang") == 0) {
1128                         args.lang = (i->value);
1129                 } else
1130                 if (strcmp(i->name, "offsetms") == 0) {
1131                         args.offsetms = atoi(i->value);
1132                 } else
1133                 if (strcmp(i->name, "skipms") == 0) {
1134                         args.skipms = atoi(i->value);
1135                 } else
1136                 {}
1137         }
1138         for (i = path_vars; i; i = i->next) {
1139                 if (strcmp(i->name, "channelId") == 0) {
1140                         args.channel_id = (i->value);
1141                 } else
1142                 {}
1143         }
1144         ast_ari_channels_play(headers, &args, response);
1145 #if defined(AST_DEVMODE)
1146         code = response->response_code;
1147
1148         switch (code) {
1149         case 0: /* Implementation is still a stub, or the code wasn't set */
1150                 is_valid = response->message == NULL;
1151                 break;
1152         case 500: /* Internal Server Error */
1153         case 501: /* Not Implemented */
1154         case 404: /* Channel not found */
1155         case 409: /* Channel not in a Stasis application */
1156                 is_valid = 1;
1157                 break;
1158         default:
1159                 if (200 <= code && code <= 299) {
1160                         is_valid = ast_ari_validate_playback(
1161                                 response->message);
1162                 } else {
1163                         ast_log(LOG_ERROR, "Invalid error response %d for /channels/{channelId}/play\n", code);
1164                         is_valid = 0;
1165                 }
1166         }
1167
1168         if (!is_valid) {
1169                 ast_log(LOG_ERROR, "Response validation failed for /channels/{channelId}/play\n");
1170                 ast_ari_response_error(response, 500,
1171                         "Internal Server Error", "Response validation failed");
1172         }
1173 #endif /* AST_DEVMODE */
1174
1175 fin: __attribute__((unused))
1176         return;
1177 }
1178 /*!
1179  * \brief Parameter parsing callback for /channels/{channelId}/record.
1180  * \param get_params GET parameters in the HTTP request.
1181  * \param path_vars Path variables extracted from the request.
1182  * \param headers HTTP headers.
1183  * \param[out] response Response to the HTTP request.
1184  */
1185 static void ast_ari_channels_record_cb(
1186         struct ast_variable *get_params, struct ast_variable *path_vars,
1187         struct ast_variable *headers, struct ast_ari_response *response)
1188 {
1189         struct ast_ari_channels_record_args args = {};
1190         struct ast_variable *i;
1191 #if defined(AST_DEVMODE)
1192         int is_valid;
1193         int code;
1194 #endif /* AST_DEVMODE */
1195
1196         for (i = get_params; i; i = i->next) {
1197                 if (strcmp(i->name, "name") == 0) {
1198                         args.name = (i->value);
1199                 } else
1200                 if (strcmp(i->name, "format") == 0) {
1201                         args.format = (i->value);
1202                 } else
1203                 if (strcmp(i->name, "maxDurationSeconds") == 0) {
1204                         args.max_duration_seconds = atoi(i->value);
1205                 } else
1206                 if (strcmp(i->name, "maxSilenceSeconds") == 0) {
1207                         args.max_silence_seconds = atoi(i->value);
1208                 } else
1209                 if (strcmp(i->name, "ifExists") == 0) {
1210                         args.if_exists = (i->value);
1211                 } else
1212                 if (strcmp(i->name, "beep") == 0) {
1213                         args.beep = ast_true(i->value);
1214                 } else
1215                 if (strcmp(i->name, "terminateOn") == 0) {
1216                         args.terminate_on = (i->value);
1217                 } else
1218                 {}
1219         }
1220         for (i = path_vars; i; i = i->next) {
1221                 if (strcmp(i->name, "channelId") == 0) {
1222                         args.channel_id = (i->value);
1223                 } else
1224                 {}
1225         }
1226         ast_ari_channels_record(headers, &args, response);
1227 #if defined(AST_DEVMODE)
1228         code = response->response_code;
1229
1230         switch (code) {
1231         case 0: /* Implementation is still a stub, or the code wasn't set */
1232                 is_valid = response->message == NULL;
1233                 break;
1234         case 500: /* Internal Server Error */
1235         case 501: /* Not Implemented */
1236         case 400: /* Invalid parameters */
1237         case 404: /* Channel not found */
1238         case 409: /* Channel is not in a Stasis application; the channel is currently bridged with other hcannels; A recording with the same name already exists on the system and can not be overwritten because it is in progress or ifExists=fail */
1239         case 422: /* The format specified is unknown on this system */
1240                 is_valid = 1;
1241                 break;
1242         default:
1243                 if (200 <= code && code <= 299) {
1244                         is_valid = ast_ari_validate_live_recording(
1245                                 response->message);
1246                 } else {
1247                         ast_log(LOG_ERROR, "Invalid error response %d for /channels/{channelId}/record\n", code);
1248                         is_valid = 0;
1249                 }
1250         }
1251
1252         if (!is_valid) {
1253                 ast_log(LOG_ERROR, "Response validation failed for /channels/{channelId}/record\n");
1254                 ast_ari_response_error(response, 500,
1255                         "Internal Server Error", "Response validation failed");
1256         }
1257 #endif /* AST_DEVMODE */
1258
1259 fin: __attribute__((unused))
1260         return;
1261 }
1262 /*!
1263  * \brief Parameter parsing callback for /channels/{channelId}/variable.
1264  * \param get_params GET parameters in the HTTP request.
1265  * \param path_vars Path variables extracted from the request.
1266  * \param headers HTTP headers.
1267  * \param[out] response Response to the HTTP request.
1268  */
1269 static void ast_ari_channels_get_channel_var_cb(
1270         struct ast_variable *get_params, struct ast_variable *path_vars,
1271         struct ast_variable *headers, struct ast_ari_response *response)
1272 {
1273         struct ast_ari_channels_get_channel_var_args args = {};
1274         struct ast_variable *i;
1275 #if defined(AST_DEVMODE)
1276         int is_valid;
1277         int code;
1278 #endif /* AST_DEVMODE */
1279
1280         for (i = get_params; i; i = i->next) {
1281                 if (strcmp(i->name, "variable") == 0) {
1282                         args.variable = (i->value);
1283                 } else
1284                 {}
1285         }
1286         for (i = path_vars; i; i = i->next) {
1287                 if (strcmp(i->name, "channelId") == 0) {
1288                         args.channel_id = (i->value);
1289                 } else
1290                 {}
1291         }
1292         ast_ari_channels_get_channel_var(headers, &args, response);
1293 #if defined(AST_DEVMODE)
1294         code = response->response_code;
1295
1296         switch (code) {
1297         case 0: /* Implementation is still a stub, or the code wasn't set */
1298                 is_valid = response->message == NULL;
1299                 break;
1300         case 500: /* Internal Server Error */
1301         case 501: /* Not Implemented */
1302         case 400: /* Missing variable parameter. */
1303         case 404: /* Channel not found */
1304         case 409: /* Channel not in a Stasis application */
1305                 is_valid = 1;
1306                 break;
1307         default:
1308                 if (200 <= code && code <= 299) {
1309                         is_valid = ast_ari_validate_variable(
1310                                 response->message);
1311                 } else {
1312                         ast_log(LOG_ERROR, "Invalid error response %d for /channels/{channelId}/variable\n", code);
1313                         is_valid = 0;
1314                 }
1315         }
1316
1317         if (!is_valid) {
1318                 ast_log(LOG_ERROR, "Response validation failed for /channels/{channelId}/variable\n");
1319                 ast_ari_response_error(response, 500,
1320                         "Internal Server Error", "Response validation failed");
1321         }
1322 #endif /* AST_DEVMODE */
1323
1324 fin: __attribute__((unused))
1325         return;
1326 }
1327 /*!
1328  * \brief Parameter parsing callback for /channels/{channelId}/variable.
1329  * \param get_params GET parameters in the HTTP request.
1330  * \param path_vars Path variables extracted from the request.
1331  * \param headers HTTP headers.
1332  * \param[out] response Response to the HTTP request.
1333  */
1334 static void ast_ari_channels_set_channel_var_cb(
1335         struct ast_variable *get_params, struct ast_variable *path_vars,
1336         struct ast_variable *headers, struct ast_ari_response *response)
1337 {
1338         struct ast_ari_channels_set_channel_var_args args = {};
1339         struct ast_variable *i;
1340 #if defined(AST_DEVMODE)
1341         int is_valid;
1342         int code;
1343 #endif /* AST_DEVMODE */
1344
1345         for (i = get_params; i; i = i->next) {
1346                 if (strcmp(i->name, "variable") == 0) {
1347                         args.variable = (i->value);
1348                 } else
1349                 if (strcmp(i->name, "value") == 0) {
1350                         args.value = (i->value);
1351                 } else
1352                 {}
1353         }
1354         for (i = path_vars; i; i = i->next) {
1355                 if (strcmp(i->name, "channelId") == 0) {
1356                         args.channel_id = (i->value);
1357                 } else
1358                 {}
1359         }
1360         ast_ari_channels_set_channel_var(headers, &args, response);
1361 #if defined(AST_DEVMODE)
1362         code = response->response_code;
1363
1364         switch (code) {
1365         case 0: /* Implementation is still a stub, or the code wasn't set */
1366                 is_valid = response->message == NULL;
1367                 break;
1368         case 500: /* Internal Server Error */
1369         case 501: /* Not Implemented */
1370         case 400: /* Missing variable parameter. */
1371         case 404: /* Channel not found */
1372         case 409: /* Channel not in a Stasis application */
1373                 is_valid = 1;
1374                 break;
1375         default:
1376                 if (200 <= code && code <= 299) {
1377                         is_valid = ast_ari_validate_void(
1378                                 response->message);
1379                 } else {
1380                         ast_log(LOG_ERROR, "Invalid error response %d for /channels/{channelId}/variable\n", code);
1381                         is_valid = 0;
1382                 }
1383         }
1384
1385         if (!is_valid) {
1386                 ast_log(LOG_ERROR, "Response validation failed for /channels/{channelId}/variable\n");
1387                 ast_ari_response_error(response, 500,
1388                         "Internal Server Error", "Response validation failed");
1389         }
1390 #endif /* AST_DEVMODE */
1391
1392 fin: __attribute__((unused))
1393         return;
1394 }
1395
1396 /*! \brief REST handler for /api-docs/channels.{format} */
1397 static struct stasis_rest_handlers channels_channelId_continue = {
1398         .path_segment = "continue",
1399         .callbacks = {
1400                 [AST_HTTP_POST] = ast_ari_channels_continue_in_dialplan_cb,
1401         },
1402         .num_children = 0,
1403         .children = {  }
1404 };
1405 /*! \brief REST handler for /api-docs/channels.{format} */
1406 static struct stasis_rest_handlers channels_channelId_answer = {
1407         .path_segment = "answer",
1408         .callbacks = {
1409                 [AST_HTTP_POST] = ast_ari_channels_answer_cb,
1410         },
1411         .num_children = 0,
1412         .children = {  }
1413 };
1414 /*! \brief REST handler for /api-docs/channels.{format} */
1415 static struct stasis_rest_handlers channels_channelId_ring = {
1416         .path_segment = "ring",
1417         .callbacks = {
1418                 [AST_HTTP_POST] = ast_ari_channels_ring_cb,
1419                 [AST_HTTP_DELETE] = ast_ari_channels_ring_stop_cb,
1420         },
1421         .num_children = 0,
1422         .children = {  }
1423 };
1424 /*! \brief REST handler for /api-docs/channels.{format} */
1425 static struct stasis_rest_handlers channels_channelId_dtmf = {
1426         .path_segment = "dtmf",
1427         .callbacks = {
1428                 [AST_HTTP_POST] = ast_ari_channels_send_dtmf_cb,
1429         },
1430         .num_children = 0,
1431         .children = {  }
1432 };
1433 /*! \brief REST handler for /api-docs/channels.{format} */
1434 static struct stasis_rest_handlers channels_channelId_mute = {
1435         .path_segment = "mute",
1436         .callbacks = {
1437                 [AST_HTTP_POST] = ast_ari_channels_mute_cb,
1438                 [AST_HTTP_DELETE] = ast_ari_channels_unmute_cb,
1439         },
1440         .num_children = 0,
1441         .children = {  }
1442 };
1443 /*! \brief REST handler for /api-docs/channels.{format} */
1444 static struct stasis_rest_handlers channels_channelId_hold = {
1445         .path_segment = "hold",
1446         .callbacks = {
1447                 [AST_HTTP_POST] = ast_ari_channels_hold_cb,
1448                 [AST_HTTP_DELETE] = ast_ari_channels_unhold_cb,
1449         },
1450         .num_children = 0,
1451         .children = {  }
1452 };
1453 /*! \brief REST handler for /api-docs/channels.{format} */
1454 static struct stasis_rest_handlers channels_channelId_moh = {
1455         .path_segment = "moh",
1456         .callbacks = {
1457                 [AST_HTTP_POST] = ast_ari_channels_start_moh_cb,
1458                 [AST_HTTP_DELETE] = ast_ari_channels_stop_moh_cb,
1459         },
1460         .num_children = 0,
1461         .children = {  }
1462 };
1463 /*! \brief REST handler for /api-docs/channels.{format} */
1464 static struct stasis_rest_handlers channels_channelId_silence = {
1465         .path_segment = "silence",
1466         .callbacks = {
1467                 [AST_HTTP_POST] = ast_ari_channels_start_silence_cb,
1468                 [AST_HTTP_DELETE] = ast_ari_channels_stop_silence_cb,
1469         },
1470         .num_children = 0,
1471         .children = {  }
1472 };
1473 /*! \brief REST handler for /api-docs/channels.{format} */
1474 static struct stasis_rest_handlers channels_channelId_play = {
1475         .path_segment = "play",
1476         .callbacks = {
1477                 [AST_HTTP_POST] = ast_ari_channels_play_cb,
1478         },
1479         .num_children = 0,
1480         .children = {  }
1481 };
1482 /*! \brief REST handler for /api-docs/channels.{format} */
1483 static struct stasis_rest_handlers channels_channelId_record = {
1484         .path_segment = "record",
1485         .callbacks = {
1486                 [AST_HTTP_POST] = ast_ari_channels_record_cb,
1487         },
1488         .num_children = 0,
1489         .children = {  }
1490 };
1491 /*! \brief REST handler for /api-docs/channels.{format} */
1492 static struct stasis_rest_handlers channels_channelId_variable = {
1493         .path_segment = "variable",
1494         .callbacks = {
1495                 [AST_HTTP_GET] = ast_ari_channels_get_channel_var_cb,
1496                 [AST_HTTP_POST] = ast_ari_channels_set_channel_var_cb,
1497         },
1498         .num_children = 0,
1499         .children = {  }
1500 };
1501 /*! \brief REST handler for /api-docs/channels.{format} */
1502 static struct stasis_rest_handlers channels_channelId = {
1503         .path_segment = "channelId",
1504         .is_wildcard = 1,
1505         .callbacks = {
1506                 [AST_HTTP_GET] = ast_ari_channels_get_cb,
1507                 [AST_HTTP_DELETE] = ast_ari_channels_hangup_cb,
1508         },
1509         .num_children = 11,
1510         .children = { &channels_channelId_continue,&channels_channelId_answer,&channels_channelId_ring,&channels_channelId_dtmf,&channels_channelId_mute,&channels_channelId_hold,&channels_channelId_moh,&channels_channelId_silence,&channels_channelId_play,&channels_channelId_record,&channels_channelId_variable, }
1511 };
1512 /*! \brief REST handler for /api-docs/channels.{format} */
1513 static struct stasis_rest_handlers channels = {
1514         .path_segment = "channels",
1515         .callbacks = {
1516                 [AST_HTTP_GET] = ast_ari_channels_list_cb,
1517                 [AST_HTTP_POST] = ast_ari_channels_originate_cb,
1518         },
1519         .num_children = 1,
1520         .children = { &channels_channelId, }
1521 };
1522
1523 static int load_module(void)
1524 {
1525         int res = 0;
1526         stasis_app_ref();
1527         res |= ast_ari_add_handler(&channels);
1528         return res;
1529 }
1530
1531 static int unload_module(void)
1532 {
1533         ast_ari_remove_handler(&channels);
1534         stasis_app_unref();
1535         return 0;
1536 }
1537
1538 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "RESTful API module - Channel resources",
1539         .load = load_module,
1540         .unload = unload_module,
1541         .nonoptreq = "res_ari,res_stasis",
1542         );