wip send/recv
[psmb.git] / src / psmb_socket.c
1 #include <stdlib.h>
2 #include <string.h>
3 #include <errno.h>
4 #include <unistd.h>
5 #include <sys/types.h>
6 #include <arpa/inet.h>
7 #include <netinet/in.h>
8 #include <sys/socket.h>
9
10 #include <psmb.h>
11 #include "psmb_priv.h"
12 #include "hash64.h"
13
14 static void dummy_log(void *log_priv, int priority, const char *format, ...) {}
15
16 psmb_ctx_t *psmb_new(void)
17 {
18         return psmb_new_mm(malloc, free, realloc);
19 }
20
21 psmb_ctx_t *psmb_new_mm(void *(*malloc)(size_t size),
22                         void (*free)(void *ptr),
23                         void *(*realloc)(void *ptr, size_t size))
24 {
25         psmb_ctx_t *ctx = (*malloc)(sizeof(psmb_ctx_t));
26         if (!ctx) {
27                 int sverr = errno;
28                 LOG(ctx, LOG_ERR, "failed to allocate psmb_ctx: %m");
29                 errno = sverr;
30                 return NULL;
31         }
32         *ctx = (psmb_ctx_t){
33                 .fd = -1,
34                 .malloc = malloc, .free = free, .realloc = realloc,
35                 .logf = dummy_log,
36                 .prefix = (struct in6_addr){{{  0xff, 0x15,  'P',  'S',
37                                                  'M',  'B',  '0',  '1',
38                                                 0x00, 0x00, 0x00, 0x00,
39                                                 0x00, 0x00, 0x00, 0x00 }}},
40                 .prefixlen = 64,
41                 .pmtu = PSMB_DEFAULT_PMTU,
42                 .port = PSMB_DEFAULT_PORT};
43         return ctx;
44 }
45
46 psmb_result_t psmb_set_logf(psmb_ctx_t *ctx,
47         void (*logf)(void *log_priv, int priority, const char *format, ...),
48         void *log_priv)
49 {
50         if (ctx->fd == -1) {
51                 ctx->logf = logf;
52                 ctx->log_priv = log_priv;
53                 return (psmb_result_t){PSMB_OK};
54         } else {
55                 LOG(ctx, LOG_ERR, "psmb_set_...() used after psmb_open()");
56                 errno = EBUSY;
57                 return (psmb_result_t){PSMB_ERROR};
58         }
59 }
60
61 psmb_result_t psmb_set_pmtu(psmb_ctx_t *ctx, unsigned int pmtu)
62 {
63         if (ctx->fd == -1) {
64                 ctx->pmtu = pmtu;
65                 return (psmb_result_t){PSMB_OK};
66         } else {
67                 LOG(ctx, LOG_ERR, "psmb_set_...() used after psmb_open()");
68                 errno = EBUSY;
69                 return (psmb_result_t){PSMB_ERROR};
70         }
71 }
72
73 psmb_result_t psmb_set_port(psmb_ctx_t *ctx, unsigned short port)
74 {
75         if (ctx->fd == -1) {
76                 ctx->port = port;
77                 return (psmb_result_t){PSMB_OK};
78         } else {
79                 LOG(ctx, LOG_ERR, "psmb_set_...() used after psmb_open()");
80                 errno = EBUSY;
81                 return (psmb_result_t){PSMB_ERROR};
82         }
83 }
84
85 psmb_result_t psmb_set_mgrp(psmb_ctx_t *ctx, struct in6_addr prefix,
86         unsigned char prefixlen)
87 {
88         if (prefixlen > 128) {
89                 LOG(ctx, LOG_ERR, "psmb_set_mgrp() prefixlen %d is too big",
90                                 prefixlen);
91                 errno = EINVAL;
92                 return (psmb_result_t){PSMB_ERROR};
93         }
94         if (ctx->fd == -1) {
95                 ctx->prefix = prefix;
96                 ctx->prefixlen = prefixlen;
97                 return (psmb_result_t){PSMB_OK};
98         } else {
99                 LOG(ctx, LOG_ERR, "psmb_set_...() used after psmb_open()");
100                 errno = EBUSY;
101                 return (psmb_result_t){PSMB_ERROR};
102         }
103 }
104
105 psmb_result_t psmb_open(psmb_ctx_t *ctx)
106 {
107         unsigned long on = 1;
108         struct sockaddr_in6 addr = (struct sockaddr_in6){
109                 .sin6_family = AF_INET6,
110                 .sin6_addr = in6addr_any,
111                 .sin6_port = htons(ctx->port)
112         };
113
114         if (ctx->fd != -1) {
115                 LOG(ctx, LOG_ERR, "redundant call to psmb_open()");
116                 errno = EBUSY;
117                 return (psmb_result_t){PSMB_ERROR};
118         }
119         ctx->fd = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
120         if (ctx->fd == -1) {
121                 int sverr = errno;
122                 LOG(ctx, LOG_ERR, "socket: %m");
123                 errno = sverr;
124                 return (psmb_result_t){PSMB_ERROR};
125         }
126         if (setsockopt(ctx->fd, SOL_SOCKET, SO_REUSEADDR,
127                         &on, sizeof(on)) < 0) {
128                 int sverr = errno;
129                 LOG(ctx, LOG_ERR, "setsockopt(..., SO_REUSEADDR, ...): %m");
130                 close(ctx->fd);
131                 ctx->fd = -1;
132                 errno = sverr;
133                 return (psmb_result_t){PSMB_ERROR};
134         }
135         if (setsockopt(ctx->fd, IPPROTO_IPV6, IPV6_RECVPKTINFO,
136                         &on, sizeof(on)) < 0) {
137                 int sverr = errno;
138                 LOG(ctx, LOG_ERR, "setsockopt(..., IPV6_PKTINFO, ...): %m");
139                 close(ctx->fd);
140                 ctx->fd = -1;
141                 errno = sverr;
142                 return (psmb_result_t){PSMB_ERROR};
143         }
144         if (bind(ctx->fd, (struct sockaddr *)&addr,
145                         sizeof(struct sockaddr_in6)) == -1) {
146                 int sverr = errno;
147                 LOG(ctx, LOG_ERR, "bind(): %m");
148                 close(ctx->fd);
149                 ctx->fd = -1;
150                 errno = sverr;
151                 return (psmb_result_t){PSMB_ERROR};
152         }
153         /* TODO: set non-blocking */
154         return (psmb_result_t){PSMB_OK};
155 }
156
157 static struct in6_addr multiaddr(struct in6_addr prefix,
158                 unsigned char prefixlen, uint64_t suffix)
159 {
160         struct in6_addr result = prefix;
161         unsigned char len = prefixlen > 64 ? prefixlen : 64;
162         uint64_t mask = len == 64 ? ~(uint64_t)0 : ((uint64_t)1 << len) - 1;
163
164         *(uint64_t *)(&result.__in6_u.__u6_addr32[2]) &= ~mask;
165         *(uint64_t *)(&result.__in6_u.__u6_addr32[2]) |= (suffix & mask);
166         return result;
167 }
168
169 static psmb_result_t psmb_sub_unsub(psmb_ctx_t *ctx, char *channel, int option)
170 {
171         struct ipv6_mreq mreq = { 0 };
172         char mgrp_str[INET6_ADDRSTRLEN+1];
173
174         if (ctx->fd == -1) {
175                 LOG(ctx, LOG_ERR, "subscribe: psmb is not open");
176                 errno = EINVAL;
177                 return (psmb_result_t){PSMB_ERROR};
178         }
179         mreq.ipv6mr_multiaddr = multiaddr(ctx->prefix, ctx->prefixlen,
180                         hash64(channel, strlen(channel)));
181         (void)inet_ntop(AF_INET6, &mreq.ipv6mr_multiaddr,
182                         mgrp_str, sizeof(mgrp_str));
183         LOG(ctx, LOG_DEBUG, "using multiaddr %s for channel \"%s\"",
184                         mgrp_str, channel);
185         mreq.ipv6mr_interface = 0; /* how to use this??? */
186         if (setsockopt(ctx->fd, IPPROTO_IPV6, option,
187                         (void *)&mreq, sizeof(mreq)) == -1) {
188                 int sverr = errno;
189                 LOG(ctx, LOG_ERR, "add_membership(): %m");
190                 errno = sverr;
191                 return (psmb_result_t){PSMB_ERROR};
192         }
193         return (psmb_result_t){PSMB_OK};
194 }
195
196 psmb_result_t psmb_subscribe(psmb_ctx_t *ctx, char *channel)
197 {
198         return psmb_sub_unsub(ctx, channel, IPV6_ADD_MEMBERSHIP);
199 }
200
201 psmb_result_t psmb_unsubscribe(psmb_ctx_t *ctx, char *channel)
202 {
203         return psmb_sub_unsub(ctx, channel, IPV6_DROP_MEMBERSHIP);
204 }
205
206 psmb_result_t psmb_ev_rd(psmb_ctx_t *ctx)
207 {
208         char buf[MAXBUFLEN];
209         char cmsgbuf[MAXBUFLEN];
210         struct iovec iov[1];
211         iov[0].iov_base=buf;
212         iov[0].iov_len=sizeof(buf);
213         struct cmsghdr *cmsg;
214         struct msghdr message;
215         message.msg_name=&their_addr;
216 message.msg_namelen=sizeof(their_addr);
217 message.msg_iov=iov;
218 message.msg_iovlen=1;
219 message.msg_control=cmsgbuf;
220 message.msg_controllen=MAXBUFLEN;
221
222         if ((numbytes = recvmsg(sockfd, &message, 0)) == -1) {
223                 /* error */ ;
224         }
225         for (cmsg = CMSG_FIRSTHDR(&message); cmsg != NULL; cmsg = CMSG_NXTHDR(&message, cmsg)) {
226                 if (cmsg->cmsg_level != IPPROTO_IP || cmsg->cmsg_type != IP_PKTINFO)
227                         continue;
228                 struct in_pktinfo *pi = CMSG_DATA(cmsg);
229                 addr = pi->ipi_spec_dst.s_addr;
230         }
231         
232
233         return (psmb_result_t){PSMB_OK};
234 }
235
236 psmb_result_t psmb_ev_wr(psmb_ctx_t *ctx)
237 {
238         sock_opt_addr.s_addr = addr;
239         setsockopt(sockfd, IPPROTO_IP, IP_MULTICAST_IF, &sock_opt_addr, sizeof(sock_opt_addr));
240         sendto(sockfd, buffer, len, 0, (struct sockaddr *)&destination, sizeof destination);
241
242         return (psmb_result_t){PSMB_OK};
243 }
244
245 psmb_result_t psmb_ev_ex(psmb_ctx_t *ctx)
246 {
247         return (psmb_result_t){PSMB_OK};
248 }
249
250 psmb_result_t psmb_publish(psmb_ctx_t *ctx, char *channel,
251         void *data, size_t size)
252 {
253         return (psmb_result_t){PSMB_OK};
254 }
255
256 psmb_result_t psmb_get_message(psmb_ctx_t *ctx, char **channel,
257         void **data, size_t *size)
258 {
259         return (psmb_result_t){PSMB_OK};
260 }
261
262 bool psmb_success(psmb_result_t result)
263 {
264         return !(result.code & PSMB_ERROR);
265 }
266
267 bool psmb_message_waiting(psmb_result_t result)
268 {
269         return !!(result.code & PSMB_MESSAGE);
270 }
271
272 bool psmb_need_write_wait(psmb_result_t result)
273 {
274         return !!(result.code & PSMB_NEED_WRITE);
275 }
276
277 void psmb_destroy(psmb_ctx_t *ctx)
278 {
279         if (ctx->fd == -1) {
280                 LOG(ctx, LOG_ERR, "psmb_ctx is not open");
281         } else {
282                 if (close(ctx->fd) == -1)
283                         LOG(ctx, LOG_ERR, "close(): %m");
284         }
285         /* clean up the rest */
286         (*ctx->free)(ctx);
287 }