ao2_iterator: Mini-audit of the ao2_iterator loops in the new code files.
[asterisk/asterisk.git] / res / ari / resource_endpoints.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 /*! \file
20  *
21  * \brief /api-docs/endpoints.{format} implementation- Endpoint resources
22  *
23  * \author David M. Lee, II <dlee@digium.com>
24  */
25
26 #include "asterisk.h"
27
28 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
29
30 #include "resource_endpoints.h"
31
32 #include "asterisk/astobj2.h"
33 #include "asterisk/stasis.h"
34 #include "asterisk/stasis_app.h"
35 #include "asterisk/stasis_endpoints.h"
36 #include "asterisk/channel.h"
37
38 void ast_ari_endpoints_list(struct ast_variable *headers,
39         struct ast_ari_endpoints_list_args *args,
40         struct ast_ari_response *response)
41 {
42         RAII_VAR(struct stasis_cache *, cache, NULL, ao2_cleanup);
43         RAII_VAR(struct ao2_container *, snapshots, NULL, ao2_cleanup);
44         RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
45         struct ao2_iterator i;
46         void *obj;
47
48         cache = ast_endpoint_cache();
49         if (!cache) {
50                 ast_ari_response_error(
51                         response, 500, "Internal Server Error",
52                         "Message bus not initialized");
53                 return;
54         }
55         ao2_ref(cache, +1);
56
57         snapshots = stasis_cache_dump(cache, ast_endpoint_snapshot_type());
58         if (!snapshots) {
59                 ast_ari_response_alloc_failed(response);
60                 return;
61         }
62
63         json = ast_json_array_create();
64         if (!json) {
65                 ast_ari_response_alloc_failed(response);
66                 return;
67         }
68
69         i = ao2_iterator_init(snapshots, 0);
70         while ((obj = ao2_iterator_next(&i))) {
71                 RAII_VAR(struct stasis_message *, msg, obj, ao2_cleanup);
72                 struct ast_endpoint_snapshot *snapshot = stasis_message_data(msg);
73                 struct ast_json *json_endpoint = ast_endpoint_snapshot_to_json(snapshot, stasis_app_get_sanitizer());
74                 int r;
75
76                 if (!json_endpoint) {
77                         ao2_iterator_destroy(&i);
78                         return;
79                 }
80
81                 r = ast_json_array_append(
82                         json, json_endpoint);
83                 if (r != 0) {
84                         ao2_iterator_destroy(&i);
85                         ast_ari_response_alloc_failed(response);
86                         return;
87                 }
88         }
89         ao2_iterator_destroy(&i);
90
91         ast_ari_response_ok(response, ast_json_ref(json));
92 }
93 void ast_ari_endpoints_list_by_tech(struct ast_variable *headers,
94         struct ast_ari_endpoints_list_by_tech_args *args,
95         struct ast_ari_response *response)
96 {
97         RAII_VAR(struct stasis_cache *, cache, NULL, ao2_cleanup);
98         RAII_VAR(struct ao2_container *, snapshots, NULL, ao2_cleanup);
99         RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
100         struct ao2_iterator i;
101         void *obj;
102
103         if (!ast_get_channel_tech(args->tech)) {
104                 ast_ari_response_error(response, 404, "Not Found",
105                                        "No Endpoints found - invalid tech %s", args->tech);
106                 return;
107         }
108
109         cache = ast_endpoint_cache();
110         if (!cache) {
111                 ast_ari_response_error(
112                         response, 500, "Internal Server Error",
113                         "Message bus not initialized");
114                 return;
115         }
116         ao2_ref(cache, +1);
117
118         snapshots = stasis_cache_dump(cache, ast_endpoint_snapshot_type());
119         if (!snapshots) {
120                 ast_ari_response_alloc_failed(response);
121                 return;
122         }
123
124         json = ast_json_array_create();
125         if (!json) {
126                 ast_ari_response_alloc_failed(response);
127                 return;
128         }
129
130         i = ao2_iterator_init(snapshots, 0);
131         while ((obj = ao2_iterator_next(&i))) {
132                 RAII_VAR(struct stasis_message *, msg, obj, ao2_cleanup);
133                 struct ast_endpoint_snapshot *snapshot = stasis_message_data(msg);
134                 struct ast_json *json_endpoint;
135                 int r;
136
137                 if (strcasecmp(args->tech, snapshot->tech) != 0) {
138                         continue;
139                 }
140
141                 json_endpoint = ast_endpoint_snapshot_to_json(snapshot, stasis_app_get_sanitizer());
142                 if (!json_endpoint) {
143                         continue;
144                 }
145
146                 r = ast_json_array_append(
147                         json, json_endpoint);
148                 if (r != 0) {
149                         ao2_iterator_destroy(&i);
150                         ast_ari_response_alloc_failed(response);
151                         return;
152                 }
153         }
154         ao2_iterator_destroy(&i);
155         ast_ari_response_ok(response, ast_json_ref(json));
156 }
157 void ast_ari_endpoints_get(struct ast_variable *headers,
158         struct ast_ari_endpoints_get_args *args,
159         struct ast_ari_response *response)
160 {
161         RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
162         RAII_VAR(struct ast_endpoint_snapshot *, snapshot, NULL, ao2_cleanup);
163
164         snapshot = ast_endpoint_latest_snapshot(args->tech, args->resource);
165         if (!snapshot) {
166                 ast_ari_response_error(response, 404, "Not Found",
167                         "Endpoint not found");
168                 return;
169         }
170
171         json = ast_endpoint_snapshot_to_json(snapshot, stasis_app_get_sanitizer());
172         if (!json) {
173                 ast_ari_response_alloc_failed(response);
174                 return;
175         }
176
177         ast_ari_response_ok(response, ast_json_ref(json));
178 }