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
00032 #include "asterisk.h"
00033
00034 ASTERISK_FILE_VERSION(__FILE__, "$Revision: 159808 $")
00035
00036 #include <sys/types.h>
00037 #include <netinet/in.h>
00038 #include <arpa/nameser.h>
00039 #if __APPLE_CC__ >= 1495
00040 #include <arpa/nameser_compat.h>
00041 #endif
00042 #include <resolv.h>
00043 #include <stdio.h>
00044 #include <string.h>
00045 #include <unistd.h>
00046
00047 #include "asterisk/channel.h"
00048 #include "asterisk/logger.h"
00049 #include "asterisk/srv.h"
00050 #include "asterisk/dns.h"
00051 #include "asterisk/options.h"
00052 #include "asterisk/utils.h"
00053 #include "asterisk/linkedlists.h"
00054
00055 #ifdef __APPLE__
00056 #undef T_SRV
00057 #define T_SRV 33
00058 #endif
00059
00060 struct srv_entry {
00061 unsigned short priority;
00062 unsigned short weight;
00063 unsigned short port;
00064 unsigned int weight_sum;
00065 AST_LIST_ENTRY(srv_entry) list;
00066 char host[1];
00067 };
00068
00069 struct srv_context {
00070 unsigned int have_weights:1;
00071 AST_LIST_HEAD_NOLOCK(srv_entries, srv_entry) entries;
00072 };
00073
00074 static int parse_srv(unsigned char *answer, int len, unsigned char *msg, struct srv_entry **result)
00075 {
00076 struct srv {
00077 unsigned short priority;
00078 unsigned short weight;
00079 unsigned short port;
00080 } __attribute__((__packed__)) *srv = (struct srv *) answer;
00081
00082 int res = 0;
00083 char repl[256] = "";
00084 struct srv_entry *entry;
00085
00086 if (len < sizeof(*srv))
00087 return -1;
00088
00089 answer += sizeof(*srv);
00090 len -= sizeof(*srv);
00091
00092 if ((res = dn_expand(msg, answer + len, answer, repl, sizeof(repl) - 1)) <= 0) {
00093 ast_log(LOG_WARNING, "Failed to expand hostname\n");
00094 return -1;
00095 }
00096
00097
00098
00099 if (!strcmp(repl, "."))
00100 return -1;
00101
00102 if (!(entry = ast_calloc(1, sizeof(*entry) + strlen(repl))))
00103 return -1;
00104
00105 entry->priority = ntohs(srv->priority);
00106 entry->weight = ntohs(srv->weight);
00107 entry->port = ntohs(srv->port);
00108 strcpy(entry->host, repl);
00109
00110 *result = entry;
00111
00112 return 0;
00113 }
00114
00115 static int srv_callback(void *context, unsigned char *answer, int len, unsigned char *fullanswer)
00116 {
00117 struct srv_context *c = (struct srv_context *) context;
00118 struct srv_entry *entry = NULL;
00119 struct srv_entry *current;
00120
00121 if (parse_srv(answer, len, fullanswer, &entry))
00122 return -1;
00123
00124 if (entry->weight)
00125 c->have_weights = 1;
00126
00127 AST_LIST_TRAVERSE_SAFE_BEGIN(&c->entries, current, list) {
00128
00129
00130 if (current->priority <= entry->priority)
00131 continue;
00132
00133 AST_LIST_INSERT_BEFORE_CURRENT(&c->entries, entry, list);
00134 entry = NULL;
00135 break;
00136 }
00137 AST_LIST_TRAVERSE_SAFE_END;
00138
00139
00140
00141 if (entry)
00142 AST_LIST_INSERT_TAIL(&c->entries, entry, list);
00143
00144 return 1;
00145 }
00146
00147
00148
00149
00150
00151
00152 static void process_weights(struct srv_context *context)
00153 {
00154 struct srv_entry *current;
00155 struct srv_entries newlist = AST_LIST_HEAD_NOLOCK_INIT_VALUE;
00156
00157 while (AST_LIST_FIRST(&context->entries)) {
00158 unsigned int random_weight;
00159 unsigned int weight_sum;
00160 unsigned short cur_priority = AST_LIST_FIRST(&context->entries)->priority;
00161 struct srv_entries temp_list = AST_LIST_HEAD_NOLOCK_INIT_VALUE;
00162 weight_sum = 0;
00163
00164 AST_LIST_TRAVERSE_SAFE_BEGIN(&context->entries, current, list) {
00165 if (current->priority != cur_priority)
00166 break;
00167
00168 AST_LIST_REMOVE_CURRENT(&context->entries, list);
00169 AST_LIST_INSERT_TAIL(&temp_list, current, list);
00170 }
00171 AST_LIST_TRAVERSE_SAFE_END;
00172
00173 while (AST_LIST_FIRST(&temp_list)) {
00174 weight_sum = 0;
00175 AST_LIST_TRAVERSE(&temp_list, current, list)
00176 current->weight_sum = weight_sum += current->weight;
00177
00178
00179
00180 if (weight_sum == 0) {
00181 AST_LIST_APPEND_LIST(&newlist, &temp_list, list);
00182 break;
00183 }
00184
00185 random_weight = 1 + (unsigned int) ((float) weight_sum * (ast_random() / ((float) RAND_MAX + 1.0)));
00186
00187 AST_LIST_TRAVERSE_SAFE_BEGIN(&temp_list, current, list) {
00188 if (current->weight < random_weight)
00189 continue;
00190
00191 AST_LIST_REMOVE_CURRENT(&temp_list, list);
00192 AST_LIST_INSERT_TAIL(&newlist, current, list);
00193 break;
00194 }
00195 AST_LIST_TRAVERSE_SAFE_END;
00196 }
00197
00198 }
00199
00200
00201
00202
00203 AST_LIST_APPEND_LIST(&context->entries, &newlist, list);
00204 }
00205
00206 int ast_get_srv(struct ast_channel *chan, char *host, int hostlen, int *port, const char *service)
00207 {
00208 struct srv_context context = { .entries = AST_LIST_HEAD_NOLOCK_INIT_VALUE };
00209 struct srv_entry *current;
00210 int ret;
00211
00212 if (chan && ast_autoservice_start(chan) < 0)
00213 return -1;
00214
00215 ret = ast_search_dns(&context, service, C_IN, T_SRV, srv_callback);
00216
00217 if (context.have_weights)
00218 process_weights(&context);
00219
00220 if (chan)
00221 ret |= ast_autoservice_stop(chan);
00222
00223
00224
00225
00226
00227
00228
00229 if ((ret > 0) && (current = AST_LIST_REMOVE_HEAD(&context.entries, list))) {
00230 ast_copy_string(host, current->host, hostlen);
00231 *port = current->port;
00232 ast_free(current);
00233 if (option_verbose > 3) {
00234 ast_verbose(VERBOSE_PREFIX_3 "ast_get_srv: SRV lookup for '%s' mapped to host %s, port %d\n",
00235 service, host, *port);
00236 }
00237 } else {
00238 host[0] = '\0';
00239 *port = -1;
00240 }
00241
00242 while ((current = AST_LIST_REMOVE_HEAD(&context.entries, list)))
00243 ast_free(current);
00244
00245 return ret;
00246 }