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 }