1 /* Copyright (C) 2020-2021 Greenbone Networks GmbH
2 *
3 * SPDX-License-Identifier: AGPL-3.0-or-later
4 *
5 * This program is free software: you can redistribute it and/or modify
6 * it under the terms of the GNU Affero General Public License as
7 * published by the Free Software Foundation, either version 3 of the
8 * License, or (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU Affero General Public License for more details.
14 *
15 * You should have received a copy of the GNU Affero General Public License
16 * along with this program. If not, see <http://www.gnu.org/licenses/>.
17 */
18
19 /**
20 * @file manage_sql_port_lists.c
21 * @brief GVM management layer: Port list SQL
22 *
23 * The Port List SQL for the GVM management layer.
24 */
25
26 #include "manage_sql_port_lists.h"
27 #include "manage_acl.h"
28 #include "manage_port_lists.h"
29 #include "sql.h"
30
31 #include <errno.h>
32 #include <glib.h>
33 #include <glib/gstdio.h>
34 #include <stdlib.h>
35 #include <string.h>
36 #include <strings.h>
37
38 #undef G_LOG_DOMAIN
39 /**
40 * @brief GLib log domain.
41 */
42 #define G_LOG_DOMAIN "md manage"
43
44
45 /* Static headers for internal non-SQL functions. */
46
47 int
48 sync_port_lists_with_feed (gboolean);
49
50
51 /* Port list functions. */
52
53 /**
54 * @brief Insert a port range.
55 */
56 #define RANGE(type, start, end) \
57 sql ("INSERT INTO port_ranges" \
58 " (uuid, port_list, type, start, \"end\", comment, exclude)" \
59 " VALUES" \
60 " (make_uuid (), %llu, %i," \
61 " '" G_STRINGIFY (start) "'," \
62 " '" G_STRINGIFY (end) "'," \
63 " '', 0)", \
64 list, \
65 type)
66
67 /**
68 * @brief Make port ranges.
69 *
70 * Caller must lock the db.
71 *
72 * @param[in] list Port list.
73 */
74 static void
make_port_ranges_openvas_default(port_list_t list)75 make_port_ranges_openvas_default (port_list_t list)
76 {
77 RANGE (PORT_PROTOCOL_TCP, 1, 5);
78 RANGE (PORT_PROTOCOL_TCP, 7, 7);
79 RANGE (PORT_PROTOCOL_TCP, 9, 9);
80 RANGE (PORT_PROTOCOL_TCP, 11, 11);
81 RANGE (PORT_PROTOCOL_TCP, 13, 13);
82 RANGE (PORT_PROTOCOL_TCP, 15, 15);
83 RANGE (PORT_PROTOCOL_TCP, 17, 25);
84 RANGE (PORT_PROTOCOL_TCP, 27, 27);
85 RANGE (PORT_PROTOCOL_TCP, 29, 29);
86 RANGE (PORT_PROTOCOL_TCP, 31, 31);
87 RANGE (PORT_PROTOCOL_TCP, 33, 33);
88 RANGE (PORT_PROTOCOL_TCP, 35, 35);
89 RANGE (PORT_PROTOCOL_TCP, 37, 39);
90 RANGE (PORT_PROTOCOL_TCP, 41, 59);
91 RANGE (PORT_PROTOCOL_TCP, 61, 224);
92 RANGE (PORT_PROTOCOL_TCP, 242, 248);
93 RANGE (PORT_PROTOCOL_TCP, 256, 268);
94 RANGE (PORT_PROTOCOL_TCP, 280, 287);
95 RANGE (PORT_PROTOCOL_TCP, 308, 322);
96 RANGE (PORT_PROTOCOL_TCP, 333, 333);
97 RANGE (PORT_PROTOCOL_TCP, 344, 700);
98 RANGE (PORT_PROTOCOL_TCP, 702, 702);
99 RANGE (PORT_PROTOCOL_TCP, 704, 707);
100 RANGE (PORT_PROTOCOL_TCP, 709, 711);
101 RANGE (PORT_PROTOCOL_TCP, 721, 721);
102 RANGE (PORT_PROTOCOL_TCP, 723, 723);
103 RANGE (PORT_PROTOCOL_TCP, 729, 731);
104 RANGE (PORT_PROTOCOL_TCP, 740, 742);
105 RANGE (PORT_PROTOCOL_TCP, 744, 744);
106 RANGE (PORT_PROTOCOL_TCP, 747, 754);
107 RANGE (PORT_PROTOCOL_TCP, 758, 765);
108 RANGE (PORT_PROTOCOL_TCP, 767, 767);
109 RANGE (PORT_PROTOCOL_TCP, 769, 777);
110 RANGE (PORT_PROTOCOL_TCP, 780, 783);
111 RANGE (PORT_PROTOCOL_TCP, 786, 787);
112 RANGE (PORT_PROTOCOL_TCP, 799, 801);
113 RANGE (PORT_PROTOCOL_TCP, 808, 808);
114 RANGE (PORT_PROTOCOL_TCP, 810, 810);
115 RANGE (PORT_PROTOCOL_TCP, 828, 829);
116 RANGE (PORT_PROTOCOL_TCP, 847, 848);
117 RANGE (PORT_PROTOCOL_TCP, 860, 860);
118 RANGE (PORT_PROTOCOL_TCP, 871, 871);
119 RANGE (PORT_PROTOCOL_TCP, 873, 873);
120 RANGE (PORT_PROTOCOL_TCP, 886, 888);
121 RANGE (PORT_PROTOCOL_TCP, 898, 898);
122 RANGE (PORT_PROTOCOL_TCP, 900, 904);
123 RANGE (PORT_PROTOCOL_TCP, 911, 913);
124 RANGE (PORT_PROTOCOL_TCP, 927, 927);
125 RANGE (PORT_PROTOCOL_TCP, 950, 950);
126 RANGE (PORT_PROTOCOL_TCP, 953, 953);
127 RANGE (PORT_PROTOCOL_TCP, 975, 975);
128 RANGE (PORT_PROTOCOL_TCP, 989, 1002);
129 RANGE (PORT_PROTOCOL_TCP, 1005, 1005);
130 RANGE (PORT_PROTOCOL_TCP, 1008, 1008);
131 RANGE (PORT_PROTOCOL_TCP, 1010, 1010);
132 RANGE (PORT_PROTOCOL_TCP, 1023, 1027);
133 RANGE (PORT_PROTOCOL_TCP, 1029, 1036);
134 RANGE (PORT_PROTOCOL_TCP, 1040, 1040);
135 RANGE (PORT_PROTOCOL_TCP, 1042, 1042);
136 RANGE (PORT_PROTOCOL_TCP, 1045, 1045);
137 RANGE (PORT_PROTOCOL_TCP, 1047, 1112);
138 RANGE (PORT_PROTOCOL_TCP, 1114, 1117);
139 RANGE (PORT_PROTOCOL_TCP, 1119, 1120);
140 RANGE (PORT_PROTOCOL_TCP, 1122, 1127);
141 RANGE (PORT_PROTOCOL_TCP, 1139, 1139);
142 RANGE (PORT_PROTOCOL_TCP, 1154, 1155);
143 RANGE (PORT_PROTOCOL_TCP, 1161, 1162);
144 RANGE (PORT_PROTOCOL_TCP, 1168, 1170);
145 RANGE (PORT_PROTOCOL_TCP, 1178, 1178);
146 RANGE (PORT_PROTOCOL_TCP, 1180, 1181);
147 RANGE (PORT_PROTOCOL_TCP, 1183, 1188);
148 RANGE (PORT_PROTOCOL_TCP, 1194, 1194);
149 RANGE (PORT_PROTOCOL_TCP, 1199, 1231);
150 RANGE (PORT_PROTOCOL_TCP, 1233, 1286);
151 RANGE (PORT_PROTOCOL_TCP, 1288, 1774);
152 RANGE (PORT_PROTOCOL_TCP, 1776, 2028);
153 RANGE (PORT_PROTOCOL_TCP, 2030, 2030);
154 RANGE (PORT_PROTOCOL_TCP, 2032, 2035);
155 RANGE (PORT_PROTOCOL_TCP, 2037, 2038);
156 RANGE (PORT_PROTOCOL_TCP, 2040, 2065);
157 RANGE (PORT_PROTOCOL_TCP, 2067, 2083);
158 RANGE (PORT_PROTOCOL_TCP, 2086, 2087);
159 RANGE (PORT_PROTOCOL_TCP, 2089, 2152);
160 RANGE (PORT_PROTOCOL_TCP, 2155, 2155);
161 RANGE (PORT_PROTOCOL_TCP, 2159, 2167);
162 RANGE (PORT_PROTOCOL_TCP, 2170, 2177);
163 RANGE (PORT_PROTOCOL_TCP, 2180, 2181);
164 RANGE (PORT_PROTOCOL_TCP, 2190, 2191);
165 RANGE (PORT_PROTOCOL_TCP, 2199, 2202);
166 RANGE (PORT_PROTOCOL_TCP, 2213, 2213);
167 RANGE (PORT_PROTOCOL_TCP, 2220, 2223);
168 RANGE (PORT_PROTOCOL_TCP, 2232, 2246);
169 RANGE (PORT_PROTOCOL_TCP, 2248, 2255);
170 RANGE (PORT_PROTOCOL_TCP, 2260, 2260);
171 RANGE (PORT_PROTOCOL_TCP, 2273, 2273);
172 RANGE (PORT_PROTOCOL_TCP, 2279, 2289);
173 RANGE (PORT_PROTOCOL_TCP, 2294, 2311);
174 RANGE (PORT_PROTOCOL_TCP, 2313, 2371);
175 RANGE (PORT_PROTOCOL_TCP, 2381, 2425);
176 RANGE (PORT_PROTOCOL_TCP, 2427, 2681);
177 RANGE (PORT_PROTOCOL_TCP, 2683, 2824);
178 RANGE (PORT_PROTOCOL_TCP, 2826, 2854);
179 RANGE (PORT_PROTOCOL_TCP, 2856, 2924);
180 RANGE (PORT_PROTOCOL_TCP, 2926, 3096);
181 RANGE (PORT_PROTOCOL_TCP, 3098, 3299);
182 RANGE (PORT_PROTOCOL_TCP, 3302, 3321);
183 RANGE (PORT_PROTOCOL_TCP, 3326, 3366);
184 RANGE (PORT_PROTOCOL_TCP, 3372, 3403);
185 RANGE (PORT_PROTOCOL_TCP, 3405, 3545);
186 RANGE (PORT_PROTOCOL_TCP, 3547, 3707);
187 RANGE (PORT_PROTOCOL_TCP, 3709, 3765);
188 RANGE (PORT_PROTOCOL_TCP, 3767, 3770);
189 RANGE (PORT_PROTOCOL_TCP, 3772, 3800);
190 RANGE (PORT_PROTOCOL_TCP, 3802, 3802);
191 RANGE (PORT_PROTOCOL_TCP, 3845, 3871);
192 RANGE (PORT_PROTOCOL_TCP, 3875, 3876);
193 RANGE (PORT_PROTOCOL_TCP, 3885, 3885);
194 RANGE (PORT_PROTOCOL_TCP, 3900, 3900);
195 RANGE (PORT_PROTOCOL_TCP, 3928, 3929);
196 RANGE (PORT_PROTOCOL_TCP, 3939, 3939);
197 RANGE (PORT_PROTOCOL_TCP, 3959, 3959);
198 RANGE (PORT_PROTOCOL_TCP, 3970, 3971);
199 RANGE (PORT_PROTOCOL_TCP, 3984, 3987);
200 RANGE (PORT_PROTOCOL_TCP, 3999, 4036);
201 RANGE (PORT_PROTOCOL_TCP, 4040, 4042);
202 RANGE (PORT_PROTOCOL_TCP, 4045, 4045);
203 RANGE (PORT_PROTOCOL_TCP, 4080, 4080);
204 RANGE (PORT_PROTOCOL_TCP, 4096, 4100);
205 RANGE (PORT_PROTOCOL_TCP, 4111, 4111);
206 RANGE (PORT_PROTOCOL_TCP, 4114, 4114);
207 RANGE (PORT_PROTOCOL_TCP, 4132, 4134);
208 RANGE (PORT_PROTOCOL_TCP, 4138, 4138);
209 RANGE (PORT_PROTOCOL_TCP, 4141, 4145);
210 RANGE (PORT_PROTOCOL_TCP, 4154, 4154);
211 RANGE (PORT_PROTOCOL_TCP, 4160, 4160);
212 RANGE (PORT_PROTOCOL_TCP, 4199, 4200);
213 RANGE (PORT_PROTOCOL_TCP, 4242, 4242);
214 RANGE (PORT_PROTOCOL_TCP, 4300, 4300);
215 RANGE (PORT_PROTOCOL_TCP, 4321, 4321);
216 RANGE (PORT_PROTOCOL_TCP, 4333, 4333);
217 RANGE (PORT_PROTOCOL_TCP, 4343, 4351);
218 RANGE (PORT_PROTOCOL_TCP, 4353, 4358);
219 RANGE (PORT_PROTOCOL_TCP, 4369, 4369);
220 RANGE (PORT_PROTOCOL_TCP, 4400, 4400);
221 RANGE (PORT_PROTOCOL_TCP, 4442, 4457);
222 RANGE (PORT_PROTOCOL_TCP, 4480, 4480);
223 RANGE (PORT_PROTOCOL_TCP, 4500, 4500);
224 RANGE (PORT_PROTOCOL_TCP, 4545, 4547);
225 RANGE (PORT_PROTOCOL_TCP, 4555, 4555);
226 RANGE (PORT_PROTOCOL_TCP, 4557, 4557);
227 RANGE (PORT_PROTOCOL_TCP, 4559, 4559);
228 RANGE (PORT_PROTOCOL_TCP, 4567, 4568);
229 RANGE (PORT_PROTOCOL_TCP, 4600, 4601);
230 RANGE (PORT_PROTOCOL_TCP, 4658, 4662);
231 RANGE (PORT_PROTOCOL_TCP, 4672, 4672);
232 RANGE (PORT_PROTOCOL_TCP, 4752, 4752);
233 RANGE (PORT_PROTOCOL_TCP, 4800, 4802);
234 RANGE (PORT_PROTOCOL_TCP, 4827, 4827);
235 RANGE (PORT_PROTOCOL_TCP, 4837, 4839);
236 RANGE (PORT_PROTOCOL_TCP, 4848, 4849);
237 RANGE (PORT_PROTOCOL_TCP, 4868, 4869);
238 RANGE (PORT_PROTOCOL_TCP, 4885, 4885);
239 RANGE (PORT_PROTOCOL_TCP, 4894, 4894);
240 RANGE (PORT_PROTOCOL_TCP, 4899, 4899);
241 RANGE (PORT_PROTOCOL_TCP, 4950, 4950);
242 RANGE (PORT_PROTOCOL_TCP, 4983, 4983);
243 RANGE (PORT_PROTOCOL_TCP, 4987, 4989);
244 RANGE (PORT_PROTOCOL_TCP, 4998, 4998);
245 RANGE (PORT_PROTOCOL_TCP, 5000, 5011);
246 RANGE (PORT_PROTOCOL_TCP, 5020, 5025);
247 RANGE (PORT_PROTOCOL_TCP, 5031, 5031);
248 RANGE (PORT_PROTOCOL_TCP, 5042, 5042);
249 RANGE (PORT_PROTOCOL_TCP, 5050, 5057);
250 RANGE (PORT_PROTOCOL_TCP, 5060, 5061);
251 RANGE (PORT_PROTOCOL_TCP, 5064, 5066);
252 RANGE (PORT_PROTOCOL_TCP, 5069, 5069);
253 RANGE (PORT_PROTOCOL_TCP, 5071, 5071);
254 RANGE (PORT_PROTOCOL_TCP, 5081, 5081);
255 RANGE (PORT_PROTOCOL_TCP, 5093, 5093);
256 RANGE (PORT_PROTOCOL_TCP, 5099, 5102);
257 RANGE (PORT_PROTOCOL_TCP, 5137, 5137);
258 RANGE (PORT_PROTOCOL_TCP, 5145, 5145);
259 RANGE (PORT_PROTOCOL_TCP, 5150, 5152);
260 RANGE (PORT_PROTOCOL_TCP, 5154, 5154);
261 RANGE (PORT_PROTOCOL_TCP, 5165, 5165);
262 RANGE (PORT_PROTOCOL_TCP, 5190, 5193);
263 RANGE (PORT_PROTOCOL_TCP, 5200, 5203);
264 RANGE (PORT_PROTOCOL_TCP, 5222, 5222);
265 RANGE (PORT_PROTOCOL_TCP, 5225, 5226);
266 RANGE (PORT_PROTOCOL_TCP, 5232, 5232);
267 RANGE (PORT_PROTOCOL_TCP, 5236, 5236);
268 RANGE (PORT_PROTOCOL_TCP, 5250, 5251);
269 RANGE (PORT_PROTOCOL_TCP, 5264, 5265);
270 RANGE (PORT_PROTOCOL_TCP, 5269, 5269);
271 RANGE (PORT_PROTOCOL_TCP, 5272, 5272);
272 RANGE (PORT_PROTOCOL_TCP, 5282, 5282);
273 RANGE (PORT_PROTOCOL_TCP, 5300, 5311);
274 RANGE (PORT_PROTOCOL_TCP, 5314, 5315);
275 RANGE (PORT_PROTOCOL_TCP, 5351, 5355);
276 RANGE (PORT_PROTOCOL_TCP, 5400, 5432);
277 RANGE (PORT_PROTOCOL_TCP, 5435, 5435);
278 RANGE (PORT_PROTOCOL_TCP, 5454, 5456);
279 RANGE (PORT_PROTOCOL_TCP, 5461, 5463);
280 RANGE (PORT_PROTOCOL_TCP, 5465, 5465);
281 RANGE (PORT_PROTOCOL_TCP, 5500, 5504);
282 RANGE (PORT_PROTOCOL_TCP, 5510, 5510);
283 RANGE (PORT_PROTOCOL_TCP, 5520, 5521);
284 RANGE (PORT_PROTOCOL_TCP, 5530, 5530);
285 RANGE (PORT_PROTOCOL_TCP, 5540, 5540);
286 RANGE (PORT_PROTOCOL_TCP, 5550, 5550);
287 RANGE (PORT_PROTOCOL_TCP, 5553, 5556);
288 RANGE (PORT_PROTOCOL_TCP, 5566, 5566);
289 RANGE (PORT_PROTOCOL_TCP, 5569, 5569);
290 RANGE (PORT_PROTOCOL_TCP, 5595, 5605);
291 RANGE (PORT_PROTOCOL_TCP, 5631, 5632);
292 RANGE (PORT_PROTOCOL_TCP, 5666, 5666);
293 RANGE (PORT_PROTOCOL_TCP, 5673, 5680);
294 RANGE (PORT_PROTOCOL_TCP, 5688, 5688);
295 RANGE (PORT_PROTOCOL_TCP, 5690, 5690);
296 RANGE (PORT_PROTOCOL_TCP, 5713, 5717);
297 RANGE (PORT_PROTOCOL_TCP, 5720, 5720);
298 RANGE (PORT_PROTOCOL_TCP, 5729, 5730);
299 RANGE (PORT_PROTOCOL_TCP, 5741, 5742);
300 RANGE (PORT_PROTOCOL_TCP, 5745, 5746);
301 RANGE (PORT_PROTOCOL_TCP, 5755, 5755);
302 RANGE (PORT_PROTOCOL_TCP, 5757, 5757);
303 RANGE (PORT_PROTOCOL_TCP, 5766, 5768);
304 RANGE (PORT_PROTOCOL_TCP, 5771, 5771);
305 RANGE (PORT_PROTOCOL_TCP, 5800, 5803);
306 RANGE (PORT_PROTOCOL_TCP, 5813, 5813);
307 RANGE (PORT_PROTOCOL_TCP, 5858, 5859);
308 RANGE (PORT_PROTOCOL_TCP, 5882, 5882);
309 RANGE (PORT_PROTOCOL_TCP, 5888, 5889);
310 RANGE (PORT_PROTOCOL_TCP, 5900, 5903);
311 RANGE (PORT_PROTOCOL_TCP, 5968, 5969);
312 RANGE (PORT_PROTOCOL_TCP, 5977, 5979);
313 RANGE (PORT_PROTOCOL_TCP, 5987, 5991);
314 RANGE (PORT_PROTOCOL_TCP, 5997, 6010);
315 RANGE (PORT_PROTOCOL_TCP, 6050, 6051);
316 RANGE (PORT_PROTOCOL_TCP, 6064, 6073);
317 RANGE (PORT_PROTOCOL_TCP, 6085, 6085);
318 RANGE (PORT_PROTOCOL_TCP, 6100, 6112);
319 RANGE (PORT_PROTOCOL_TCP, 6123, 6123);
320 RANGE (PORT_PROTOCOL_TCP, 6141, 6150);
321 RANGE (PORT_PROTOCOL_TCP, 6175, 6177);
322 RANGE (PORT_PROTOCOL_TCP, 6200, 6200);
323 RANGE (PORT_PROTOCOL_TCP, 6253, 6253);
324 RANGE (PORT_PROTOCOL_TCP, 6255, 6255);
325 RANGE (PORT_PROTOCOL_TCP, 6270, 6270);
326 RANGE (PORT_PROTOCOL_TCP, 6300, 6300);
327 RANGE (PORT_PROTOCOL_TCP, 6321, 6322);
328 RANGE (PORT_PROTOCOL_TCP, 6343, 6343);
329 RANGE (PORT_PROTOCOL_TCP, 6346, 6347);
330 RANGE (PORT_PROTOCOL_TCP, 6373, 6373);
331 RANGE (PORT_PROTOCOL_TCP, 6382, 6382);
332 RANGE (PORT_PROTOCOL_TCP, 6389, 6389);
333 RANGE (PORT_PROTOCOL_TCP, 6400, 6400);
334 RANGE (PORT_PROTOCOL_TCP, 6455, 6456);
335 RANGE (PORT_PROTOCOL_TCP, 6471, 6471);
336 RANGE (PORT_PROTOCOL_TCP, 6500, 6503);
337 RANGE (PORT_PROTOCOL_TCP, 6505, 6510);
338 RANGE (PORT_PROTOCOL_TCP, 6543, 6543);
339 RANGE (PORT_PROTOCOL_TCP, 6547, 6550);
340 RANGE (PORT_PROTOCOL_TCP, 6558, 6558);
341 RANGE (PORT_PROTOCOL_TCP, 6566, 6566);
342 RANGE (PORT_PROTOCOL_TCP, 6580, 6582);
343 RANGE (PORT_PROTOCOL_TCP, 6588, 6588);
344 RANGE (PORT_PROTOCOL_TCP, 6620, 6621);
345 RANGE (PORT_PROTOCOL_TCP, 6623, 6623);
346 RANGE (PORT_PROTOCOL_TCP, 6628, 6628);
347 RANGE (PORT_PROTOCOL_TCP, 6631, 6631);
348 RANGE (PORT_PROTOCOL_TCP, 6665, 6670);
349 RANGE (PORT_PROTOCOL_TCP, 6672, 6673);
350 RANGE (PORT_PROTOCOL_TCP, 6699, 6701);
351 RANGE (PORT_PROTOCOL_TCP, 6714, 6714);
352 RANGE (PORT_PROTOCOL_TCP, 6767, 6768);
353 RANGE (PORT_PROTOCOL_TCP, 6776, 6776);
354 RANGE (PORT_PROTOCOL_TCP, 6788, 6790);
355 RANGE (PORT_PROTOCOL_TCP, 6831, 6831);
356 RANGE (PORT_PROTOCOL_TCP, 6841, 6842);
357 RANGE (PORT_PROTOCOL_TCP, 6850, 6850);
358 RANGE (PORT_PROTOCOL_TCP, 6881, 6889);
359 RANGE (PORT_PROTOCOL_TCP, 6891, 6891);
360 RANGE (PORT_PROTOCOL_TCP, 6901, 6901);
361 RANGE (PORT_PROTOCOL_TCP, 6939, 6939);
362 RANGE (PORT_PROTOCOL_TCP, 6961, 6966);
363 RANGE (PORT_PROTOCOL_TCP, 6969, 6970);
364 RANGE (PORT_PROTOCOL_TCP, 6998, 7015);
365 RANGE (PORT_PROTOCOL_TCP, 7020, 7021);
366 RANGE (PORT_PROTOCOL_TCP, 7030, 7030);
367 RANGE (PORT_PROTOCOL_TCP, 7070, 7070);
368 RANGE (PORT_PROTOCOL_TCP, 7099, 7100);
369 RANGE (PORT_PROTOCOL_TCP, 7121, 7121);
370 RANGE (PORT_PROTOCOL_TCP, 7161, 7161);
371 RANGE (PORT_PROTOCOL_TCP, 7170, 7170);
372 RANGE (PORT_PROTOCOL_TCP, 7174, 7174);
373 RANGE (PORT_PROTOCOL_TCP, 7200, 7201);
374 RANGE (PORT_PROTOCOL_TCP, 7210, 7210);
375 RANGE (PORT_PROTOCOL_TCP, 7269, 7269);
376 RANGE (PORT_PROTOCOL_TCP, 7273, 7273);
377 RANGE (PORT_PROTOCOL_TCP, 7280, 7281);
378 RANGE (PORT_PROTOCOL_TCP, 7283, 7283);
379 RANGE (PORT_PROTOCOL_TCP, 7300, 7300);
380 RANGE (PORT_PROTOCOL_TCP, 7320, 7320);
381 RANGE (PORT_PROTOCOL_TCP, 7326, 7326);
382 RANGE (PORT_PROTOCOL_TCP, 7391, 7392);
383 RANGE (PORT_PROTOCOL_TCP, 7395, 7395);
384 RANGE (PORT_PROTOCOL_TCP, 7426, 7431);
385 RANGE (PORT_PROTOCOL_TCP, 7437, 7437);
386 RANGE (PORT_PROTOCOL_TCP, 7464, 7464);
387 RANGE (PORT_PROTOCOL_TCP, 7491, 7491);
388 RANGE (PORT_PROTOCOL_TCP, 7501, 7501);
389 RANGE (PORT_PROTOCOL_TCP, 7510, 7511);
390 RANGE (PORT_PROTOCOL_TCP, 7544, 7545);
391 RANGE (PORT_PROTOCOL_TCP, 7560, 7560);
392 RANGE (PORT_PROTOCOL_TCP, 7566, 7566);
393 RANGE (PORT_PROTOCOL_TCP, 7570, 7570);
394 RANGE (PORT_PROTOCOL_TCP, 7575, 7575);
395 RANGE (PORT_PROTOCOL_TCP, 7588, 7588);
396 RANGE (PORT_PROTOCOL_TCP, 7597, 7597);
397 RANGE (PORT_PROTOCOL_TCP, 7624, 7624);
398 RANGE (PORT_PROTOCOL_TCP, 7626, 7627);
399 RANGE (PORT_PROTOCOL_TCP, 7633, 7634);
400 RANGE (PORT_PROTOCOL_TCP, 7648, 7649);
401 RANGE (PORT_PROTOCOL_TCP, 7666, 7666);
402 RANGE (PORT_PROTOCOL_TCP, 7674, 7676);
403 RANGE (PORT_PROTOCOL_TCP, 7743, 7743);
404 RANGE (PORT_PROTOCOL_TCP, 7775, 7779);
405 RANGE (PORT_PROTOCOL_TCP, 7781, 7781);
406 RANGE (PORT_PROTOCOL_TCP, 7786, 7786);
407 RANGE (PORT_PROTOCOL_TCP, 7797, 7798);
408 RANGE (PORT_PROTOCOL_TCP, 7800, 7801);
409 RANGE (PORT_PROTOCOL_TCP, 7845, 7846);
410 RANGE (PORT_PROTOCOL_TCP, 7875, 7875);
411 RANGE (PORT_PROTOCOL_TCP, 7902, 7902);
412 RANGE (PORT_PROTOCOL_TCP, 7913, 7913);
413 RANGE (PORT_PROTOCOL_TCP, 7932, 7933);
414 RANGE (PORT_PROTOCOL_TCP, 7967, 7967);
415 RANGE (PORT_PROTOCOL_TCP, 7979, 7980);
416 RANGE (PORT_PROTOCOL_TCP, 7999, 8005);
417 RANGE (PORT_PROTOCOL_TCP, 8007, 8010);
418 RANGE (PORT_PROTOCOL_TCP, 8022, 8022);
419 RANGE (PORT_PROTOCOL_TCP, 8032, 8033);
420 RANGE (PORT_PROTOCOL_TCP, 8044, 8044);
421 RANGE (PORT_PROTOCOL_TCP, 8074, 8074);
422 RANGE (PORT_PROTOCOL_TCP, 8080, 8082);
423 RANGE (PORT_PROTOCOL_TCP, 8088, 8089);
424 RANGE (PORT_PROTOCOL_TCP, 8098, 8098);
425 RANGE (PORT_PROTOCOL_TCP, 8100, 8100);
426 RANGE (PORT_PROTOCOL_TCP, 8115, 8116);
427 RANGE (PORT_PROTOCOL_TCP, 8118, 8118);
428 RANGE (PORT_PROTOCOL_TCP, 8121, 8122);
429 RANGE (PORT_PROTOCOL_TCP, 8130, 8132);
430 RANGE (PORT_PROTOCOL_TCP, 8160, 8161);
431 RANGE (PORT_PROTOCOL_TCP, 8181, 8194);
432 RANGE (PORT_PROTOCOL_TCP, 8199, 8201);
433 RANGE (PORT_PROTOCOL_TCP, 8204, 8208);
434 RANGE (PORT_PROTOCOL_TCP, 8224, 8225);
435 RANGE (PORT_PROTOCOL_TCP, 8245, 8245);
436 RANGE (PORT_PROTOCOL_TCP, 8311, 8311);
437 RANGE (PORT_PROTOCOL_TCP, 8351, 8351);
438 RANGE (PORT_PROTOCOL_TCP, 8376, 8380);
439 RANGE (PORT_PROTOCOL_TCP, 8400, 8403);
440 RANGE (PORT_PROTOCOL_TCP, 8416, 8417);
441 RANGE (PORT_PROTOCOL_TCP, 8431, 8431);
442 RANGE (PORT_PROTOCOL_TCP, 8443, 8444);
443 RANGE (PORT_PROTOCOL_TCP, 8450, 8450);
444 RANGE (PORT_PROTOCOL_TCP, 8473, 8473);
445 RANGE (PORT_PROTOCOL_TCP, 8554, 8555);
446 RANGE (PORT_PROTOCOL_TCP, 8649, 8649);
447 RANGE (PORT_PROTOCOL_TCP, 8733, 8733);
448 RANGE (PORT_PROTOCOL_TCP, 8763, 8765);
449 RANGE (PORT_PROTOCOL_TCP, 8786, 8787);
450 RANGE (PORT_PROTOCOL_TCP, 8804, 8804);
451 RANGE (PORT_PROTOCOL_TCP, 8863, 8864);
452 RANGE (PORT_PROTOCOL_TCP, 8875, 8875);
453 RANGE (PORT_PROTOCOL_TCP, 8880, 8880);
454 RANGE (PORT_PROTOCOL_TCP, 8888, 8894);
455 RANGE (PORT_PROTOCOL_TCP, 8900, 8901);
456 RANGE (PORT_PROTOCOL_TCP, 8910, 8911);
457 RANGE (PORT_PROTOCOL_TCP, 8954, 8954);
458 RANGE (PORT_PROTOCOL_TCP, 8989, 8989);
459 RANGE (PORT_PROTOCOL_TCP, 8999, 9002);
460 RANGE (PORT_PROTOCOL_TCP, 9006, 9006);
461 RANGE (PORT_PROTOCOL_TCP, 9009, 9009);
462 RANGE (PORT_PROTOCOL_TCP, 9020, 9026);
463 RANGE (PORT_PROTOCOL_TCP, 9080, 9080);
464 RANGE (PORT_PROTOCOL_TCP, 9090, 9091);
465 RANGE (PORT_PROTOCOL_TCP, 9100, 9103);
466 RANGE (PORT_PROTOCOL_TCP, 9110, 9111);
467 RANGE (PORT_PROTOCOL_TCP, 9131, 9131);
468 RANGE (PORT_PROTOCOL_TCP, 9152, 9152);
469 RANGE (PORT_PROTOCOL_TCP, 9160, 9164);
470 RANGE (PORT_PROTOCOL_TCP, 9200, 9207);
471 RANGE (PORT_PROTOCOL_TCP, 9210, 9211);
472 RANGE (PORT_PROTOCOL_TCP, 9217, 9217);
473 RANGE (PORT_PROTOCOL_TCP, 9281, 9285);
474 RANGE (PORT_PROTOCOL_TCP, 9287, 9287);
475 RANGE (PORT_PROTOCOL_TCP, 9292, 9292);
476 RANGE (PORT_PROTOCOL_TCP, 9321, 9321);
477 RANGE (PORT_PROTOCOL_TCP, 9343, 9344);
478 RANGE (PORT_PROTOCOL_TCP, 9346, 9346);
479 RANGE (PORT_PROTOCOL_TCP, 9374, 9374);
480 RANGE (PORT_PROTOCOL_TCP, 9390, 9390);
481 RANGE (PORT_PROTOCOL_TCP, 9396, 9397);
482 RANGE (PORT_PROTOCOL_TCP, 9400, 9400);
483 RANGE (PORT_PROTOCOL_TCP, 9418, 9418);
484 RANGE (PORT_PROTOCOL_TCP, 9495, 9495);
485 RANGE (PORT_PROTOCOL_TCP, 9500, 9500);
486 RANGE (PORT_PROTOCOL_TCP, 9535, 9537);
487 RANGE (PORT_PROTOCOL_TCP, 9593, 9595);
488 RANGE (PORT_PROTOCOL_TCP, 9600, 9600);
489 RANGE (PORT_PROTOCOL_TCP, 9612, 9612);
490 RANGE (PORT_PROTOCOL_TCP, 9704, 9704);
491 RANGE (PORT_PROTOCOL_TCP, 9747, 9747);
492 RANGE (PORT_PROTOCOL_TCP, 9753, 9753);
493 RANGE (PORT_PROTOCOL_TCP, 9797, 9797);
494 RANGE (PORT_PROTOCOL_TCP, 9800, 9802);
495 RANGE (PORT_PROTOCOL_TCP, 9872, 9872);
496 RANGE (PORT_PROTOCOL_TCP, 9875, 9876);
497 RANGE (PORT_PROTOCOL_TCP, 9888, 9889);
498 RANGE (PORT_PROTOCOL_TCP, 9898, 9901);
499 RANGE (PORT_PROTOCOL_TCP, 9909, 9909);
500 RANGE (PORT_PROTOCOL_TCP, 9911, 9911);
501 RANGE (PORT_PROTOCOL_TCP, 9950, 9952);
502 RANGE (PORT_PROTOCOL_TCP, 9990, 10005);
503 RANGE (PORT_PROTOCOL_TCP, 10007, 10008);
504 RANGE (PORT_PROTOCOL_TCP, 10012, 10012);
505 RANGE (PORT_PROTOCOL_TCP, 10080, 10083);
506 RANGE (PORT_PROTOCOL_TCP, 10101, 10103);
507 RANGE (PORT_PROTOCOL_TCP, 10113, 10116);
508 RANGE (PORT_PROTOCOL_TCP, 10128, 10128);
509 RANGE (PORT_PROTOCOL_TCP, 10252, 10252);
510 RANGE (PORT_PROTOCOL_TCP, 10260, 10260);
511 RANGE (PORT_PROTOCOL_TCP, 10288, 10288);
512 RANGE (PORT_PROTOCOL_TCP, 10607, 10607);
513 RANGE (PORT_PROTOCOL_TCP, 10666, 10666);
514 RANGE (PORT_PROTOCOL_TCP, 10752, 10752);
515 RANGE (PORT_PROTOCOL_TCP, 10990, 10990);
516 RANGE (PORT_PROTOCOL_TCP, 11000, 11001);
517 RANGE (PORT_PROTOCOL_TCP, 11111, 11111);
518 RANGE (PORT_PROTOCOL_TCP, 11201, 11201);
519 RANGE (PORT_PROTOCOL_TCP, 11223, 11223);
520 RANGE (PORT_PROTOCOL_TCP, 11319, 11321);
521 RANGE (PORT_PROTOCOL_TCP, 11367, 11367);
522 RANGE (PORT_PROTOCOL_TCP, 11371, 11371);
523 RANGE (PORT_PROTOCOL_TCP, 11600, 11600);
524 RANGE (PORT_PROTOCOL_TCP, 11720, 11720);
525 RANGE (PORT_PROTOCOL_TCP, 11751, 11751);
526 RANGE (PORT_PROTOCOL_TCP, 11965, 11965);
527 RANGE (PORT_PROTOCOL_TCP, 11967, 11967);
528 RANGE (PORT_PROTOCOL_TCP, 11999, 12006);
529 RANGE (PORT_PROTOCOL_TCP, 12076, 12076);
530 RANGE (PORT_PROTOCOL_TCP, 12109, 12109);
531 RANGE (PORT_PROTOCOL_TCP, 12168, 12168);
532 RANGE (PORT_PROTOCOL_TCP, 12172, 12172);
533 RANGE (PORT_PROTOCOL_TCP, 12223, 12223);
534 RANGE (PORT_PROTOCOL_TCP, 12321, 12321);
535 RANGE (PORT_PROTOCOL_TCP, 12345, 12346);
536 RANGE (PORT_PROTOCOL_TCP, 12361, 12362);
537 RANGE (PORT_PROTOCOL_TCP, 12468, 12468);
538 RANGE (PORT_PROTOCOL_TCP, 12701, 12701);
539 RANGE (PORT_PROTOCOL_TCP, 12753, 12753);
540 RANGE (PORT_PROTOCOL_TCP, 13160, 13160);
541 RANGE (PORT_PROTOCOL_TCP, 13223, 13224);
542 RANGE (PORT_PROTOCOL_TCP, 13701, 13702);
543 RANGE (PORT_PROTOCOL_TCP, 13705, 13706);
544 RANGE (PORT_PROTOCOL_TCP, 13708, 13718);
545 RANGE (PORT_PROTOCOL_TCP, 13720, 13722);
546 RANGE (PORT_PROTOCOL_TCP, 13724, 13724);
547 RANGE (PORT_PROTOCOL_TCP, 13782, 13783);
548 RANGE (PORT_PROTOCOL_TCP, 13818, 13822);
549 RANGE (PORT_PROTOCOL_TCP, 14001, 14001);
550 RANGE (PORT_PROTOCOL_TCP, 14033, 14034);
551 RANGE (PORT_PROTOCOL_TCP, 14141, 14141);
552 RANGE (PORT_PROTOCOL_TCP, 14145, 14145);
553 RANGE (PORT_PROTOCOL_TCP, 14149, 14149);
554 RANGE (PORT_PROTOCOL_TCP, 14194, 14194);
555 RANGE (PORT_PROTOCOL_TCP, 14237, 14237);
556 RANGE (PORT_PROTOCOL_TCP, 14936, 14937);
557 RANGE (PORT_PROTOCOL_TCP, 15000, 15000);
558 RANGE (PORT_PROTOCOL_TCP, 15126, 15126);
559 RANGE (PORT_PROTOCOL_TCP, 15345, 15345);
560 RANGE (PORT_PROTOCOL_TCP, 15363, 15363);
561 RANGE (PORT_PROTOCOL_TCP, 16360, 16361);
562 RANGE (PORT_PROTOCOL_TCP, 16367, 16368);
563 RANGE (PORT_PROTOCOL_TCP, 16384, 16384);
564 RANGE (PORT_PROTOCOL_TCP, 16660, 16661);
565 RANGE (PORT_PROTOCOL_TCP, 16959, 16959);
566 RANGE (PORT_PROTOCOL_TCP, 16969, 16969);
567 RANGE (PORT_PROTOCOL_TCP, 16991, 16991);
568 RANGE (PORT_PROTOCOL_TCP, 17007, 17007);
569 RANGE (PORT_PROTOCOL_TCP, 17185, 17185);
570 RANGE (PORT_PROTOCOL_TCP, 17219, 17219);
571 RANGE (PORT_PROTOCOL_TCP, 17300, 17300);
572 RANGE (PORT_PROTOCOL_TCP, 17770, 17772);
573 RANGE (PORT_PROTOCOL_TCP, 18000, 18000);
574 RANGE (PORT_PROTOCOL_TCP, 18181, 18187);
575 RANGE (PORT_PROTOCOL_TCP, 18190, 18190);
576 RANGE (PORT_PROTOCOL_TCP, 18241, 18241);
577 RANGE (PORT_PROTOCOL_TCP, 18463, 18463);
578 RANGE (PORT_PROTOCOL_TCP, 18769, 18769);
579 RANGE (PORT_PROTOCOL_TCP, 18888, 18888);
580 RANGE (PORT_PROTOCOL_TCP, 19191, 19191);
581 RANGE (PORT_PROTOCOL_TCP, 19194, 19194);
582 RANGE (PORT_PROTOCOL_TCP, 19283, 19283);
583 RANGE (PORT_PROTOCOL_TCP, 19315, 19315);
584 RANGE (PORT_PROTOCOL_TCP, 19398, 19398);
585 RANGE (PORT_PROTOCOL_TCP, 19410, 19412);
586 RANGE (PORT_PROTOCOL_TCP, 19540, 19541);
587 RANGE (PORT_PROTOCOL_TCP, 19638, 19638);
588 RANGE (PORT_PROTOCOL_TCP, 19726, 19726);
589 RANGE (PORT_PROTOCOL_TCP, 20000, 20001);
590 RANGE (PORT_PROTOCOL_TCP, 20005, 20005);
591 RANGE (PORT_PROTOCOL_TCP, 20011, 20012);
592 RANGE (PORT_PROTOCOL_TCP, 20034, 20034);
593 RANGE (PORT_PROTOCOL_TCP, 20200, 20200);
594 RANGE (PORT_PROTOCOL_TCP, 20202, 20203);
595 RANGE (PORT_PROTOCOL_TCP, 20222, 20222);
596 RANGE (PORT_PROTOCOL_TCP, 20670, 20670);
597 RANGE (PORT_PROTOCOL_TCP, 20999, 21000);
598 RANGE (PORT_PROTOCOL_TCP, 21490, 21490);
599 RANGE (PORT_PROTOCOL_TCP, 21544, 21544);
600 RANGE (PORT_PROTOCOL_TCP, 21590, 21590);
601 RANGE (PORT_PROTOCOL_TCP, 21800, 21800);
602 RANGE (PORT_PROTOCOL_TCP, 21845, 21849);
603 RANGE (PORT_PROTOCOL_TCP, 22000, 22001);
604 RANGE (PORT_PROTOCOL_TCP, 22222, 22222);
605 RANGE (PORT_PROTOCOL_TCP, 22273, 22273);
606 RANGE (PORT_PROTOCOL_TCP, 22289, 22289);
607 RANGE (PORT_PROTOCOL_TCP, 22305, 22305);
608 RANGE (PORT_PROTOCOL_TCP, 22321, 22321);
609 RANGE (PORT_PROTOCOL_TCP, 22370, 22370);
610 RANGE (PORT_PROTOCOL_TCP, 22555, 22555);
611 RANGE (PORT_PROTOCOL_TCP, 22800, 22800);
612 RANGE (PORT_PROTOCOL_TCP, 22951, 22951);
613 RANGE (PORT_PROTOCOL_TCP, 23456, 23456);
614 RANGE (PORT_PROTOCOL_TCP, 24000, 24006);
615 RANGE (PORT_PROTOCOL_TCP, 24242, 24242);
616 RANGE (PORT_PROTOCOL_TCP, 24249, 24249);
617 RANGE (PORT_PROTOCOL_TCP, 24345, 24347);
618 RANGE (PORT_PROTOCOL_TCP, 24386, 24386);
619 RANGE (PORT_PROTOCOL_TCP, 24554, 24554);
620 RANGE (PORT_PROTOCOL_TCP, 24677, 24678);
621 RANGE (PORT_PROTOCOL_TCP, 24922, 24922);
622 RANGE (PORT_PROTOCOL_TCP, 25000, 25009);
623 RANGE (PORT_PROTOCOL_TCP, 25378, 25378);
624 RANGE (PORT_PROTOCOL_TCP, 25544, 25544);
625 RANGE (PORT_PROTOCOL_TCP, 25793, 25793);
626 RANGE (PORT_PROTOCOL_TCP, 25867, 25867);
627 RANGE (PORT_PROTOCOL_TCP, 25901, 25901);
628 RANGE (PORT_PROTOCOL_TCP, 25903, 25903);
629 RANGE (PORT_PROTOCOL_TCP, 26000, 26000);
630 RANGE (PORT_PROTOCOL_TCP, 26208, 26208);
631 RANGE (PORT_PROTOCOL_TCP, 26260, 26264);
632 RANGE (PORT_PROTOCOL_TCP, 27000, 27010);
633 RANGE (PORT_PROTOCOL_TCP, 27345, 27345);
634 RANGE (PORT_PROTOCOL_TCP, 27374, 27374);
635 RANGE (PORT_PROTOCOL_TCP, 27504, 27504);
636 RANGE (PORT_PROTOCOL_TCP, 27665, 27665);
637 RANGE (PORT_PROTOCOL_TCP, 27999, 27999);
638 RANGE (PORT_PROTOCOL_TCP, 28001, 28001);
639 RANGE (PORT_PROTOCOL_TCP, 29559, 29559);
640 RANGE (PORT_PROTOCOL_TCP, 29891, 29891);
641 RANGE (PORT_PROTOCOL_TCP, 30001, 30002);
642 RANGE (PORT_PROTOCOL_TCP, 30100, 30102);
643 RANGE (PORT_PROTOCOL_TCP, 30303, 30303);
644 RANGE (PORT_PROTOCOL_TCP, 30999, 30999);
645 RANGE (PORT_PROTOCOL_TCP, 31337, 31337);
646 RANGE (PORT_PROTOCOL_TCP, 31339, 31339);
647 RANGE (PORT_PROTOCOL_TCP, 31416, 31416);
648 RANGE (PORT_PROTOCOL_TCP, 31457, 31457);
649 RANGE (PORT_PROTOCOL_TCP, 31554, 31554);
650 RANGE (PORT_PROTOCOL_TCP, 31556, 31556);
651 RANGE (PORT_PROTOCOL_TCP, 31620, 31620);
652 RANGE (PORT_PROTOCOL_TCP, 31765, 31765);
653 RANGE (PORT_PROTOCOL_TCP, 31785, 31787);
654 RANGE (PORT_PROTOCOL_TCP, 32261, 32261);
655 RANGE (PORT_PROTOCOL_TCP, 32666, 32666);
656 RANGE (PORT_PROTOCOL_TCP, 32768, 32780);
657 RANGE (PORT_PROTOCOL_TCP, 32786, 32787);
658 RANGE (PORT_PROTOCOL_TCP, 32896, 32896);
659 RANGE (PORT_PROTOCOL_TCP, 33270, 33270);
660 RANGE (PORT_PROTOCOL_TCP, 33331, 33331);
661 RANGE (PORT_PROTOCOL_TCP, 33434, 33434);
662 RANGE (PORT_PROTOCOL_TCP, 33911, 33911);
663 RANGE (PORT_PROTOCOL_TCP, 34249, 34249);
664 RANGE (PORT_PROTOCOL_TCP, 34324, 34324);
665 RANGE (PORT_PROTOCOL_TCP, 34952, 34952);
666 RANGE (PORT_PROTOCOL_TCP, 36865, 36865);
667 RANGE (PORT_PROTOCOL_TCP, 37475, 37475);
668 RANGE (PORT_PROTOCOL_TCP, 37651, 37651);
669 RANGE (PORT_PROTOCOL_TCP, 38037, 38037);
670 RANGE (PORT_PROTOCOL_TCP, 38201, 38201);
671 RANGE (PORT_PROTOCOL_TCP, 38292, 38293);
672 RANGE (PORT_PROTOCOL_TCP, 39681, 39681);
673 RANGE (PORT_PROTOCOL_TCP, 40412, 40412);
674 RANGE (PORT_PROTOCOL_TCP, 40841, 40843);
675 RANGE (PORT_PROTOCOL_TCP, 41111, 41111);
676 RANGE (PORT_PROTOCOL_TCP, 41508, 41508);
677 RANGE (PORT_PROTOCOL_TCP, 41794, 41795);
678 RANGE (PORT_PROTOCOL_TCP, 42508, 42510);
679 RANGE (PORT_PROTOCOL_TCP, 43118, 43118);
680 RANGE (PORT_PROTOCOL_TCP, 43188, 43190);
681 RANGE (PORT_PROTOCOL_TCP, 44321, 44322);
682 RANGE (PORT_PROTOCOL_TCP, 44333, 44334);
683 RANGE (PORT_PROTOCOL_TCP, 44442, 44443);
684 RANGE (PORT_PROTOCOL_TCP, 44818, 44818);
685 RANGE (PORT_PROTOCOL_TCP, 45000, 45000);
686 RANGE (PORT_PROTOCOL_TCP, 45054, 45054);
687 RANGE (PORT_PROTOCOL_TCP, 45678, 45678);
688 RANGE (PORT_PROTOCOL_TCP, 45966, 45966);
689 RANGE (PORT_PROTOCOL_TCP, 47000, 47000);
690 RANGE (PORT_PROTOCOL_TCP, 47557, 47557);
691 RANGE (PORT_PROTOCOL_TCP, 47624, 47624);
692 RANGE (PORT_PROTOCOL_TCP, 47806, 47806);
693 RANGE (PORT_PROTOCOL_TCP, 47808, 47808);
694 RANGE (PORT_PROTOCOL_TCP, 47891, 47891);
695 RANGE (PORT_PROTOCOL_TCP, 48000, 48003);
696 RANGE (PORT_PROTOCOL_TCP, 48556, 48556);
697 RANGE (PORT_PROTOCOL_TCP, 49400, 49400);
698 RANGE (PORT_PROTOCOL_TCP, 50000, 50004);
699 RANGE (PORT_PROTOCOL_TCP, 50505, 50505);
700 RANGE (PORT_PROTOCOL_TCP, 50776, 50776);
701 RANGE (PORT_PROTOCOL_TCP, 51210, 51210);
702 RANGE (PORT_PROTOCOL_TCP, 53001, 53001);
703 RANGE (PORT_PROTOCOL_TCP, 54320, 54321);
704 RANGE (PORT_PROTOCOL_TCP, 57341, 57341);
705 RANGE (PORT_PROTOCOL_TCP, 59595, 59595);
706 RANGE (PORT_PROTOCOL_TCP, 60177, 60177);
707 RANGE (PORT_PROTOCOL_TCP, 60179, 60179);
708 RANGE (PORT_PROTOCOL_TCP, 61439, 61441);
709 RANGE (PORT_PROTOCOL_TCP, 61446, 61446);
710 RANGE (PORT_PROTOCOL_TCP, 65000, 65000);
711 RANGE (PORT_PROTOCOL_TCP, 65301, 65301);
712 }
713
714 /**
715 * @brief Find a port list given a UUID.
716 *
717 * @param[in] uuid UUID of port_list.
718 * @param[out] port_list Port_List return, 0 if successfully failed to find
719 * port_list.
720 *
721 * @return FALSE on success (including if failed to find port_list), TRUE on error.
722 */
723 gboolean
find_port_list(const char * uuid,port_list_t * port_list)724 find_port_list (const char* uuid, port_list_t* port_list)
725 {
726 gchar *quoted_uuid = sql_quote (uuid);
727 if (acl_user_owns_uuid ("port_list", quoted_uuid, 0) == 0)
728 {
729 g_free (quoted_uuid);
730 *port_list = 0;
731 return FALSE;
732 }
733 switch (sql_int64 (port_list,
734 "SELECT id FROM port_lists WHERE uuid = '%s';",
735 quoted_uuid))
736 {
737 case 0:
738 break;
739 case 1: /* Too few rows in result of query. */
740 *port_list = 0;
741 break;
742 default: /* Programming error. */
743 assert (0);
744 case -1:
745 g_free (quoted_uuid);
746 return TRUE;
747 break;
748 }
749
750 g_free (quoted_uuid);
751 return FALSE;
752 }
753
754 /**
755 * @brief Find a port list given a UUID.
756 *
757 * This does not do any permission checks.
758 *
759 * @param[in] uuid UUID of resource.
760 * @param[out] port_list Port list return, 0 if no such port list.
761 *
762 * @return FALSE on success (including if no such port list), TRUE on error.
763 */
764 gboolean
find_port_list_no_acl(const char * uuid,port_list_t * port_list)765 find_port_list_no_acl (const char *uuid, port_list_t *port_list)
766 {
767 gchar *quoted_uuid;
768
769 quoted_uuid = sql_quote (uuid);
770 switch (sql_int64 (port_list,
771 "SELECT id FROM port_lists WHERE uuid = '%s';",
772 quoted_uuid))
773 {
774 case 0:
775 break;
776 case 1: /* Too few rows in result of query. */
777 *port_list = 0;
778 break;
779 default: /* Programming error. */
780 assert (0);
781 case -1:
782 g_free (quoted_uuid);
783 return TRUE;
784 break;
785 }
786
787 g_free (quoted_uuid);
788 return FALSE;
789 }
790
791 /**
792 * @brief Find a port list for a specific permission, given a UUID.
793 *
794 * @param[in] uuid UUID of port list.
795 * @param[out] port_list Port list return, 0 if successfully failed to find
796 * port list.
797 * @param[in] permission Permission.
798 *
799 * @return FALSE on success (including if failed to find port_list), TRUE on
800 * error.
801 */
802 gboolean
find_port_list_with_permission(const char * uuid,port_list_t * port_list,const char * permission)803 find_port_list_with_permission (const char* uuid, port_list_t* port_list,
804 const char *permission)
805 {
806 return find_resource_with_permission ("port_list", uuid, port_list,
807 permission, 0);
808 }
809
810 /**
811 * @brief Find a trash port list given a UUID.
812 *
813 * This does not do any permission checks.
814 *
815 * @param[in] uuid UUID of resource.
816 * @param[out] port_list Port list return, 0 if no such port list.
817 *
818 * @return FALSE on success (including if no such port list), TRUE on error.
819 */
820 gboolean
find_trash_port_list_no_acl(const char * uuid,port_list_t * port_list)821 find_trash_port_list_no_acl (const char *uuid, port_list_t *port_list)
822 {
823 gchar *quoted_uuid;
824
825 quoted_uuid = sql_quote (uuid);
826 switch (sql_int64 (port_list,
827 "SELECT id FROM port_lists_trash WHERE uuid = '%s';",
828 quoted_uuid))
829 {
830 case 0:
831 break;
832 case 1: /* Too few rows in result of query. */
833 *port_list = 0;
834 break;
835 default: /* Programming error. */
836 assert (0);
837 case -1:
838 g_free (quoted_uuid);
839 return TRUE;
840 break;
841 }
842
843 g_free (quoted_uuid);
844 return FALSE;
845 }
846
847 /**
848 * @brief Return whether a port list is predefined.
849 *
850 * @param[in] port_list Port list.
851 *
852 * @return 1 if predefined, else 0.
853 */
854 int
port_list_predefined(port_list_t port_list)855 port_list_predefined (port_list_t port_list)
856 {
857 return sql_int ("SELECT predefined FROM port_lists"
858 " WHERE id = %llu;",
859 port_list);
860 }
861
862 /**
863 * @brief Return whether a trash port list is predefined.
864 *
865 * @param[in] port_list Port list.
866 *
867 * @return 1 if predefined, else 0.
868 */
869 int
trash_port_list_predefined(port_list_t port_list)870 trash_port_list_predefined (port_list_t port_list)
871 {
872 return sql_int ("SELECT predefined FROM port_lists_trash"
873 " WHERE id = %llu;",
874 port_list);
875 }
876
877 /**
878 * @brief Return the UUID of the port list of a port_range.
879 *
880 * @param[in] port_range Port Range UUID.
881 *
882 * @return Newly allocated UUID if available, else NULL.
883 */
884 static char*
port_range_port_list_uuid(const char * port_range)885 port_range_port_list_uuid (const char *port_range)
886 {
887 gchar *quoted_port_range;
888 char *ret;
889
890 quoted_port_range = sql_quote (port_range);
891 if (sql_int ("SELECT count (*) FROM port_ranges WHERE uuid = '%s';",
892 quoted_port_range))
893 ret = sql_string ("SELECT uuid FROM port_lists"
894 " WHERE id = (SELECT port_list FROM port_ranges"
895 " WHERE uuid = '%s');",
896 quoted_port_range);
897 else
898 ret = NULL;
899 g_free (quoted_port_range);
900 return ret;
901 }
902
903 /**
904 * @brief Find a port range given a UUID.
905 *
906 * @param[in] uuid UUID of port_range.
907 * @param[out] port_range Port range return, 0 if successfully failed to find
908 * port range.
909 * @param[in] permission UUID of port_range.
910 *
911 * @return FALSE on success (including if failed to find port range), TRUE on
912 * error.
913 */
914 static gboolean
find_port_range_with_permission(const char * uuid,port_range_t * port_range,const char * permission)915 find_port_range_with_permission (const char *uuid, port_range_t *port_range,
916 const char *permission)
917 {
918 char *port_list_uuid;
919 gchar *quoted_uuid;
920 port_list_t port_list;
921
922 assert (current_credentials.uuid);
923
924 *port_range = 0;
925
926 if (uuid == NULL)
927 return TRUE;
928
929 port_list_uuid = port_range_port_list_uuid (uuid);
930 if (port_list_uuid == NULL)
931 return TRUE;
932
933 if (find_port_list_with_permission (port_list_uuid, &port_list, permission)
934 || port_list == 0)
935 {
936 g_free (port_list_uuid);
937 return TRUE;
938 }
939 g_free (port_list_uuid);
940
941 quoted_uuid = sql_quote (uuid);
942 switch (sql_int64 (port_range,
943 "SELECT id FROM port_ranges WHERE uuid = '%s';",
944 quoted_uuid))
945 {
946 case 0:
947 break;
948 case 1: /* Too few rows in result of query. */
949 *port_range = 0;
950 break;
951 default: /* Programming error. */
952 assert (0);
953 case -1:
954 g_free (quoted_uuid);
955 return TRUE;
956 break;
957 }
958
959 g_free (quoted_uuid);
960 return FALSE;
961 }
962
963 /**
964 * @brief Compare two ranges by type then start.
965 *
966 * @param[in] one First range.
967 * @param[in] two Second range.
968 *
969 * @return 0 equal, 1 one greater, -1 two greater.
970 */
971 static int
range_compare(gconstpointer one,gconstpointer two)972 range_compare (gconstpointer one, gconstpointer two)
973 {
974 range_t *range_one, *range_two;
975
976 range_one = *((range_t**) one);
977 range_two = *((range_t**) two);
978
979 if (range_one->type > range_two->type)
980 return 1;
981
982 if (range_one->type < range_two->type)
983 return -1;
984
985 if (range_one->start > range_two->start)
986 return 1;
987
988 if (range_one->start < range_two->start)
989 return -1;
990
991 return 0;
992 }
993
994 /**
995 * @brief Sort and merge ranges.
996 *
997 * @param[in] ranges Array of port ranges of type range_t.
998 */
999 static void
ranges_sort_merge(array_t * ranges)1000 ranges_sort_merge (array_t *ranges)
1001 {
1002 if (ranges->len > 1)
1003 {
1004 int index;
1005 range_t *last_range;
1006
1007 /* Sort by type then start. */
1008
1009 g_ptr_array_sort (ranges, range_compare);
1010
1011 /* Merge overlaps. */
1012
1013 last_range = (range_t*) g_ptr_array_index (ranges, 0);
1014 for (index = 1; index < ranges->len; )
1015 {
1016 range_t *range;
1017
1018 range = (range_t*) g_ptr_array_index (ranges, index);
1019 if (range == NULL)
1020 break;
1021
1022 if (range->type == last_range->type
1023 && range->start <= last_range->end)
1024 {
1025 if (range->end > last_range->end)
1026 last_range->end = range->end;
1027 /* This moves everything else up into the space. */
1028 g_ptr_array_remove_index (ranges, index);
1029 }
1030 else
1031 {
1032 index++;
1033 last_range = range;
1034 }
1035 }
1036 }
1037 }
1038
1039 /**
1040 * @brief Create a port list, with database locked.
1041 *
1042 * Caller must lock the database.
1043 *
1044 * @param[in] quoted_id SQL quoted UUID, or NULL.
1045 * @param[in] quoted_name SQL quoted name of port list.
1046 * @param[in] comment Comment on port list.
1047 * @param[in] ranges Port ranges of port list.
1048 * @param[in] predefined Whether port list is predefined.
1049 * @param[out] port_list Created port list.
1050 *
1051 * @return 0 success.
1052 */
1053 static int
create_port_list_lock(const char * quoted_id,const char * quoted_name,const char * comment,array_t * ranges,int predefined,port_list_t * port_list)1054 create_port_list_lock (const char *quoted_id, const char *quoted_name,
1055 const char *comment, array_t *ranges, int predefined,
1056 port_list_t* port_list)
1057 {
1058 gchar *quoted_comment;
1059 range_t *range;
1060 int index;
1061
1062 assert (comment);
1063
1064 quoted_comment = sql_quote (comment);
1065 if (quoted_id)
1066 sql ("INSERT INTO port_lists"
1067 " (uuid, owner, name, comment, predefined, creation_time,"
1068 " modification_time)"
1069 " VALUES"
1070 " ('%s', (SELECT id FROM users WHERE uuid = '%s'), '%s',"
1071 " '%s', %i, m_now (), m_now ());",
1072 quoted_id,
1073 current_credentials.uuid,
1074 quoted_name,
1075 quoted_comment,
1076 predefined);
1077 else
1078 sql ("INSERT INTO port_lists"
1079 " (uuid, owner, name, comment, predefined, creation_time,"
1080 " modification_time)"
1081 " VALUES"
1082 " (make_uuid (), (SELECT id FROM users WHERE uuid = '%s'), '%s',"
1083 " '%s', %i, m_now (), m_now ());",
1084 current_credentials.uuid,
1085 quoted_name,
1086 quoted_comment,
1087 predefined);
1088 g_free (quoted_comment);
1089
1090 *port_list = sql_last_insert_id ();
1091
1092 ranges_sort_merge (ranges);
1093 array_terminate (ranges);
1094 index = 0;
1095 while ((range = (range_t*) g_ptr_array_index (ranges, index++)))
1096 sql ("INSERT INTO port_ranges"
1097 " (uuid, port_list, type, start, \"end\", comment, exclude)"
1098 " VALUES"
1099 " (make_uuid (), %llu, %i, %i, %i, '', %i);",
1100 *port_list,
1101 range->type,
1102 range->start,
1103 range->end,
1104 range->exclude);
1105 return 0;
1106 }
1107
1108 /**
1109 * @brief Create a port list having a unique name.
1110 *
1111 * Caller must provide transaction.
1112 *
1113 * @param[in] name Name of port list.
1114 * @param[in] comment Comment on port list.
1115 * @param[in] port_range GMP style port range list.
1116 * @param[out] port_list Created port list.
1117 *
1118 * @return 0 success, 4 error in port range.
1119 */
1120 int
create_port_list_unique(const char * name,const char * comment,const char * port_range,port_list_t * port_list)1121 create_port_list_unique (const char *name, const char *comment,
1122 const char* port_range, port_list_t* port_list)
1123 {
1124 gchar *quoted_name;
1125 array_t *ranges;
1126 int suffix, ret;
1127
1128 assert (current_credentials.uuid);
1129
1130 if (validate_port_range (port_range))
1131 return 4;
1132
1133 ranges = port_range_ranges (port_range);
1134
1135 /* Check whether a port list with the same name exists already. */
1136 suffix = 1;
1137 quoted_name = sql_quote (name);
1138 while (resource_with_name_exists (quoted_name, "port_list", 0))
1139 {
1140 gchar *new_name;
1141 new_name = g_strdup_printf ("%s %i", name, suffix);
1142 g_free (quoted_name);
1143 quoted_name = sql_quote (new_name);
1144 g_free (new_name);
1145 suffix++;
1146 }
1147
1148 ret = create_port_list_lock (NULL, quoted_name, comment, ranges, 0,
1149 port_list);
1150
1151 array_free (ranges);
1152
1153 return ret;
1154 }
1155
1156 /**
1157 * @brief Create a port list.
1158 *
1159 * @param[in] check_access Whether to check for create_config permission.
1160 * @param[in] id ID of port list. Only used with \p ranges.
1161 * @param[in] name Name of port list.
1162 * @param[in] comment Comment on port list.
1163 * @param[in] port_ranges GMP port range string.
1164 * @param[in] ranges Array of port ranges of type range_t.
1165 * Overrides port_ranges.
1166 * @param[in] predefined Whether port list is predefined.
1167 * @param[out] port_list_return Created port list.
1168 *
1169 * @return 0 success, 1 port list exists already, 4 error in port_ranges,
1170 * 99 permission denied, -1 error.
1171 */
1172 static int
create_port_list_internal(int check_access,const char * id,const char * name,const char * comment,const char * port_ranges,array_t * ranges,int predefined,port_list_t * port_list_return)1173 create_port_list_internal (int check_access, const char *id, const char *name,
1174 const char *comment, const char *port_ranges,
1175 array_t *ranges, int predefined,
1176 port_list_t *port_list_return)
1177 {
1178 port_list_t port_list;
1179 int ret;
1180
1181 assert (current_credentials.uuid);
1182
1183 if (ranges)
1184 {
1185 int suffix;
1186 gchar *quoted_name, *quoted_id;
1187
1188 if (id == NULL)
1189 return -1;
1190
1191 sql_begin_immediate ();
1192
1193 if (check_access && acl_user_may ("create_port_list") == 0)
1194 {
1195 sql_rollback ();
1196 return 99;
1197 }
1198
1199 /* Check whether this port list exists already. */
1200
1201 quoted_id = sql_quote (id);
1202 if (sql_int ("SELECT COUNT(*) FROM port_lists"
1203 " WHERE uuid = '%s';",
1204 quoted_id))
1205 {
1206 g_free (quoted_id);
1207 sql_rollback ();
1208 return 1;
1209 }
1210
1211 if (sql_int ("SELECT COUNT(*) FROM port_lists_trash"
1212 " WHERE uuid = '%s';",
1213 quoted_id))
1214 {
1215 g_free (quoted_id);
1216 sql_rollback ();
1217 return 2;
1218 }
1219
1220 /* Ensure the name is unique. */
1221 quoted_name = sql_quote (name);
1222 suffix = 1;
1223 while (resource_with_name_exists (quoted_name, "port_list", 0))
1224 {
1225 gchar *new_name;
1226 g_free (quoted_name);
1227 new_name = g_strdup_printf ("%s %i", name, suffix++);
1228 quoted_name = sql_quote (new_name);
1229 g_free (new_name);
1230 }
1231
1232 ret = create_port_list_lock (quoted_id, quoted_name,
1233 comment ? comment : "", ranges, predefined,
1234 &port_list);
1235 g_free (quoted_name);
1236 if (ret)
1237 {
1238 sql_rollback ();
1239 return ret;
1240 }
1241
1242 if (port_list_return)
1243 *port_list_return = port_list;
1244
1245 sql_commit ();
1246 return 0;
1247 }
1248
1249 if (port_ranges == NULL)
1250 port_ranges = "default";
1251
1252 if (validate_port_range (port_ranges))
1253 return 4;
1254
1255 sql_begin_immediate ();
1256
1257 if (check_access && acl_user_may ("create_port_list") == 0)
1258 {
1259 sql_rollback ();
1260 return 99;
1261 }
1262
1263
1264 /* Check whether a port_list with the same name exists already. */
1265 if (resource_with_name_exists (name, "port_list", 0))
1266 {
1267 sql_rollback ();
1268 return 1;
1269 }
1270
1271 if (port_ranges == NULL || (strcmp (port_ranges, "default") == 0))
1272 {
1273 gchar *quoted_comment, *quoted_name;
1274
1275 quoted_name = sql_quote (name);
1276 quoted_comment = sql_quote (comment ? comment : "");
1277 sql ("INSERT INTO port_lists"
1278 " (uuid, owner, name, comment, predefined, creation_time,"
1279 " modification_time)"
1280 " VALUES"
1281 " (make_uuid (), (SELECT id FROM users WHERE uuid = '%s'), '%s',"
1282 " '%s', %i, m_now (), m_now ());",
1283 current_credentials.uuid,
1284 quoted_name,
1285 quoted_comment,
1286 predefined);
1287 g_free (quoted_comment);
1288 g_free (quoted_name);
1289
1290 port_list = sql_last_insert_id ();
1291 make_port_ranges_openvas_default (port_list);
1292 }
1293 else
1294 {
1295 gchar *quoted_name;
1296
1297 quoted_name = sql_quote (name);
1298
1299 ranges = port_range_ranges (port_ranges);
1300 ret = create_port_list_lock (NULL, quoted_name, comment ? comment : "",
1301 ranges, predefined, &port_list);
1302
1303 g_free (quoted_name);
1304 array_free (ranges);
1305 if (ret)
1306 {
1307 sql_rollback ();
1308 return ret;
1309 }
1310 }
1311
1312 if (port_list_return)
1313 *port_list_return = port_list;
1314
1315 sql_commit ();
1316
1317 return 0;
1318 }
1319
1320 /**
1321 * @brief Create a port list.
1322 *
1323 * @param[in] id ID of port list. Only used with \p ranges.
1324 * @param[in] name Name of port list.
1325 * @param[in] comment Comment on port list.
1326 * @param[in] port_ranges GMP port range string.
1327 * @param[in] ranges Array of port ranges of type range_t.
1328 * Overrides port_ranges.
1329 * @param[out] port_list_return Created port list.
1330 *
1331 * @return 0 success, 1 port list exists already, 4 error in port_ranges,
1332 * 99 permission denied, -1 error.
1333 */
1334 int
create_port_list(const char * id,const char * name,const char * comment,const char * port_ranges,array_t * ranges,port_list_t * port_list_return)1335 create_port_list (const char *id, const char *name, const char *comment,
1336 const char *port_ranges, array_t *ranges,
1337 port_list_t *port_list_return)
1338 {
1339 return create_port_list_internal (1, id, name, comment, port_ranges, ranges,
1340 0, /* Predefined. */
1341 port_list_return);
1342 }
1343
1344 /**
1345 * @brief Create a port list.
1346 *
1347 * @param[in] id ID of port list. Only used with \p ranges.
1348 * @param[in] name Name of port list.
1349 * @param[in] comment Comment on port list.
1350 * @param[in] port_ranges GMP port range string.
1351 * @param[in] ranges Array of port ranges of type range_t.
1352 * Overrides port_ranges.
1353 * @param[out] port_list_return Created port list.
1354 *
1355 * @return 0 success, 1 port list exists already, 4 error in port_ranges,
1356 * 99 permission denied, -1 error.
1357 */
1358 int
create_port_list_no_acl(const char * id,const char * name,const char * comment,const char * port_ranges,array_t * ranges,port_list_t * port_list_return)1359 create_port_list_no_acl (const char *id, const char *name, const char *comment,
1360 const char *port_ranges, array_t *ranges,
1361 port_list_t *port_list_return)
1362 {
1363 return create_port_list_internal (0, id, name, comment, port_ranges, ranges,
1364 1, /* Predefined. */
1365 port_list_return);
1366 }
1367
1368 /**
1369 * @brief Create Port List from an existing Port List.
1370 *
1371 * @param[in] name Name of new Port List. NULL to copy from
1372 * existing.
1373 * @param[in] comment Comment on new Port List. NULL to copy from
1374 * existing.
1375 * @param[in] port_list_id UUID of existing Port List.
1376 * @param[out] new_port_list New Port List.
1377 *
1378 * @return 0 success, 1 Port List exists already, 2 failed to find existing
1379 * Port List, 99 permission denied, -1 error.
1380 */
1381 int
copy_port_list(const char * name,const char * comment,const char * port_list_id,port_list_t * new_port_list)1382 copy_port_list (const char* name, const char* comment,
1383 const char* port_list_id, port_list_t* new_port_list)
1384 {
1385 int ret;
1386 port_list_t new, old;
1387
1388 sql_begin_immediate ();
1389
1390 ret = copy_resource_lock ("port_list", name, comment, port_list_id, NULL, 1,
1391 &new, &old);
1392 if (ret)
1393 {
1394 sql_rollback ();
1395 return ret;
1396 }
1397
1398 sql ("UPDATE port_lists SET predefined = 0 WHERE id = %llu;", new);
1399
1400 /* Copy port ranges. */
1401
1402 sql ("INSERT INTO port_ranges "
1403 " (uuid, port_list, type, start, \"end\", comment, exclude)"
1404 " SELECT make_uuid(), %llu, type, start, \"end\", comment, exclude"
1405 " FROM port_ranges WHERE port_list = %llu;",
1406 new,
1407 old);
1408
1409 sql_commit ();
1410 if (new_port_list) *new_port_list = new;
1411 return 0;
1412 }
1413
1414 /**
1415 * @brief Return whether a port list is predefined.
1416 *
1417 * @param[in] port_list_id UUID of port list.
1418 *
1419 * @return 1 if predefined, else 0.
1420 */
1421 static int
port_list_predefined_uuid(const gchar * port_list_id)1422 port_list_predefined_uuid (const gchar *port_list_id)
1423 {
1424 port_list_t port_list;
1425
1426 if (find_port_list_no_acl (port_list_id, &port_list)
1427 || port_list == 0)
1428 return 0;
1429
1430 return port_list_predefined (port_list);
1431 }
1432
1433 /**
1434 * @brief Modify a Port List.
1435 *
1436 * @param[in] port_list_id UUID of Port List.
1437 * @param[in] name Name of Port List.
1438 * @param[in] comment Comment on Port List.
1439 *
1440 * @return 0 success, 1 failed to find port list, 2 port list with new name,
1441 * exists, 3 port_list_id required, 99 permission denied, -1 internal
1442 * error.
1443 */
1444 int
modify_port_list(const char * port_list_id,const char * name,const char * comment)1445 modify_port_list (const char *port_list_id, const char *name,
1446 const char *comment)
1447 {
1448 gchar *quoted_name, *quoted_comment;
1449 port_list_t port_list;
1450
1451 if (port_list_id == NULL)
1452 return 3;
1453
1454 sql_begin_immediate ();
1455
1456 assert (current_credentials.uuid);
1457
1458 if (acl_user_may ("modify_port_list") == 0)
1459 {
1460 sql_rollback ();
1461 return 99;
1462 }
1463
1464 if (port_list_predefined_uuid (port_list_id))
1465 {
1466 sql_rollback ();
1467 return 99;
1468 }
1469
1470 port_list = 0;
1471 if (find_port_list_with_permission (port_list_id, &port_list,
1472 "modify_port_list"))
1473 {
1474 sql_rollback ();
1475 return -1;
1476 }
1477
1478 if (port_list == 0)
1479 {
1480 sql_rollback ();
1481 return 1;
1482 }
1483
1484 /* Check whether a Port List with the same name exists already. */
1485 if (name)
1486 {
1487 if (resource_with_name_exists (name, "port_list", port_list))
1488 {
1489 sql_rollback ();
1490 return 2;
1491 }
1492 }
1493
1494 quoted_name = sql_quote (name ?: "");
1495 quoted_comment = sql_quote (comment ?: "");
1496
1497 sql ("UPDATE port_lists SET"
1498 " name = '%s',"
1499 " comment = '%s',"
1500 " modification_time = m_now ()"
1501 " WHERE id = %llu;",
1502 quoted_name,
1503 quoted_comment,
1504 port_list);
1505
1506 g_free (quoted_comment);
1507 g_free (quoted_name);
1508
1509 sql_commit ();
1510
1511 return 0;
1512 }
1513
1514 /**
1515 * @brief Create a port range in a port list.
1516 *
1517 * @param[in] port_list_id Port list UUID.
1518 * @param[in] type Type.
1519 * @param[in] start Start port.
1520 * @param[in] end End port.
1521 * @param[in] comment Comment.
1522 * @param[out] port_range_return Created port range.
1523 *
1524 * @return 0 success, 1 syntax error in start, 2 syntax error in end, 3 failed
1525 * to find port list, 4 syntax error in type, 5 port list in use,
1526 * 6 new range overlaps an existing range, 99 permission denied,
1527 * -1 error.
1528 */
1529 int
create_port_range(const char * port_list_id,const char * type,const char * start,const char * end,const char * comment,port_range_t * port_range_return)1530 create_port_range (const char *port_list_id, const char *type,
1531 const char *start, const char *end, const char *comment,
1532 port_range_t *port_range_return)
1533 {
1534 int first, last;
1535 port_list_t port_list;
1536 port_protocol_t port_type;
1537 gchar *quoted_comment;
1538
1539 first = atoi (start);
1540 if (first < 1 || first > 65535)
1541 return 1;
1542
1543 last = atoi (end);
1544 if (last < 1 || last > 65535)
1545 return 2;
1546
1547 if (strcasecmp (type, "TCP") == 0)
1548 port_type = PORT_PROTOCOL_TCP;
1549 else if (strcasecmp (type, "UDP") == 0)
1550 port_type = PORT_PROTOCOL_UDP;
1551 else
1552 return 4;
1553
1554 if (last < first)
1555 {
1556 int tem;
1557 tem = first;
1558 first = last;
1559 last = tem;
1560 }
1561
1562 sql_begin_immediate ();
1563
1564 if (acl_user_may ("create_port_range") == 0)
1565 {
1566 sql_rollback ();
1567 return 99;
1568 }
1569
1570 port_list = 0;
1571
1572 if (find_port_list (port_list_id, &port_list))
1573 {
1574 sql_rollback ();
1575 return -1;
1576 }
1577
1578 if (port_list == 0)
1579 {
1580 sql_rollback ();
1581 return 3;
1582 }
1583
1584 if (port_list_in_use (port_list))
1585 {
1586 sql_rollback ();
1587 return 5;
1588 }
1589
1590 if (sql_int ("SELECT count (*) FROM port_ranges"
1591 " WHERE port_list = %llu"
1592 " AND type = %i"
1593 " AND ((start <= %i AND \"end\" >= %i)"
1594 " OR (start <= %i AND \"end\" >= %i)"
1595 " OR (start >= %i AND start <= %i)"
1596 " OR (\"end\" >= %i AND \"end\" <= %i))",
1597 port_list,
1598 port_type,
1599 first,
1600 first,
1601 last,
1602 last,
1603 first,
1604 last,
1605 first,
1606 last))
1607 {
1608 sql_rollback ();
1609 return 6;
1610 }
1611
1612 quoted_comment = comment ? sql_quote (comment) : g_strdup ("");
1613 sql ("INSERT INTO port_ranges"
1614 " (uuid, port_list, type, start, \"end\", comment, exclude)"
1615 " VALUES"
1616 " (make_uuid (), %llu, %i, %i, %i, '', 0);",
1617 port_list, port_type, first, last, quoted_comment);
1618 g_free (quoted_comment);
1619
1620 if (port_range_return)
1621 *port_range_return = sql_last_insert_id ();
1622
1623 sql_commit ();
1624
1625 return 0;
1626 }
1627
1628 /**
1629 * @brief Delete a port list.
1630 *
1631 * @param[in] port_list_id UUID of port_list.
1632 * @param[in] ultimate Whether to remove entirely, or to trashcan.
1633 *
1634 * @return 0 success, 1 fail because a target refers to the port list, 2 failed
1635 * to find port list, 99 permission denied, -1 error.
1636 */
1637 int
delete_port_list(const char * port_list_id,int ultimate)1638 delete_port_list (const char *port_list_id, int ultimate)
1639 {
1640 port_list_t port_list = 0;
1641
1642 sql_begin_immediate ();
1643
1644 if (acl_user_may ("delete_port_list") == 0)
1645 {
1646 sql_rollback ();
1647 return 99;
1648 }
1649
1650 if (find_port_list_with_permission (port_list_id, &port_list,
1651 "delete_port_list"))
1652 {
1653 sql_rollback ();
1654 return -1;
1655 }
1656
1657 if (port_list == 0)
1658 {
1659 if (find_trash ("port_list", port_list_id, &port_list))
1660 {
1661 sql_rollback ();
1662 return -1;
1663 }
1664 if (port_list == 0)
1665 {
1666 sql_rollback ();
1667 return 2;
1668 }
1669 if (ultimate == 0)
1670 {
1671 /* It's already in the trashcan. */
1672 sql_commit ();
1673 return 0;
1674 }
1675
1676 /* Check if it's in use by a target in the trashcan. */
1677 if (sql_int ("SELECT count(*) FROM targets_trash"
1678 " WHERE port_list = %llu"
1679 " AND port_list_location"
1680 " = " G_STRINGIFY (LOCATION_TRASH) ";",
1681 port_list))
1682 {
1683 sql_rollback ();
1684 return 1;
1685 }
1686
1687 permissions_set_orphans ("port_list", port_list, LOCATION_TRASH);
1688 tags_remove_resource ("port_list", port_list, LOCATION_TRASH);
1689
1690 sql ("DELETE FROM port_ranges_trash WHERE port_list = %llu;", port_list);
1691 sql ("DELETE FROM port_lists_trash WHERE id = %llu;", port_list);
1692 sql_commit ();
1693 return 0;
1694 }
1695
1696 if (sql_int ("SELECT count(*) FROM targets"
1697 " WHERE port_list = %llu;",
1698 port_list))
1699 {
1700 sql_rollback ();
1701 return 1;
1702 }
1703
1704 if (ultimate == 0)
1705 {
1706 port_list_t trash_port_list;
1707
1708 sql ("INSERT INTO port_lists_trash"
1709 " (uuid, owner, name, comment, predefined, creation_time,"
1710 " modification_time)"
1711 " SELECT uuid, owner, name, comment, predefined, creation_time,"
1712 " modification_time"
1713 " FROM port_lists WHERE id = %llu;",
1714 port_list);
1715
1716 trash_port_list = sql_last_insert_id ();
1717
1718 sql ("INSERT INTO port_ranges_trash"
1719 " (uuid, port_list, type, start, \"end\", comment, exclude)"
1720 " SELECT uuid, %llu, type, start, \"end\", comment, exclude"
1721 " FROM port_ranges WHERE port_list = %llu;",
1722 trash_port_list,
1723 port_list);
1724
1725 /* Update the location of the port_list in any trashcan targets. */
1726 sql ("UPDATE targets_trash"
1727 " SET port_list = %llu,"
1728 " port_list_location = " G_STRINGIFY (LOCATION_TRASH)
1729 " WHERE port_list = %llu"
1730 " AND port_list_location = " G_STRINGIFY (LOCATION_TABLE) ";",
1731 trash_port_list,
1732 port_list);
1733
1734 permissions_set_locations ("port_list", port_list, trash_port_list,
1735 LOCATION_TRASH);
1736 tags_set_locations ("port_list", port_list, trash_port_list,
1737 LOCATION_TRASH);
1738 }
1739 else
1740 {
1741 permissions_set_orphans ("port_list", port_list, LOCATION_TABLE);
1742 tags_remove_resource ("port_list", port_list, LOCATION_TABLE);
1743 }
1744
1745 sql ("DELETE FROM port_ranges WHERE port_list = %llu;", port_list);
1746 sql ("DELETE FROM port_lists WHERE id = %llu;", port_list);
1747
1748 sql_commit ();
1749 return 0;
1750 }
1751
1752 /**
1753 * @brief Create a port range.
1754 *
1755 * @param[in] port_list Port list to insert into.
1756 * @param[in] type Protocol: PORT_PROTOCOL_UDP or PORT_PROTOCOL_TCP.
1757 * @param[in] start Start of range.
1758 * @param[in] end End of range.
1759 */
1760 void
insert_port_range(port_list_t port_list,port_protocol_t type,int start,int end)1761 insert_port_range (port_list_t port_list, port_protocol_t type, int start,
1762 int end)
1763 {
1764 sql ("INSERT INTO port_ranges"
1765 " (uuid, port_list, type, start, \"end\", comment, exclude)"
1766 " VALUES"
1767 " (make_uuid (), %llu, %i, '%i', '%i', '', 0);",
1768 port_list,
1769 type,
1770 start,
1771 end);
1772 }
1773
1774 /**
1775 * @brief Delete a port range.
1776 *
1777 * @param[in] port_range_id UUID of port_range.
1778 * @param[in] dummy Dummy arg to match other delete functions.
1779 *
1780 * @return 0 success, 2 failed to find port range, 99 permission denied,
1781 * -1 error.
1782 */
1783 int
delete_port_range(const char * port_range_id,int dummy)1784 delete_port_range (const char *port_range_id, int dummy)
1785 {
1786 port_range_t port_range = 0;
1787
1788 sql_begin_immediate ();
1789
1790 if (acl_user_may ("delete_port_range") == 0)
1791 {
1792 sql_rollback ();
1793 return 99;
1794 }
1795
1796 if (find_port_range_with_permission (port_range_id, &port_range,
1797 "delete_port_range"))
1798 {
1799 sql_rollback ();
1800 return -1;
1801 }
1802
1803 if (port_range == 0)
1804 {
1805 sql_rollback ();
1806 return 2;
1807 }
1808
1809 sql ("DELETE FROM port_ranges WHERE id = %llu;", port_range);
1810
1811 sql_commit ();
1812 return 0;
1813 }
1814
1815 /**
1816 * @brief Filter columns for Port List iterator.
1817 */
1818 #define PORT_LIST_ITERATOR_FILTER_COLUMNS \
1819 { GET_ITERATOR_FILTER_COLUMNS, "total", "tcp", "udp", "predefined", NULL }
1820
1821 /**
1822 * @brief Port List iterator columns.
1823 */
1824 #define PORT_LIST_ITERATOR_COLUMNS \
1825 { \
1826 GET_ITERATOR_COLUMNS (port_lists), \
1827 { \
1828 /* COUNT ALL ports */ \
1829 "(SELECT" \
1830 " sum ((CASE" \
1831 " WHEN \"end\" IS NULL THEN start ELSE \"end\"" \
1832 " END)" \
1833 " - start" \
1834 " + 1)" \
1835 " FROM port_ranges WHERE port_list = port_lists.id)", \
1836 "total", \
1837 KEYWORD_TYPE_INTEGER \
1838 }, \
1839 { \
1840 /* COUNT TCP ports */ \
1841 "(SELECT" \
1842 " sum ((CASE" \
1843 " WHEN \"end\" IS NULL THEN start ELSE \"end\"" \
1844 " END)" \
1845 " - start" \
1846 " + 1)" \
1847 " FROM port_ranges WHERE port_list = port_lists.id" \
1848 " AND type = 0)", \
1849 "tcp", \
1850 KEYWORD_TYPE_INTEGER \
1851 }, \
1852 { \
1853 /* COUNT UDP ports */ \
1854 "(SELECT" \
1855 " sum ((CASE" \
1856 " WHEN \"end\" IS NULL THEN start ELSE \"end\"" \
1857 " END)" \
1858 " - start" \
1859 " + 1)" \
1860 " FROM port_ranges WHERE port_list = port_lists.id" \
1861 " AND type = 1)", \
1862 "udp", \
1863 KEYWORD_TYPE_INTEGER \
1864 }, \
1865 { "predefined", NULL, KEYWORD_TYPE_INTEGER }, \
1866 { NULL, NULL, KEYWORD_TYPE_UNKNOWN } \
1867 }
1868
1869 /**
1870 * @brief Port List iterator columns for trash case.
1871 */
1872 #define PORT_LIST_ITERATOR_TRASH_COLUMNS \
1873 { \
1874 GET_ITERATOR_COLUMNS (port_lists_trash), \
1875 { \
1876 /* COUNT ALL ports */ \
1877 "(SELECT" \
1878 " sum ((CASE" \
1879 " WHEN \"end\" IS NULL THEN start ELSE \"end\"" \
1880 " END)" \
1881 " - start" \
1882 " + 1)" \
1883 " FROM port_ranges_trash" \
1884 " WHERE port_list = port_lists_trash.id)", \
1885 "total", \
1886 KEYWORD_TYPE_INTEGER \
1887 }, \
1888 { \
1889 /* COUNT TCP ports */ \
1890 "(SELECT" \
1891 " sum ((CASE" \
1892 " WHEN \"end\" IS NULL THEN start ELSE \"end\"" \
1893 " END)" \
1894 " - start" \
1895 " + 1)" \
1896 " FROM port_ranges_trash" \
1897 " WHERE port_list = port_lists_trash.id AND type = 0)", \
1898 "tcp", \
1899 KEYWORD_TYPE_INTEGER \
1900 }, \
1901 { \
1902 /* COUNT UDP ports */ \
1903 "(SELECT" \
1904 " sum ((CASE" \
1905 " WHEN \"end\" IS NULL THEN start ELSE \"end\"" \
1906 " END)" \
1907 " - start" \
1908 " + 1)" \
1909 " FROM port_ranges_trash" \
1910 " WHERE port_list = port_lists_trash.id AND type = 1)", \
1911 "udp", \
1912 KEYWORD_TYPE_INTEGER \
1913 }, \
1914 { "predefined", NULL, KEYWORD_TYPE_INTEGER }, \
1915 { NULL, NULL, KEYWORD_TYPE_UNKNOWN } \
1916 }
1917
1918 /**
1919 * @brief Get filter columns.
1920 *
1921 * @return Constant array of filter columns.
1922 */
1923 const char**
port_list_filter_columns()1924 port_list_filter_columns ()
1925 {
1926 static const char *columns[] = PORT_LIST_ITERATOR_FILTER_COLUMNS;
1927 return columns;
1928 }
1929
1930 /**
1931 * @brief Get select columns.
1932 *
1933 * @return Constant array of select columns.
1934 */
1935 column_t*
port_list_select_columns()1936 port_list_select_columns ()
1937 {
1938 static column_t columns[] = PORT_LIST_ITERATOR_COLUMNS;
1939 return columns;
1940 }
1941
1942 /**
1943 * @brief Count the number of Port Lists.
1944 *
1945 * @param[in] get GET params.
1946 *
1947 * @return Total number of Port Lists filtered set.
1948 */
1949 int
port_list_count(const get_data_t * get)1950 port_list_count (const get_data_t *get)
1951 {
1952 static const char *filter_columns[] = PORT_LIST_ITERATOR_FILTER_COLUMNS;
1953 static column_t columns[] = PORT_LIST_ITERATOR_COLUMNS;
1954 static column_t trash_columns[] = PORT_LIST_ITERATOR_TRASH_COLUMNS;
1955
1956 return count ("port_list", get, columns, trash_columns, filter_columns,
1957 0, 0, 0, TRUE);
1958 }
1959
1960 /**
1961 * @brief Initialise a Port List iterator, including observed Port Lists.
1962 *
1963 * @param[in] iterator Iterator.
1964 * @param[in] get GET data.
1965 *
1966 * @return 0 success, 1 failed to find Port List, 2 failed to find filter,
1967 * -1 error.
1968 */
1969 int
init_port_list_iterator(iterator_t * iterator,const get_data_t * get)1970 init_port_list_iterator (iterator_t* iterator, const get_data_t *get)
1971 {
1972 static const char *filter_columns[] = PORT_LIST_ITERATOR_FILTER_COLUMNS;
1973 static column_t columns[] = PORT_LIST_ITERATOR_COLUMNS;
1974 static column_t trash_columns[] = PORT_LIST_ITERATOR_TRASH_COLUMNS;
1975
1976 return init_get_iterator (iterator,
1977 "port_list",
1978 get,
1979 columns,
1980 trash_columns,
1981 filter_columns,
1982 0,
1983 NULL,
1984 NULL,
1985 TRUE);
1986 }
1987
1988 /**
1989 * @brief Get the port count from a port_list iterator.
1990 *
1991 * @param[in] iterator Iterator.
1992 *
1993 * @return Port count.
1994 */
1995 int
port_list_iterator_count_all(iterator_t * iterator)1996 port_list_iterator_count_all (iterator_t* iterator)
1997 {
1998 if (iterator->done) return -1;
1999 return iterator_int (iterator, GET_ITERATOR_COLUMN_COUNT);
2000 }
2001
2002 /**
2003 * @brief Get the TCP port count from a port_list iterator.
2004 *
2005 * @param[in] iterator Iterator.
2006 *
2007 * @return TCP port count.
2008 */
2009 int
port_list_iterator_count_tcp(iterator_t * iterator)2010 port_list_iterator_count_tcp (iterator_t* iterator)
2011 {
2012 if (iterator->done) return -1;
2013 return iterator_int (iterator, GET_ITERATOR_COLUMN_COUNT + 1);
2014 }
2015
2016 /**
2017 * @brief Get the UDP port count from a port_list iterator.
2018 *
2019 * @param[in] iterator Iterator.
2020 *
2021 * @return UDP port count.
2022 */
2023 int
port_list_iterator_count_udp(iterator_t * iterator)2024 port_list_iterator_count_udp (iterator_t* iterator)
2025 {
2026 if (iterator->done) return -1;
2027 return iterator_int (iterator, GET_ITERATOR_COLUMN_COUNT + 2);
2028 }
2029
2030 /**
2031 * @brief Get predefined status from a port_list iterator.
2032 *
2033 * @param[in] iterator Iterator.
2034 *
2035 * @return 1 if predefined, else 0.
2036 */
2037 int
port_list_iterator_predefined(iterator_t * iterator)2038 port_list_iterator_predefined (iterator_t* iterator)
2039 {
2040 if (iterator->done) return 0;
2041 return iterator_int (iterator, GET_ITERATOR_COLUMN_COUNT + 3);
2042 }
2043
2044 /**
2045 * @brief Return the UUID of a port_list.
2046 *
2047 * @param[in] port_list Port_List.
2048 *
2049 * @return Newly allocated UUID if available, else NULL.
2050 */
2051 char*
port_list_uuid(port_list_t port_list)2052 port_list_uuid (port_list_t port_list)
2053 {
2054 return sql_string ("SELECT uuid FROM port_lists WHERE id = %llu;",
2055 port_list);
2056 }
2057
2058 /**
2059 * @brief Return the UUID of a port_range.
2060 *
2061 * @param[in] port_range Port Range.
2062 *
2063 * @return Newly allocated UUID if available, else NULL.
2064 */
2065 char*
port_range_uuid(port_range_t port_range)2066 port_range_uuid (port_range_t port_range)
2067 {
2068 return sql_string ("SELECT uuid FROM port_ranges WHERE id = %llu;",
2069 port_range);
2070 }
2071
2072 /**
2073 * @brief Return whether a port_list is in use by a task.
2074 *
2075 * @param[in] port_list Port_List.
2076 *
2077 * @return 1 if in use, else 0.
2078 */
2079 int
port_list_in_use(port_list_t port_list)2080 port_list_in_use (port_list_t port_list)
2081 {
2082 return !!sql_int ("SELECT count(*) FROM targets"
2083 " WHERE port_list = %llu",
2084 port_list);
2085 }
2086
2087 /**
2088 * @brief Check whether a trashcan Port List is in use.
2089 *
2090 * @param[in] port_list Port List.
2091 *
2092 * @return 1 yes, 0 no.
2093 */
2094 int
trash_port_list_in_use(port_list_t port_list)2095 trash_port_list_in_use (port_list_t port_list)
2096 {
2097 return !!sql_int ("SELECT count (*) FROM targets_trash"
2098 " WHERE port_list = %llu"
2099 " AND port_list_location = "
2100 G_STRINGIFY (LOCATION_TRASH) ";",
2101 port_list);
2102 }
2103
2104 /**
2105 * @brief Check whether a Port List is writable.
2106 *
2107 * @param[in] port_list Port List.
2108 *
2109 * @return 1 yes, 0 no.
2110 */
2111 int
port_list_writable(port_list_t port_list)2112 port_list_writable (port_list_t port_list)
2113 {
2114 return port_list_in_use (port_list) == 0;
2115 }
2116
2117 /**
2118 * @brief Check whether a trashcan Port List is writable.
2119 *
2120 * @param[in] port_list Port List.
2121 *
2122 * @return 1 yes, 0 no.
2123 */
2124 int
trash_port_list_writable(port_list_t port_list)2125 trash_port_list_writable (port_list_t port_list)
2126 {
2127 return trash_port_list_in_use (port_list) == 0;
2128 }
2129
2130 /**
2131 * @brief Return whether a trashcan port list is readable.
2132 *
2133 * @param[in] port_list_id Port list UUID.
2134 *
2135 * @return 1 if readable, else 0.
2136 */
2137 int
trash_port_list_readable_uuid(const gchar * port_list_id)2138 trash_port_list_readable_uuid (const gchar *port_list_id)
2139 {
2140 port_list_t found;
2141
2142 if (port_list_id == NULL)
2143 return 0;
2144 if (find_trash ("port_list", port_list_id, &found))
2145 return 0;
2146 return found > 0;
2147 }
2148
2149 /**
2150 * @brief Initialise a port_range iterator.
2151 *
2152 * @param[in] iterator Iterator.
2153 * @param[in] port_list Port list.
2154 * @param[in] trash Whether port_list is in the trashcan.
2155 * @param[in] ascending Whether to sort ascending or descending.
2156 * @param[in] sort_field Field to sort on, or NULL for type then start.
2157 */
2158 void
init_port_range_iterator(iterator_t * iterator,port_list_t port_list,int trash,int ascending,const char * sort_field)2159 init_port_range_iterator (iterator_t* iterator, port_list_t port_list,
2160 int trash, int ascending, const char* sort_field)
2161 {
2162 assert (current_credentials.uuid);
2163
2164 if (port_list)
2165 {
2166 char *uuid;
2167
2168 uuid = port_list_uuid (port_list);
2169 assert (uuid);
2170 if (acl_user_has_access_uuid ("port_list", uuid, "get_port_lists", trash))
2171 init_iterator (iterator,
2172 "SELECT uuid, comment, start, \"end\", type, exclude"
2173 " FROM port_ranges%s"
2174 " WHERE port_list = %llu"
2175 " ORDER BY %s %s;",
2176 trash ? "_trash" : "",
2177 port_list,
2178 sort_field ? sort_field : "type, CAST (start AS INTEGER)",
2179 ascending ? "ASC" : "DESC");
2180 else
2181 init_iterator (iterator,
2182 "SELECT uuid, comment, start, \"end\", type, exclude"
2183 " FROM port_ranges"
2184 " WHERE 1 = 0");
2185 free (uuid);
2186 }
2187 else
2188 init_iterator (iterator,
2189 "SELECT uuid, comment, start, end, type, exclude"
2190 " FROM port_ranges%s"
2191 " WHERE"
2192 " (((SELECT owner FROM port_lists%s WHERE id = port_list)"
2193 " IS NULL)"
2194 " OR ((SELECT owner FROM port_lists%s WHERE id = port_list)"
2195 " = (SELECT id FROM users WHERE users.uuid = '%s'))"
2196 " OR (CAST (%i AS boolean)"
2197 " AND (" ACL_USER_MAY ("port_list") ")))"
2198 " ORDER BY %s %s;",
2199 trash ? "_trash" : "",
2200 trash ? "_trash" : "",
2201 trash ? "_trash" : "",
2202 current_credentials.uuid,
2203 trash ? 0 : 1,
2204 current_credentials.uuid,
2205 current_credentials.uuid,
2206 current_credentials.uuid,
2207 "get_port_lists",
2208 "get_port_lists",
2209 "get_port_lists",
2210 "get_port_lists",
2211 sort_field ? sort_field : "type, CAST (start AS INTEGER)",
2212 ascending ? "ASC" : "DESC");
2213 }
2214
2215 /**
2216 * @brief Get the UUID from a port range iterator.
2217 *
2218 * @param[in] iterator Iterator.
2219 *
2220 * @return The UUID of the range, or NULL if iteration is complete. Freed by
2221 * cleanup_iterator.
2222 */
2223 DEF_ACCESS (port_range_iterator_uuid, 0);
2224
2225 /**
2226 * @brief Get the comment from a port range iterator.
2227 *
2228 * @param[in] iterator Iterator.
2229 *
2230 * @return The comment of the range, or NULL if iteration is complete. Freed by
2231 * cleanup_iterator.
2232 */
2233 const char*
port_range_iterator_comment(iterator_t * iterator)2234 port_range_iterator_comment (iterator_t* iterator)
2235 {
2236 const char *ret;
2237 if (iterator->done) return "";
2238 ret = iterator_string (iterator, 1);
2239 return ret ? ret : "";
2240 }
2241
2242 /**
2243 * @brief Get the comment from a port range iterator.
2244 *
2245 * @param[in] iterator Iterator.
2246 *
2247 * @return The comment of the range, or NULL if iteration is complete. Freed by
2248 * cleanup_iterator.
2249 */
2250 DEF_ACCESS (port_range_iterator_start, 2);
2251
2252 /**
2253 * @brief Get the comment from a port range iterator.
2254 *
2255 * @param[in] iterator Iterator.
2256 *
2257 * @return The comment of the range, or NULL if iteration is complete. Freed by
2258 * cleanup_iterator.
2259 */
2260 DEF_ACCESS (port_range_iterator_end, 3);
2261
2262 /**
2263 * @brief Get the type from a port range iterator.
2264 *
2265 * @param[in] iterator Iterator.
2266 *
2267 * @return The type of the range, or NULL if iteration is complete. Freed by
2268 * cleanup_iterator.
2269 */
2270 const char*
port_range_iterator_type(iterator_t * iterator)2271 port_range_iterator_type (iterator_t* iterator)
2272 {
2273 if (iterator->done) return "";
2274 switch ((port_protocol_t) iterator_int (iterator, 4))
2275 {
2276 case PORT_PROTOCOL_TCP:
2277 return "tcp";
2278 case PORT_PROTOCOL_UDP:
2279 return "udp";
2280 default:
2281 return "";
2282 }
2283 }
2284
2285 /**
2286 * @brief Get the type from a port range iterator.
2287 *
2288 * @param[in] iterator Iterator.
2289 *
2290 * @return The type of the range, or NULL if iteration is complete. Freed by
2291 * cleanup_iterator.
2292 */
2293 port_protocol_t
port_range_iterator_type_int(iterator_t * iterator)2294 port_range_iterator_type_int (iterator_t* iterator)
2295 {
2296 if (iterator->done) return PORT_PROTOCOL_OTHER;
2297 return (port_protocol_t) iterator_int (iterator, 4);
2298 }
2299
2300 /**
2301 * @brief Initialise a port list target iterator.
2302 *
2303 * @param[in] iterator Iterator.
2304 * @param[in] port_list Port list.
2305 * @param[in] ascending Whether to sort ascending or descending.
2306 */
2307 void
init_port_list_target_iterator(iterator_t * iterator,port_list_t port_list,int ascending)2308 init_port_list_target_iterator (iterator_t* iterator, port_list_t port_list,
2309 int ascending)
2310 {
2311 gchar *available, *with_clause;
2312 get_data_t get;
2313 array_t *permissions;
2314
2315 assert (port_list);
2316
2317 get.trash = 0;
2318 permissions = make_array ();
2319 array_add (permissions, g_strdup ("get_targets"));
2320 available = acl_where_owned ("target", &get, 1, "any", 0, permissions, 0,
2321 &with_clause);
2322 array_free (permissions);
2323
2324 init_iterator (iterator,
2325 "%s"
2326 " SELECT uuid, name, %s FROM targets"
2327 " WHERE port_list = %llu"
2328 " ORDER BY name %s;",
2329 with_clause ? with_clause : "",
2330 available,
2331 port_list,
2332 ascending ? "ASC" : "DESC");
2333
2334 g_free (with_clause);
2335 g_free (available);
2336 }
2337
2338 /**
2339 * @brief Get the UUID from a port list target iterator.
2340 *
2341 * @param[in] iterator Iterator.
2342 *
2343 * @return The UUID of the target, or NULL if iteration is complete. Freed by
2344 * cleanup_iterator.
2345 */
2346 DEF_ACCESS (port_list_target_iterator_uuid, 0);
2347
2348 /**
2349 * @brief Get the name from a port list target iterator.
2350 *
2351 * @param[in] iterator Iterator.
2352 *
2353 * @return The name of the target, or NULL if iteration is complete. Freed by
2354 * cleanup_iterator.
2355 */
2356 DEF_ACCESS (port_list_target_iterator_name, 1);
2357
2358 /**
2359 * @brief Get the read permission status from a GET iterator.
2360 *
2361 * @param[in] iterator Iterator.
2362 *
2363 * @return 1 if may read, else 0.
2364 */
2365 int
port_list_target_iterator_readable(iterator_t * iterator)2366 port_list_target_iterator_readable (iterator_t* iterator)
2367 {
2368 if (iterator->done) return 0;
2369 return iterator_int (iterator, 2);
2370 }
2371
2372
2373 /**
2374 * @brief Try restore a port list.
2375 *
2376 * If success, ends transaction for caller before exiting.
2377 *
2378 * @param[in] port_list_id UUID of resource.
2379 *
2380 * @return 0 success, 1 fail because port list is in use, 2 failed to find
2381 * port list, -1 error.
2382 */
2383 int
restore_port_list(const char * port_list_id)2384 restore_port_list (const char *port_list_id)
2385 {
2386 port_list_t port_list, table_port_list;
2387
2388 if (find_trash ("port_list", port_list_id, &port_list))
2389 {
2390 sql_rollback ();
2391 return -1;
2392 }
2393
2394 if (port_list == 0)
2395 return 2;
2396
2397 if (sql_int ("SELECT count(*) FROM port_lists"
2398 " WHERE name ="
2399 " (SELECT name FROM port_lists_trash WHERE id = %llu)"
2400 " AND " ACL_USER_OWNS () ";",
2401 port_list,
2402 current_credentials.uuid))
2403 {
2404 sql_rollback ();
2405 return 3;
2406 }
2407
2408 sql ("INSERT INTO port_lists"
2409 " (uuid, owner, name, comment, predefined, creation_time,"
2410 " modification_time)"
2411 " SELECT uuid, owner, name, comment, predefined, creation_time,"
2412 " modification_time"
2413 " FROM port_lists_trash WHERE id = %llu;",
2414 port_list);
2415
2416 table_port_list = sql_last_insert_id ();
2417
2418 sql ("INSERT INTO port_ranges"
2419 " (uuid, port_list, type, start, \"end\", comment, exclude)"
2420 " SELECT uuid, %llu, type, start, \"end\", comment, exclude"
2421 " FROM port_ranges_trash WHERE port_list = %llu;",
2422 table_port_list,
2423 port_list);
2424
2425 /* Update the port_list in any trashcan targets. */
2426 sql ("UPDATE targets_trash"
2427 " SET port_list = %llu,"
2428 " port_list_location = " G_STRINGIFY (LOCATION_TABLE)
2429 " WHERE port_list = %llu"
2430 " AND port_list_location = " G_STRINGIFY (LOCATION_TRASH),
2431 table_port_list,
2432 port_list);
2433
2434 permissions_set_locations ("port_list", port_list, table_port_list,
2435 LOCATION_TABLE);
2436 tags_set_locations ("port_list", port_list,
2437 sql_last_insert_id (),
2438 LOCATION_TABLE);
2439
2440 sql ("DELETE FROM port_ranges_trash WHERE port_list = %llu;", port_list);
2441 sql ("DELETE FROM port_lists_trash WHERE id = %llu;", port_list);
2442 sql_commit ();
2443
2444 return 0;
2445 }
2446
2447 /**
2448 * @brief Empty trashcan.
2449 */
2450 void
empty_trashcan_port_lists()2451 empty_trashcan_port_lists ()
2452 {
2453 sql ("DELETE FROM port_ranges_trash"
2454 " WHERE port_list IN (SELECT id from port_lists_trash"
2455 " WHERE owner = (SELECT id FROM users"
2456 " WHERE uuid = '%s'));",
2457 current_credentials.uuid);
2458
2459 sql ("DELETE FROM port_lists_trash"
2460 " WHERE owner = (SELECT id FROM users WHERE uuid = '%s');",
2461 current_credentials.uuid);
2462 }
2463
2464 /**
2465 * @brief Change ownership of port lists, for user deletion.
2466 *
2467 * @param[in] user Current owner.
2468 * @param[in] inheritor New owner.
2469 */
2470 void
inherit_port_lists(user_t user,user_t inheritor)2471 inherit_port_lists (user_t user, user_t inheritor)
2472 {
2473 sql ("UPDATE port_lists SET owner = %llu WHERE owner = %llu;",
2474 inheritor, user);
2475
2476 sql ("UPDATE port_lists_trash SET owner = %llu WHERE owner = %llu;",
2477 inheritor, user);
2478 }
2479
2480 /**
2481 * @brief Delete all port lists owned by a user.
2482 *
2483 * @param[in] user The user.
2484 */
2485 void
delete_port_lists_user(user_t user)2486 delete_port_lists_user (user_t user)
2487 {
2488 sql ("DELETE FROM port_ranges"
2489 " WHERE port_list IN (SELECT id FROM port_lists WHERE owner = %llu);",
2490 user);
2491 sql ("DELETE FROM port_ranges_trash"
2492 " WHERE port_list IN (SELECT id FROM port_lists_trash"
2493 " WHERE owner = %llu);",
2494 user);
2495 sql ("DELETE FROM port_lists WHERE owner = %llu;", user);
2496 sql ("DELETE FROM port_lists_trash WHERE owner = %llu;", user);
2497 }
2498
2499 /**
2500 * @brief Migrate old ownerless port lists to the Feed Owner.
2501 */
2502 void
migrate_predefined_port_lists()2503 migrate_predefined_port_lists ()
2504 {
2505 sql ("UPDATE port_lists"
2506 " SET owner = (SELECT id FROM users"
2507 " WHERE uuid = (SELECT value FROM settings"
2508 " WHERE uuid = '%s'))"
2509 " WHERE owner is NULL;",
2510 SETTING_UUID_FEED_IMPORT_OWNER);
2511 }
2512
2513
2514 /* Startup. */
2515
2516 /**
2517 * @brief Check if a port list has been updated in the feed.
2518 *
2519 * @param[in] path Full path to port list XML in feed.
2520 * @param[in] port_list Port List.
2521 *
2522 * @return 1 if updated in feed, else 0.
2523 */
2524 int
port_list_updated_in_feed(port_list_t port_list,const gchar * path)2525 port_list_updated_in_feed (port_list_t port_list, const gchar *path)
2526 {
2527 GStatBuf state;
2528 int last_update;
2529
2530 last_update = sql_int ("SELECT modification_time FROM port_lists"
2531 " WHERE id = %llu;",
2532 port_list);
2533
2534 if (g_stat (path, &state))
2535 {
2536 g_warning ("%s: Failed to stat feed port_list file: %s",
2537 __func__,
2538 strerror (errno));
2539 return 0;
2540 }
2541
2542 if (state.st_mtime <= last_update)
2543 return 0;
2544
2545 return 1;
2546 }
2547
2548 /**
2549 * @brief Update a port list from an XML file.
2550 *
2551 * @param[in] port_list Existing port list.
2552 * @param[in] name New name.
2553 * @param[in] comment New comment.
2554 * @param[in] ranges New port ranges.
2555 */
2556 void
update_port_list(port_list_t port_list,const gchar * name,const gchar * comment,array_t * ranges)2557 update_port_list (port_list_t port_list, const gchar *name,
2558 const gchar *comment,
2559 array_t *ranges /* range_t */)
2560 {
2561 gchar *quoted_name, *quoted_comment;
2562 int index;
2563 range_t *range;
2564
2565 sql_begin_immediate ();
2566
2567 quoted_name = sql_quote (name);
2568 quoted_comment = sql_quote (comment ? comment : "");
2569 sql ("UPDATE port_lists"
2570 " SET name = '%s', comment = '%s',"
2571 " predefined = 1, modification_time = m_now ()"
2572 " WHERE id = %llu;",
2573 quoted_name,
2574 quoted_comment,
2575 port_list);
2576 g_free (quoted_name);
2577 g_free (quoted_comment);
2578
2579 /* Replace the preferences. */
2580
2581 sql ("DELETE FROM port_ranges WHERE port_list = %llu;", port_list);
2582 ranges_sort_merge (ranges);
2583 array_terminate (ranges);
2584 index = 0;
2585 while ((range = (range_t*) g_ptr_array_index (ranges, index++)))
2586 insert_port_range (port_list, range->type, range->start, range->end);
2587
2588 sql_commit ();
2589 }
2590
2591 /**
2592 * @brief Check port lists, for startup.
2593 */
2594 void
check_db_port_lists()2595 check_db_port_lists ()
2596 {
2597 migrate_predefined_port_lists ();
2598
2599 if (sync_port_lists_with_feed (FALSE) <= -1)
2600 g_warning ("%s: Failed to sync port lists with feed", __func__);
2601
2602 /*
2603 * Ensure that the highest number in a port range is 65535. At some point
2604 * ranges were initialised to 65536.
2605 *
2606 * This should be a migrator, but this way is easier to backport. */
2607 sql ("UPDATE port_ranges SET \"end\" = 65535 WHERE \"end\" = 65536;");
2608 sql ("UPDATE port_ranges SET start = 65535 WHERE start = 65536;");
2609
2610 /* Warn about feed resources in the trash. */
2611 if (sql_int ("SELECT EXISTS (SELECT * FROM port_lists_trash"
2612 " WHERE predefined = 1);"))
2613 {
2614 g_warning ("%s: There are feed port lists in the trash."
2615 " These will be excluded from the sync.",
2616 __func__);
2617 }
2618 }
2619