]> git.meshlink.io Git - catta/blob - avahi-core/netlink.c
improve documentation
[catta] / avahi-core / netlink.c
1 /* $Id$ */
2
3 /***
4   This file is part of avahi.
5  
6   avahi is free software; you can redistribute it and/or modify it
7   under the terms of the GNU Lesser General Public License as
8   published by the Free Software Foundation; either version 2.1 of the
9   License, or (at your option) any later version.
10  
11   avahi is distributed in the hope that it will be useful, but WITHOUT
12   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
13   or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
14   Public License for more details.
15  
16   You should have received a copy of the GNU Lesser General Public
17   License along with avahi; if not, write to the Free Software
18   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
19   USA.
20 ***/
21
22 #ifdef HAVE_CONFIG_H
23 #include <config.h>
24 #endif
25
26 #include <unistd.h>
27 #include <errno.h>
28 #include <string.h>
29 #include <sys/ioctl.h>
30
31 #include "netlink.h"
32 #include "log.h"
33
34 struct AvahiNetlink {
35     GMainContext *context;
36     gint fd;
37     guint seq;
38     GPollFD poll_fd;
39     GSource *source;
40     void (*callback) (AvahiNetlink *nl, struct nlmsghdr *n, gpointer userdata);
41     gpointer userdata;
42 };
43
44 gboolean avahi_netlink_work(AvahiNetlink *nl, gboolean block) {
45     g_assert(nl);
46
47     for (;;) {
48         ssize_t bytes;
49         struct nlmsghdr *p;
50         guint8 buffer[64*1024];
51
52         p = (struct nlmsghdr *) buffer;
53
54         if ((bytes = recv(nl->fd, buffer, sizeof(buffer), block ? 0 : MSG_DONTWAIT)) < 0) {
55
56             if (errno == EAGAIN || errno == EINTR)
57                 break;
58
59             avahi_log_warn("NETLINK: recv() failed: %s", strerror(errno));
60             return FALSE;
61         }
62
63         if (nl->callback) {
64             for (; bytes > 0; p = NLMSG_NEXT(p, bytes)) {
65                 if (!NLMSG_OK(p, (size_t) bytes)) {
66                     avahi_log_warn("NETLINK: packet truncated");
67                     return FALSE;
68                 }
69
70                 nl->callback(nl, p, nl->userdata);
71             }
72         }
73
74         if (block)
75             break;
76     }
77
78     return TRUE;
79 }
80
81 static gboolean prepare_func(GSource *source, gint *timeout) {
82     g_assert(source);
83     g_assert(timeout);
84     
85     *timeout = -1;
86     return FALSE;
87 }
88
89 static gboolean check_func(GSource *source) {
90     AvahiNetlink* nl;
91     g_assert(source);
92
93     nl = *((AvahiNetlink**) (((guint8*) source) + sizeof(GSource)));
94     g_assert(nl);
95     
96     return nl->poll_fd.revents & (G_IO_IN|G_IO_HUP|G_IO_ERR);
97 }
98
99 static gboolean dispatch_func(GSource *source, GSourceFunc callback, gpointer user_data) {
100     AvahiNetlink* nl;
101     g_assert(source);
102
103     nl = *((AvahiNetlink**) (((guint8*) source) + sizeof(GSource)));
104     g_assert(nl);
105     
106     return avahi_netlink_work(nl, FALSE);
107 }
108
109 AvahiNetlink *avahi_netlink_new(GMainContext *context, gint priority, guint32 groups, void (*cb) (AvahiNetlink *nl, struct nlmsghdr *n, gpointer userdata), gpointer userdata) {
110     int fd;
111     struct sockaddr_nl addr;
112     AvahiNetlink *nl;
113
114     static GSourceFuncs source_funcs = {
115         prepare_func,
116         check_func,
117         dispatch_func,
118         NULL,
119         NULL,
120         NULL
121     };
122     
123     g_assert(cb);
124
125     if ((fd = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE)) < 0) {
126         g_critical("NETLINK: socket(PF_NETLINK): %s", strerror(errno));
127         return NULL;
128     }
129     
130     memset(&addr, 0, sizeof(addr));
131     addr.nl_family = AF_NETLINK;
132     addr.nl_groups = groups;
133     addr.nl_pid = getpid();
134
135     if (bind(fd, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
136         close(fd);
137         g_critical("bind(): %s", strerror(errno));
138         return NULL;
139     }
140
141     nl = g_new(AvahiNetlink, 1);
142     g_main_context_ref(nl->context = context ? context : g_main_context_default());
143     nl->fd = fd;
144     nl->seq = 0;
145     nl->callback = cb;
146     nl->userdata = userdata;
147
148     nl->source = g_source_new(&source_funcs, sizeof(GSource) + sizeof(AvahiNetlink*));
149     *((AvahiNetlink**) (((guint8*) nl->source) + sizeof(GSource))) = nl;
150
151     g_source_set_priority(nl->source, priority);
152     
153     memset(&nl->poll_fd, 0, sizeof(GPollFD));
154     nl->poll_fd.fd = fd;
155     nl->poll_fd.events = G_IO_IN|G_IO_ERR|G_IO_HUP;
156     g_source_add_poll(nl->source, &nl->poll_fd);
157     
158     g_source_attach(nl->source, nl->context);
159     
160     return nl;
161 }
162
163 void avahi_netlink_free(AvahiNetlink *nl) {
164     g_assert(nl);
165
166     g_source_destroy(nl->source);
167     g_source_unref(nl->source);
168     g_main_context_unref(nl->context);
169     close(nl->fd);
170     g_free(nl);
171 }
172
173 int avahi_netlink_send(AvahiNetlink *nl, struct nlmsghdr *m, guint *ret_seq) {
174     g_assert(nl);
175     g_assert(m);
176     
177     m->nlmsg_seq = nl->seq++;
178     m->nlmsg_flags |= NLM_F_ACK;
179
180     if (send(nl->fd, m, m->nlmsg_len, 0) < 0) {
181         avahi_log_warn("NETLINK: send(): %s\n", strerror(errno));
182         return -1;
183     }
184
185     if (ret_seq)
186         *ret_seq = m->nlmsg_seq;
187
188     return 0;
189 }