//! \brief call stop, free mutex, clear stack, free capture-Modul
void ende()
{
if(mutex_lock(mutex))
printf("encoder.ende Fehler beu mutex_lock 1\n");
g_run = 0;
if(mutex_unlock(mutex))
printf("encoder.ende Fehler bei mutex_unlock 1\n");
stop();
if(mutex_lock(mutex))
printf("encoder.ende Fehler bei mutex_lock 2\n");
//löschen des letzten Frames
getFrame(NULL, NULL);
if(mutex_unlock(mutex))
printf("encoder.ende Fehler bei mutex_unlock 2\n");
mutex_close(mutex);
mutex = NULL;
printf("Frames on Stack: %d\n", count_stack(g_FrameBuffer));
clear_stack(g_FrameBuffer);
if(capture)
{
capture->ende();
interface_close(capture);
}
capture = NULL;
printf("encoder.ende Encoder Modul ende\n");
}
void interface_shutdown(void)
{
struct interface *iface;
vlist_for_each_element(&interfaces, iface, node)
if (iface->fd.fd > 0 && iface->multicast) {
service_announce(iface, 0);
service_reply_a(iface, 0);
}
vlist_for_each_element(&interfaces, iface, node)
interface_close(iface);
}
static int
interface_send_packet4(struct interface *iface, struct iovec *iov, int iov_len)
{
static size_t cmsg_data[( CMSG_SPACE(sizeof(struct in_pktinfo)) / sizeof(size_t)) + 1];
static struct sockaddr_in a;
static struct msghdr m = {
.msg_name = (struct sockaddr *) &a,
.msg_namelen = sizeof(a),
.msg_control = cmsg_data,
.msg_controllen = CMSG_LEN(sizeof(struct in_pktinfo)),
};
struct in_pktinfo *pkti;
struct cmsghdr *cmsg;
int fd = iface->fd.fd;
a.sin_family = AF_INET;
a.sin_port = htons(MCAST_PORT);
m.msg_iov = iov;
m.msg_iovlen = iov_len;
memset(cmsg_data, 0, sizeof(cmsg_data));
cmsg = CMSG_FIRSTHDR(&m);
cmsg->cmsg_len = m.msg_controllen;
cmsg->cmsg_level = IPPROTO_IP;
cmsg->cmsg_type = IP_PKTINFO;
pkti = (struct in_pktinfo*) CMSG_DATA(cmsg);
pkti->ipi_ifindex = iface->ifindex;
a.sin_addr.s_addr = inet_addr(MCAST_ADDR);
return sendmsg(fd, &m, 0);
}
static int
interface_send_packet6(struct interface *iface, struct iovec *iov, int iov_len)
{
static size_t cmsg_data[( CMSG_SPACE(sizeof(struct in6_pktinfo)) / sizeof(size_t)) + 1];
static struct sockaddr_in6 a;
static struct msghdr m = {
.msg_name = (struct sockaddr *) &a,
.msg_namelen = sizeof(a),
.msg_control = cmsg_data,
.msg_controllen = CMSG_LEN(sizeof(struct in6_pktinfo)),
};
struct in6_pktinfo *pkti;
struct cmsghdr *cmsg;
int fd = iface->fd.fd;
a.sin6_family = AF_INET6;
a.sin6_port = htons(MCAST_PORT);
m.msg_iov = iov;
m.msg_iovlen = iov_len;
memset(cmsg_data, 0, sizeof(cmsg_data));
cmsg = CMSG_FIRSTHDR(&m);
cmsg->cmsg_len = m.msg_controllen;
cmsg->cmsg_level = IPPROTO_IPV6;
cmsg->cmsg_type = IPV6_PKTINFO;
pkti = (struct in6_pktinfo*) CMSG_DATA(cmsg);
pkti->ipi6_ifindex = iface->ifindex;
inet_pton(AF_INET6, MCAST_ADDR6, &a.sin6_addr);
return sendmsg(fd, &m, 0);
}
int
interface_send_packet(struct interface *iface, struct iovec *iov, int iov_len)
{
if (debug > 1) {
fprintf(stderr, "TX ipv%d: %s\n", iface->v6 * 2 + 4, iface->name);
fprintf(stderr, " multicast: %d\n", iface->multicast);
}
if (iface->v6)
return interface_send_packet6(iface, iov, iov_len);
return interface_send_packet4(iface, iov, iov_len);
}
static void interface_close(struct interface *iface)
{
if (iface->fd.fd < 0)
return;
announce_free(iface);
uloop_fd_delete(&iface->fd);
close(iface->fd.fd);
iface->fd.fd = -1;
}
static void interface_free(struct interface *iface)
{
interface_close(iface);
free(iface);
}
static int
interface_valid_src(void *ip1, void *mask, void *ip2, int len)
{
uint8_t *i1 = ip1;
uint8_t *i2 = ip2;
uint8_t *m = mask;
int i;
if (cfg_no_subnet)
return 0;
for (i = 0; i < len; i++, i1++, i2++, m++) {
if ((*i1 & *m) != (*i2 & *m))
return -1;
}
return 0;
}
static void
read_socket6(struct uloop_fd *u, unsigned int events)
{
struct interface *iface = container_of(u, struct interface, fd);
static uint8_t buffer[8 * 1024];
struct iovec iov[1];
char cmsg6[CMSG_SPACE(sizeof(struct in6_pktinfo)) + CMSG_SPACE(sizeof(int)) + 1];
struct cmsghdr *cmsgptr;
struct msghdr msg;
socklen_t len;
struct sockaddr_in6 from;
int flags = 0, ifindex = -1;
int ttl = 0;
struct in6_pktinfo *inp = NULL;
if (u->eof) {
interface_close(iface);
uloop_timeout_set(&iface->reconnect, 1000);
return;
}
iov[0].iov_base = buffer;
iov[0].iov_len = sizeof(buffer);
memset(&msg, 0, sizeof(msg));
msg.msg_name = (struct sockaddr *) &from;
msg.msg_namelen = sizeof(struct sockaddr_in6);
msg.msg_iov = iov;
msg.msg_iovlen = 1;
msg.msg_control = &cmsg6;
msg.msg_controllen = sizeof(cmsg6);
len = recvmsg(u->fd, &msg, flags);
if (len == -1) {
perror("read failed");
return;
}
for (cmsgptr = CMSG_FIRSTHDR(&msg); cmsgptr != NULL; cmsgptr = CMSG_NXTHDR(&msg, cmsgptr)) {
void *c = CMSG_DATA(cmsgptr);
switch (cmsgptr->cmsg_type) {
case IPV6_PKTINFO:
inp = ((struct in6_pktinfo *) c);
break;
case IPV6_HOPLIMIT:
ttl = (uint8_t) *((int *) c);
break;
default:
fprintf(stderr, "unknown cmsg %x\n", cmsgptr->cmsg_type);
return;
}
}
if (ttl != 255)
return;
if (debug > 1) {
char buf[256];
fprintf(stderr, "RX ipv6: %s\n", iface->name);
fprintf(stderr, " multicast: %d\n", iface->multicast);
inet_ntop(AF_INET6, &from.sin6_addr, buf, 256);
fprintf(stderr, " src %s:%d\n", buf, from.sin6_port);
inet_ntop(AF_INET6, &inp->ipi6_addr, buf, 256);
fprintf(stderr, " dst %s\n", buf);
}
if (inp->ipi6_ifindex != iface->ifindex)
fprintf(stderr, "invalid iface index %d != %d\n", ifindex, iface->ifindex);
else if (!interface_valid_src((void *) &iface->v4_addr, (void *) &iface->v4_netmask, (void *) &from.sin6_addr, 16))
dns_handle_packet(iface, (struct sockaddr *) &from, from.sin6_port, buffer, len);
}
