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
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
|
/*
* (C) 2008-2010 by Pablo Neira Ayuso <pablo@netfilter.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*/
#include <stdio.h>
#include <ctype.h>
#include <errno.h>
#include <string.h>
#include <libmnl/libmnl.h>
/**
* mnl_align - align a value to four bytes
* @value: the value that we want to get aligned
*
* This function returns the value passed aligned to four bytes. Netlink
* message headers and its attributes are always aligned to four bytes.
*/
int mnl_align(int value)
{
return (value + MNL_ALIGNTO - 1) & ~(MNL_ALIGNTO - 1);
}
/**
* mnl_nlmsg_size - get size of the netlink messages (without alignment)
* @len: length of the netlink message
*
* This function returns the size of a netlink message (header plus payload)
* without alignment.
*/
size_t mnl_nlmsg_size(int len)
{
return len + mnl_align(MNL_NLMSG_HDRLEN);
}
/**
* mnl_nlmsg_aligned_size - get size of the netlink messages (with alignment)
* @len: length of the netlink message
*
* This function returns the size of a netlink message (header plus payload)
* with alignment.
*/
size_t mnl_nlmsg_aligned_size(int len)
{
return mnl_align(mnl_nlmsg_size(len));
}
/**
* mnl_nlmsg_payload_size - get the size of the payload
* @nlh: pointer to the header of the netlink message
*
* This function returns the size of the netlink payload
*/
size_t mnl_nlmsg_payload_size(const struct nlmsghdr *nlh)
{
return nlh->nlmsg_len - MNL_NLMSG_HDRLEN;
}
/**
* mnl_nlmsg_put_header - prepare room for Netlink header
* @buf: memory already allocated to store the Netlink message
*
* This function sets to zero the room that is required to put a Netlink
* header in the memory buffer passed as parameter. This function also
* initializes the nlmsg_len field. This function returns a pointer to the
* Netlink header structure.
*/
struct nlmsghdr *mnl_nlmsg_put_header(void *buf)
{
int len = mnl_align(sizeof(struct nlmsghdr));
struct nlmsghdr *nlh = buf;
memset(buf, 0, len);
nlh->nlmsg_len = len;
return nlh;
}
/**
* mnl_nlmsg_put_extra_header - prepare room for an extra header
* @nlh: pointer to Netlink header
* @size: size of the extra header that we want to put
*
* This function sets to zero the room that is required to put the extra
* header after the initial Netlink header. This function also increases
* the nlmsg_len field. This function returns a pointer to the extra
* header.
*/
void *mnl_nlmsg_put_extra_header(struct nlmsghdr *nlh, int size)
{
char *ptr = (char *)nlh + nlh->nlmsg_len;
nlh->nlmsg_len += mnl_align(size);
memset(ptr, 0, size);
return ptr;
}
/**
* mnl_nlmsg_get_len - get the length field from the netlink message
* @nlh: pointer to a netlink header
*
* This function returns the length of the netlink message by return the field
* nlmsg_len of the message.
*/
u_int16_t mnl_nlmsg_get_len(const struct nlmsghdr *nlh)
{
return nlh->nlmsg_len;
}
/**
* mnl_nlmsg_get_data - get a pointer to the payload of the netlink message
* @nlh: pointer to a netlink header
*
* This function returns a pointer to the payload of the netlink message.
*/
void *mnl_nlmsg_get_data(const struct nlmsghdr *nlh)
{
return (void *)nlh + MNL_NLMSG_HDRLEN;
}
/**
* mnl_nlmsg_get_data_offset - get a pointer to the payload of the message
* @nlh: pointer to a netlink header
* @offset: offset to the payload of the attributes TLV set
*
* This function returns a pointer to the payload of the netlink message plus
* a given offset.
*/
void *mnl_nlmsg_get_data_offset(const struct nlmsghdr *nlh, int offset)
{
return (void *)nlh + MNL_NLMSG_HDRLEN + mnl_align(offset);
}
/**
* mnl_nlmsg_ok - check a there is room for netlink message
* @nlh: netlink message that we want to check
* @len: remaining bytes in a buffer that contains the netlink message
*
* This function is used to check that a buffer that contains a netlink
* message has enough room for the netlink message that it stores, ie. this
* function can be used to verify that a netlink message is not malformed nor
* truncated.
*/
int mnl_nlmsg_ok(const struct nlmsghdr *nlh, int len)
{
return len >= sizeof(struct nlmsghdr) &&
nlh->nlmsg_len >= sizeof(struct nlmsghdr) &&
nlh->nlmsg_len <= len;
}
/**
* mnl_nlmsg_next - get the next netlink message in a multipart message
* @nlh: current netlink message that we are handling
* @len: pointer to the current remaining bytes in the buffer
*
* This function returns a pointer to the next netlink message that is part
* of a multi-part netlink message. Netlink can batches messages into a buffer
* so that the receiver has to iterate over the whole set of netlink
* messages.
*/
struct nlmsghdr *mnl_nlmsg_next(const struct nlmsghdr *nlh, int *len)
{
*len -= mnl_align(nlh->nlmsg_len);
return (struct nlmsghdr *)((void *)nlh + mnl_align(nlh->nlmsg_len));
}
/**
* mnl_nlmsg_get_tail - get the ending of the netlink message
* @nlh: pointer to netlink message
*
* This function returns a pointer to the netlink message tail. This is useful
* to build a message since we continue adding attribute at the end of it.
*/
void *mnl_nlmsg_get_tail(const struct nlmsghdr *nlh)
{
return (struct nlmsghdr *)((void *)nlh + mnl_align(nlh->nlmsg_len));
}
/**
* mnl_nlmsg_seq_ok - perform sequence tracking
* @nlh: current netlink message that we are handling
* @seq: last sequence number used to send a message
*
* This functions returns 1 if the sequence tracking is fulfilled, otherwise
* 0 is returned. If seq is 0, then the sequence tracking is skipped. This
* value is generally used by the kernel for asynchronous notifications,
* for that reason, this library consider that it is reserved.
*/
int mnl_nlmsg_seq_ok(const struct nlmsghdr *nlh, unsigned int seq)
{
return seq ? nlh->nlmsg_seq == seq : 1;
}
/* XXX: rework this, please */
void mnl_nlmsg_print(const struct nlmsghdr *nlh)
{
int i;
printf("========= netlink header ==========\n");
printf("length(32 bits)=%.08u\n", nlh->nlmsg_len);
printf("type(16 bits)=%.04u flags(16 bits)=%.04x\n",
nlh->nlmsg_type, nlh->nlmsg_flags);
printf("sequence number(32 bits)=%.08x\n", nlh->nlmsg_seq);
printf("port ID(32 bits)=%.08u\n", nlh->nlmsg_pid);
printf("===================================\n");
for (i=sizeof(struct nlmsghdr); i<mnl_nlmsg_get_len(nlh); i+=4) {
char *b = (char *) nlh;
printf("(%.3d) %.2x %.2x %.2x %.2x | ", i,
0xff & b[i], 0xff & b[i+1],
0xff & b[i+2], 0xff & b[i+3]);
printf("%c %c %c %c\n",
isalnum(b[i]) ? b[i] : 0,
isalnum(b[i+1]) ? b[i+1] : 0,
isalnum(b[i+2]) ? b[i+2] : 0,
isalnum(b[i+3]) ? b[i+3] : 0);
}
}
|
