1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
|
/*
* DECT RAW socket support
*
* Copyright (c) 2009-2010 Patrick McHardy <kaber@trash.net>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*/
/**
* @defgroup raw Raw sockets
*
* libdect RAW sockets can be used to transmit or receive raw DECT
* MAC frames. For raw frame reception, a callback function for
* #dect_raw_ops::raw_rcv() must be provided by the user.
*
* @{
*/
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <linux/dect.h>
#include <libdect.h>
#include <utils.h>
#include <io.h>
#include <dect/raw.h>
static void dect_raw_fill_sockaddr(struct dect_handle *dh,
struct sockaddr_dect *da)
{
memset(da, 0, sizeof(*da));
da->dect_family = AF_DECT;
da->dect_index = dh->index;
}
/**
* Transmit a DECT frame on the specified slot
*
* @param dh libdect handle
* @param dfd libdect raw socket file descriptor
* @param slot slot number to transmit on
* @param mb libdect message buffer
*/
ssize_t dect_raw_transmit(struct dect_handle *dh, struct dect_fd *dfd,
uint8_t slot, struct dect_msg_buf *mb)
{
struct sockaddr_dect da;
struct iovec iov;
struct msghdr msg;
struct dect_raw_auxdata aux;
struct cmsghdr *cmsg;
union {
struct cmsghdr cmsg;
char buf[CMSG_SPACE(sizeof(aux))];
} cmsg_buf;
dect_raw_fill_sockaddr(dh, &da);
msg.msg_name = &da;
msg.msg_namelen = sizeof(da);
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
msg.msg_control = &cmsg_buf;
msg.msg_controllen = sizeof(cmsg_buf);
msg.msg_flags = 0;
iov.iov_len = mb->len;
iov.iov_base = mb->data;
cmsg = CMSG_FIRSTHDR(&msg);
cmsg->cmsg_len = CMSG_LEN(sizeof(aux));
cmsg->cmsg_level = SOL_DECT;
cmsg->cmsg_type = DECT_RAW_AUXDATA;
aux.mfn = 0;
aux.frame = 0;
aux.slot = slot;
memcpy(CMSG_DATA(cmsg), &aux, sizeof(aux));
return sendmsg(dfd->fd, &msg, 0);
}
EXPORT_SYMBOL(dect_raw_transmit);
static void dect_raw_event(struct dect_handle *dh, struct dect_fd *dfd,
uint32_t events)
{
DECT_DEFINE_MSG_BUF_ONSTACK(_mb), *mb = &_mb;
struct msghdr msg;
struct dect_raw_auxdata *aux;
struct cmsghdr *cmsg;
char cmsg_buf[4 * CMSG_SPACE(16)];
struct iovec iov;
ssize_t len;
dect_assert(!(events & ~DECT_FD_READ));
msg.msg_name = NULL;
msg.msg_namelen = 0;
msg.msg_control = cmsg_buf;
msg.msg_controllen = sizeof(cmsg_buf);
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
msg.msg_flags = 0;
iov.iov_base = mb->data;
iov.iov_len = sizeof(mb->head);
len = recvmsg(dfd->fd, &msg, 0);
if (len < 0)
return;
mb->len = len;
aux = NULL;
for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
if (cmsg->cmsg_level != SOL_DECT)
continue;
switch (cmsg->cmsg_type) {
case DECT_RAW_AUXDATA:
if (cmsg->cmsg_len < CMSG_LEN(sizeof(*aux)))
continue;
aux = (struct dect_raw_auxdata *)CMSG_DATA(cmsg);
continue;
default:
continue;
}
}
if (aux == NULL)
return;
mb->mfn = aux->mfn;
mb->frame = aux->frame;
mb->slot = aux->slot;
dh->ops->raw_ops->raw_rcv(dh, dfd, mb);
}
/**
* Open a new DECT raw socket
*
* @param dh libdect handle
*/
struct dect_fd *dect_raw_open(struct dect_handle *dh)
{
struct sockaddr_dect da;
struct dect_fd *dfd;
dfd = dect_socket(dh, SOCK_RAW, 0);
if (dfd == NULL)
goto err1;
/* Only bind socket if user wants to receive packets */
if (dh->ops->raw_ops == NULL ||
dh->ops->raw_ops->raw_rcv == NULL)
goto out;
dect_raw_fill_sockaddr(dh, &da);
if (bind(dfd->fd, (struct sockaddr *)&da, sizeof(da)) < 0)
goto err2;
dect_fd_setup(dfd, dect_raw_event, dfd);
if (dect_fd_register(dh, dfd, DECT_FD_READ) < 0)
goto err2;
out:
return dfd;
err2:
dect_close(dh, dfd);
err1:
return NULL;
}
EXPORT_SYMBOL(dect_raw_open);
/**
* Close a DECT raw socket
*
* @param dh libdect handle
* qparam dfd raw socket descriptor
*/
void dect_raw_close(struct dect_handle *dh, struct dect_fd *dfd)
{
dect_fd_unregister(dh, dfd);
dect_close(dh, dfd);
}
EXPORT_SYMBOL(dect_raw_close);
/** @} */
|
