Debian Codegraph @

src/libcollectdclient/network.c

raw
1 /**
2 * collectd - src/libcollectdclient/network.c
3 * Copyright (C) 2005-2015 Florian Forster
4 * Copyright (C) 2010 Max Henkel
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22 * DEALINGS IN THE SOFTWARE.
23 *
24 * Authors:
25 * Florian Forster <octo at collectd.org>
26 * Max Henkel <henkel at gmx.at>
27 **/
28
29 #include "collectd.h"
30
31 #include <assert.h>
32 #include <errno.h>
33 #include <stdio.h>
34 #include <stdlib.h>
35 #include <string.h>
36 #include <unistd.h>
37
38 #include <netdb.h>
39 #include <sys/socket.h>
40 #include <sys/types.h>
41
42 #if HAVE_NETINET_IN_H
43 #include <netinet/in.h>
44 #endif
45
46 #if HAVE_NET_IF_H
47 #include <net/if.h>
48 #endif
49
50 #ifdef WIN32
51 #define AI_ADDRCONFIG 0
52 #endif
53
54 #include "collectd/network.h"
55 #include "collectd/network_buffer.h"
56
57 /*
58 * Private data types
59 */
60 struct lcc_network_s {
61 lcc_server_t *servers;
62 };
63
64 struct lcc_server_s {
65 char *node;
66 char *service;
67
68 int ttl;
69 lcc_security_level_t security_level;
70 char *username;
71 char *password;
72
73 int fd;
74 struct sockaddr *sa;
75 socklen_t sa_len;
76
77 lcc_network_buffer_t *buffer;
78
79 lcc_server_t *next;
80 };
81
82 /*
83 * Private functions
84 */
85 static int server_close_socket(lcc_server_t *srv) /* {{{ */
86 {
87 if (srv == NULL)
88 return EINVAL;
89
90 if (srv->fd < 0)
91 return 0;
92
93 close(srv->fd);
94 srv->fd = -1;
95 free(srv->sa);
96 srv->sa = NULL;
97 srv->sa_len = 0;
98
99 return 0;
100 } /* }}} int server_close_socket */
101
102 static void int_server_destroy(lcc_server_t *srv) /* {{{ */
103 {
104 lcc_server_t *next;
105
106 if (srv == NULL)
107 return;
108
109 server_close_socket(srv);
110
111 next = srv->next;
112
113 free(srv->node);
114 free(srv->service);
115 free(srv->username);
116 free(srv->password);
117 free(srv);
118
119 int_server_destroy(next);
120 } /* }}} void int_server_destroy */
121
122 static int server_open_socket(lcc_server_t *srv) /* {{{ */
123 {
124 struct addrinfo *ai_list;
125 int status;
126
127 if (srv == NULL)
128 return EINVAL;
129
130 if (srv->fd >= 0)
131 server_close_socket(srv);
132
133 struct addrinfo ai_hints = {.ai_family = AF_UNSPEC,
134 .ai_flags = AI_ADDRCONFIG,
135 .ai_socktype = SOCK_DGRAM};
136
137 status = getaddrinfo(srv->node, srv->service, &ai_hints, &ai_list);
138 if (status != 0)
139 return status;
140 assert(ai_list != NULL);
141
142 for (struct addrinfo *ai_ptr = ai_list; ai_ptr != NULL;
143 ai_ptr = ai_ptr->ai_next) {
144 srv->fd =
145 socket(ai_ptr->ai_family, ai_ptr->ai_socktype, ai_ptr->ai_protocol);
146 if (srv->fd < 0)
147 continue;
148
149 if (ai_ptr->ai_family == AF_INET) {
150 struct sockaddr_in *addr = (struct sockaddr_in *)ai_ptr->ai_addr;
151 int optname;
152
153 if (IN_MULTICAST(ntohl(addr->sin_addr.s_addr)))
154 optname = IP_MULTICAST_TTL;
155 else
156 optname = IP_TTL;
157
158 status =
159 setsockopt(srv->fd, IPPROTO_IP, optname, &srv->ttl, sizeof(srv->ttl));
160 } else if (ai_ptr->ai_family == AF_INET6) {
161 /* Useful example:
162 * http://gsyc.escet.urjc.es/~eva/IPv6-web/examples/mcast.html */
163 struct sockaddr_in6 *addr = (struct sockaddr_in6 *)ai_ptr->ai_addr;
164 int optname;
165
166 if (IN6_IS_ADDR_MULTICAST(&addr->sin6_addr))
167 optname = IPV6_MULTICAST_HOPS;
168 else
169 optname = IPV6_UNICAST_HOPS;
170
171 status = setsockopt(srv->fd, IPPROTO_IPV6, optname, &srv->ttl,
172 sizeof(srv->ttl));
173 }
174 if (status != 0) {
175 /* setsockopt failed. */
176 close(srv->fd);
177 srv->fd = -1;
178 continue;
179 }
180
181 srv->sa = malloc(ai_ptr->ai_addrlen);
182 if (srv->sa == NULL) {
183 close(srv->fd);
184 srv->fd = -1;
185 continue;
186 }
187
188 memcpy(srv->sa, ai_ptr->ai_addr, ai_ptr->ai_addrlen);
189 srv->sa_len = ai_ptr->ai_addrlen;
190 break;
191 }
192
193 freeaddrinfo(ai_list);
194
195 if (srv->fd < 0)
196 return -1;
197 return 0;
198 } /* }}} int server_open_socket */
199
200 static int server_send_buffer(lcc_server_t *srv) /* {{{ */
201 {
202 char buffer[LCC_NETWORK_BUFFER_SIZE_DEFAULT] = {0};
203 size_t buffer_size;
204 int status;
205
206 if (srv->fd < 0) {
207 status = server_open_socket(srv);
208 if (status != 0)
209 return status;
210 }
211
212 buffer_size = sizeof(buffer);
213
214 status = lcc_network_buffer_finalize(srv->buffer);
215 if (status != 0) {
216 lcc_network_buffer_initialize(srv->buffer);
217 return status;
218 }
219
220 status = lcc_network_buffer_get(srv->buffer, buffer, &buffer_size);
221 lcc_network_buffer_initialize(srv->buffer);
222
223 if (status != 0)
224 return status;
225
226 if (buffer_size > sizeof(buffer))
227 buffer_size = sizeof(buffer);
228
229 while (42) {
230 assert(srv->fd >= 0);
231 assert(srv->sa != NULL);
232 status = (int)sendto(srv->fd, buffer, buffer_size, /* flags = */ 0, srv->sa,
233 srv->sa_len);
234 if ((status < 0) && ((errno == EINTR) || (errno == EAGAIN)))
235 continue;
236
237 break;
238 }
239
240 if (status < 0)
241 return status;
242 return 0;
243 } /* }}} int server_send_buffer */
244
245 static int server_value_add(lcc_server_t *srv, /* {{{ */
246 const lcc_value_list_t *vl) {
247 int status;
248
249 status = lcc_network_buffer_add_value(srv->buffer, vl);
250 if (status == 0)
251 return 0;
252
253 server_send_buffer(srv);
254 return lcc_network_buffer_add_value(srv->buffer, vl);
255 } /* }}} int server_value_add */
256
257 /*
258 * Public functions
259 */
260 lcc_network_t *lcc_network_create(void) /* {{{ */
261 {
262 lcc_network_t *net;
263
264 net = calloc(1, sizeof(*net));
265 if (net == NULL)
266 return NULL;
267
268 net->servers = NULL;
269
270 return net;
271 } /* }}} lcc_network_t *lcc_network_create */
272
273 void lcc_network_destroy(lcc_network_t *net) /* {{{ */
274 {
275 if (net == NULL)
276 return;
277 int_server_destroy(net->servers);
278 free(net);
279 } /* }}} void lcc_network_destroy */
280
281 lcc_server_t *lcc_server_create(lcc_network_t *net, /* {{{ */
282 const char *node, const char *service) {
283 lcc_server_t *srv;
284
285 if ((net == NULL) || (node == NULL))
286 return NULL;
287 if (service == NULL)
288 service = NET_DEFAULT_PORT;
289
290 srv = calloc(1, sizeof(*srv));
291 if (srv == NULL)
292 return NULL;
293
294 srv->fd = -1;
295 srv->security_level = NONE;
296 srv->username = NULL;
297 srv->password = NULL;
298 srv->next = NULL;
299
300 srv->node = strdup(node);
301 if (srv->node == NULL) {
302 free(srv);
303 return NULL;
304 }
305
306 srv->service = strdup(service);
307 if (srv->service == NULL) {
308 free(srv->node);
309 free(srv);
310 return NULL;
311 }
312
313 srv->buffer = lcc_network_buffer_create(/* size = */ 0);
314 if (srv->buffer == NULL) {
315 free(srv->service);
316 free(srv->node);
317 free(srv);
318 return NULL;
319 }
320
321 if (net->servers == NULL) {
322 net->servers = srv;
323 } else {
324 lcc_server_t *last = net->servers;
325
326 while (last->next != NULL)
327 last = last->next;
328
329 last->next = srv;
330 }
331
332 return srv;
333 } /* }}} lcc_server_t *lcc_server_create */
334
335 int lcc_server_destroy(lcc_network_t *net, lcc_server_t *srv) /* {{{ */
336 {
337 if ((net == NULL) || (srv == NULL))
338 return EINVAL;
339
340 if (net->servers == srv) {
341 net->servers = srv->next;
342 srv->next = NULL;
343 } else {
344 lcc_server_t *prev = net->servers;
345
346 while ((prev != NULL) && (prev->next != srv))
347 prev = prev->next;
348
349 if (prev == NULL)
350 return ENOENT;
351
352 prev->next = srv->next;
353 srv->next = NULL;
354 }
355
356 int_server_destroy(srv);
357
358 return 0;
359 } /* }}} int lcc_server_destroy */
360
361 int lcc_server_set_ttl(lcc_server_t *srv, uint8_t ttl) /* {{{ */
362 {
363 if (srv == NULL)
364 return EINVAL;
365
366 srv->ttl = (int)ttl;
367
368 return 0;
369 } /* }}} int lcc_server_set_ttl */
370
371 int lcc_server_set_interface(lcc_server_t *srv, char const *iface) /* {{{ */
372 {
373 unsigned int if_index;
374 int status;
375
376 if ((srv == NULL) || (iface == NULL))
377 return EINVAL;
378
379 if_index = if_nametoindex(iface);
380 if (if_index == 0)
381 return ENOENT;
382
383 /* IPv4 multicast */
384 if (srv->sa->sa_family == AF_INET) {
385 struct sockaddr_in *addr = (struct sockaddr_in *)srv->sa;
386
387 if (IN_MULTICAST(ntohl(addr->sin_addr.s_addr))) {
388 #if HAVE_STRUCT_IP_MREQN_IMR_IFINDEX
389 /* If possible, use the "ip_mreqn" structure which has
390 * an "interface index" member. Using the interface
391 * index is preferred here, because of its similarity
392 * to the way IPv6 handles this. Unfortunately, it
393 * appears not to be portable. */
394 struct ip_mreqn mreq = {.imr_multiaddr.s_addr = addr->sin_addr.s_addr,
395 .imr_address.s_addr = ntohl(INADDR_ANY),
396 .imr_ifindex = (int)if_index};
397 #else
398 struct ip_mreq mreq = {.imr_multiaddr.s_addr = addr->sin_addr.s_addr,
399 .imr_interface.s_addr = ntohl(INADDR_ANY)};
400 #endif
401
402 status =
403 setsockopt(srv->fd, IPPROTO_IP, IP_MULTICAST_IF, &mreq, sizeof(mreq));
404 if (status != 0)
405 return status;
406
407 return 0;
408 }
409 }
410
411 /* IPv6 multicast */
412 if (srv->sa->sa_family == AF_INET6) {
413 struct sockaddr_in6 *addr = (struct sockaddr_in6 *)srv->sa;
414
415 if (IN6_IS_ADDR_MULTICAST(&addr->sin6_addr)) {
416 status = setsockopt(srv->fd, IPPROTO_IPV6, IPV6_MULTICAST_IF, &if_index,
417 sizeof(if_index));
418 if (status != 0)
419 return status;
420
421 return 0;
422 }
423 }
424
425 /* else: Not a multicast interface. */
426 #if defined(SO_BINDTODEVICE)
427 status = setsockopt(srv->fd, SOL_SOCKET, SO_BINDTODEVICE, iface,
428 (socklen_t)(strlen(iface) + 1));
429 if (status != 0)
430 return -1;
431 #endif
432
433 return 0;
434 } /* }}} int lcc_server_set_interface */
435
436 int lcc_server_set_security_level(lcc_server_t *srv, /* {{{ */
437 lcc_security_level_t level,
438 const char *username, const char *password) {
439 return lcc_network_buffer_set_security_level(srv->buffer, level, username,
440 password);
441 } /* }}} int lcc_server_set_security_level */
442
443 int lcc_network_values_send(lcc_network_t *net, /* {{{ */
444 const lcc_value_list_t *vl) {
445 if ((net == NULL) || (vl == NULL))
446 return EINVAL;
447
448 for (lcc_server_t *srv = net->servers; srv != NULL; srv = srv->next)
449 server_value_add(srv, vl);
450
451 return 0;
452 } /* }}} int lcc_network_values_send */