|
0
|
1 /* Distributed Checksum Clearinghouse |
|
|
2 * |
|
|
3 * control dcc server |
|
|
4 * |
|
|
5 * Copyright (c) 2008 by Rhyolite Software, LLC |
|
|
6 * |
|
|
7 * This agreement is not applicable to any entity which sells anti-spam |
|
|
8 * solutions to others or provides an anti-spam solution as part of a |
|
|
9 * security solution sold to other entities, or to a private network |
|
|
10 * which employs the DCC or uses data provided by operation of the DCC |
|
|
11 * but does not provide corresponding data to other users. |
|
|
12 * |
|
|
13 * Permission to use, copy, modify, and distribute this software without |
|
|
14 * changes for any purpose with or without fee is hereby granted, provided |
|
|
15 * that the above copyright notice and this permission notice appear in all |
|
|
16 * copies and any distributed versions or copies are either unchanged |
|
|
17 * or not called anything similar to "DCC" or "Distributed Checksum |
|
|
18 * Clearinghouse". |
|
|
19 * |
|
|
20 * Parties not eligible to receive a license under this agreement can |
|
|
21 * obtain a commercial license to use DCC by contacting Rhyolite Software |
|
|
22 * at sales@rhyolite.com. |
|
|
23 * |
|
|
24 * A commercial license would be for Distributed Checksum and Reputation |
|
|
25 * Clearinghouse software. That software includes additional features. This |
|
|
26 * free license for Distributed ChecksumClearinghouse Software does not in any |
|
|
27 * way grant permision to use Distributed Checksum and Reputation Clearinghouse |
|
|
28 * software |
|
|
29 * |
|
|
30 * THE SOFTWARE IS PROVIDED "AS IS" AND RHYOLITE SOFTWARE, LLC DISCLAIMS ALL |
|
|
31 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES |
|
|
32 * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL RHYOLITE SOFTWARE, LLC |
|
|
33 * BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES |
|
|
34 * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, |
|
|
35 * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, |
|
|
36 * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS |
|
|
37 * SOFTWARE. |
|
|
38 * |
|
|
39 * Rhyolite Software DCC 1.3.103-1.227 $Revision$ |
|
|
40 */ |
|
|
41 |
|
|
42 #include "dcc_ck.h" |
|
|
43 #include "dcc_xhdr.h" |
|
|
44 #include "dcc_heap_debug.h" |
|
|
45 #include "dcc_ids.h" |
|
|
46 #ifndef DCC_WIN32 |
|
|
47 #include <arpa/inet.h> |
|
|
48 #endif |
|
|
49 |
|
|
50 static DCC_EMSG dcc_emsg; |
|
|
51 static DCC_FNM_LNO_BUF fnm_buf; |
|
|
52 |
|
|
53 static DCC_CLNT_CTXT *ctxt; |
|
|
54 |
|
|
55 static DCC_PATH info_map_nm = DCC_MAP_NM_DEF; |
|
|
56 static const char *ids_nm; |
|
|
57 static time_t clock_kludge; |
|
|
58 static const char *homedir; |
|
|
59 static DCC_PASSWD passwd; |
|
|
60 static u_char passwd_set; |
|
|
61 static DCC_IP src; |
|
|
62 static DCC_SRVR_NM srvr = DCC_SRVR_NM_DEF; |
|
|
63 static u_char port_set; |
|
|
64 static DCC_CLNT_ID srvr_clnt_id = DCC_ID_ANON; |
|
|
65 static enum WHICH_MAP {MAP_TMP, MAP_INFO} which_map = MAP_INFO; |
|
|
66 static u_char map_changed = 1; |
|
|
67 |
|
|
68 static u_char info_flags; |
|
|
69 |
|
|
70 static u_char grey_set; |
|
|
71 |
|
|
72 static u_char quiet; |
|
|
73 |
|
|
74 |
|
|
75 static u_char do_cmds(char *); |
|
|
76 static void set_which_map(enum WHICH_MAP); |
|
|
77 static u_char init_map(u_char, u_char); |
|
|
78 |
|
|
79 struct cmd_tbl_entry; |
|
|
80 /* -1=display help message, 0=command failed, 1=success */ |
|
|
81 typedef int CMD (const char *, const struct cmd_tbl_entry *); |
|
|
82 typedef struct cmd_tbl_entry { |
|
|
83 const char *cmd; |
|
|
84 CMD (*fnc); |
|
|
85 u_char args; /* 0=optional, 1=required, 2=none */ |
|
|
86 u_char privileged; /* 1=must have server's password */ |
|
|
87 u_char write_map; /* 1=write map, 2=write /var/dcc/map */ |
|
|
88 const char *help_str; |
|
|
89 } CMD_TBL_ENTRY; |
|
|
90 |
|
|
91 static CMD help_cmd; |
|
|
92 static CMD exit_cmd; |
|
|
93 static CMD grey_cmd; |
|
|
94 static CMD file_cmd; |
|
|
95 static CMD new_map_cmd; |
|
|
96 static CMD delete_cmd; |
|
|
97 static CMD add_cmd; |
|
|
98 static CMD load_cmd; |
|
|
99 static CMD host_cmd; |
|
|
100 static CMD port_cmd; |
|
|
101 static CMD passwd_cmd; |
|
|
102 static CMD id_cmd; |
|
|
103 static CMD homedir_cmd; |
|
|
104 static CMD debug_cmd; |
|
|
105 static CMD quiet_cmd; |
|
|
106 static CMD no_fail_cmd; |
|
|
107 static CMD ckludge_cmd; |
|
|
108 static CMD ipv6_cmd; |
|
|
109 static CMD src_cmd; |
|
|
110 static CMD socks_cmd; |
|
|
111 static CMD info_cmd; |
|
|
112 static CMD rtt_cmd; |
|
|
113 static CMD delck_cmd; |
|
|
114 static CMD sleep_cmd; |
|
|
115 static CMD clients_cmd; |
|
|
116 static CMD anon_cmd; |
|
|
117 static CMD flod_rewind; |
|
|
118 static CMD ffwd_in; |
|
|
119 static CMD ffwd_out; |
|
|
120 static CMD flod_stats; |
|
|
121 static CMD stats_cmd; |
|
|
122 static const char *stats_help; |
|
|
123 static CMD clock_ck_cmd; |
|
|
124 static CMD trace_def; |
|
|
125 |
|
|
126 static const CMD_TBL_ENTRY cmds_tbl[] = { |
|
|
127 {"help", help_cmd, 0, 0, 0, "help [cmd]"}, |
|
|
128 {"?", help_cmd, 0, 0, 0, 0}, |
|
|
129 {"exit", exit_cmd, 2, 0, 0, "exit"}, |
|
|
130 {"quit", exit_cmd, 2, 0, 0, 0}, |
|
|
131 {"grey", grey_cmd, 0, 0, 0, "grey [on|off]"}, |
|
|
132 {"homedir", homedir_cmd, 0, 0, 0, "homedir [path]"}, |
|
|
133 {"file", file_cmd, 0, 0, 0, "file [map]"}, |
|
|
134 {"map", file_cmd, 0, 0, 0, 0}, |
|
|
135 {"new map", new_map_cmd, 0, 0, 0, "new map [map]"}, |
|
|
136 {"delete", delete_cmd, 1, 0, 2, "delete host[,port]"}, |
|
|
137 {"add", add_cmd, 1, 0, 2, |
|
|
138 "add host,[port|-] [RTT+/-#] [ID [passwd]]"}, |
|
|
139 {"load", load_cmd, 1, 0, 2, "load {info-file | -}"}, |
|
|
140 {"host", host_cmd, 0, 0, 0, "host [hostname]"}, |
|
|
141 {"server", host_cmd, 0, 0, 0, 0}, |
|
|
142 {"port", port_cmd, 0, 0, 0, "port #"}, |
|
|
143 {"password", passwd_cmd, 0, 0, 0, "password secret"}, |
|
|
144 {"passwd", passwd_cmd, 0, 0, 0, 0}, |
|
|
145 {"id", id_cmd, 0, 0, 0, "id [ID]"}, |
|
|
146 {"debug", debug_cmd, 0, 0, 0, "debug [on|off|TTL=x]"}, |
|
|
147 {"quiet", quiet_cmd, 0, 0, 0, "-quiet [on|off]"}, |
|
|
148 {"no fail", no_fail_cmd, 2, 0, 2, "-no fail"}, |
|
|
149 {"clock kludge",ckludge_cmd, 0, 0, 0, "clock kludge +/-secs"}, |
|
|
150 {"IPv6", ipv6_cmd, 0, 0, 0, "IPv6 [on|off]"}, |
|
|
151 {"src", src_cmd, 0, 0, 0, "src [-|IPaddress]"}, |
|
|
152 {"SOCKS", socks_cmd, 0, 0, 0, "SOCKS [on|off]"}, |
|
|
153 {"info", info_cmd, 0, 0, 0, "info [-N]"}, |
|
|
154 {"RTT", rtt_cmd, 0, 0, 0, "RTT [-N]"}, |
|
|
155 {"delck", delck_cmd, 1, 1, 0, "delck type hex1..4"}, |
|
|
156 {"sleep", sleep_cmd, 1, 0, 0, "sleep sec.onds"}, |
|
|
157 {"clients", clients_cmd, 0, 0, 0, |
|
|
158 "clients [-nsiaVAK] [max [thold [addr/prefix]]]"}, |
|
|
159 {"anon delay", anon_cmd, 0, 0, 0, "\nanon delay [delay[,inflate]]"}, |
|
|
160 {"flood rewind",flod_rewind, 1, 1, 0, "flood rewind ID"}, |
|
|
161 {"flod rewind", flod_rewind, 1, 1, 0, 0}, |
|
|
162 {"flood FFWD in",ffwd_in, 1, 1, 0, "flood FFWD in ID"}, |
|
|
163 {"flod FFWD in",ffwd_in, 1, 1, 0, 0}, |
|
|
164 {"flood FFWD out",ffwd_out, 1, 1, 0, "flood FFWD out ID"}, |
|
|
165 {"flod FFWD out",ffwd_out, 1, 1, 0, 0}, |
|
|
166 {"flood stats", flod_stats, 1, 1, 0, "flood stats [clear] {ID|all}"}, |
|
|
167 {"flod stats", flod_stats, 1, 1, 0, 0}, |
|
|
168 {"stats", stats_cmd, 0, 0, 0, "stats [clear|all]"}, |
|
|
169 {"status", stats_cmd, 0, 0, 0, 0}, |
|
|
170 {"clock check", clock_ck_cmd, 0, 0, 0, "clock check"}, |
|
|
171 {"trace default",trace_def, 2, 1, 0, "trace default"}, |
|
|
172 }; |
|
|
173 |
|
|
174 |
|
|
175 #define PRV_MSG ";\n" \ |
|
|
176 " use the \"id server-ID\" command\n" \ |
|
|
177 " and either \"password secret\" command or `su` to read passwords from %s" |
|
|
178 |
|
|
179 |
|
|
180 static DCC_OP_RESP aop_resp; |
|
|
181 static struct timeval op_start, op_end; |
|
|
182 static DCC_SOCKU op_result_su; |
|
|
183 |
|
|
184 static struct { |
|
|
185 const char *op; |
|
|
186 const char *help_str; |
|
|
187 DCC_AOPS aop; |
|
|
188 u_char privileged; |
|
|
189 u_int32_t val; |
|
|
190 } aops_tbl[] = { |
|
|
191 #define TMAC(s,b) \ |
|
|
192 {"trace "#s" on", "trace "#s" {on|off}", \ |
|
|
193 DCC_AOP_TRACE_ON, 1, DCC_TRACE_##b},\ |
|
|
194 {"trace "#s" off", 0, DCC_AOP_TRACE_OFF, 1, DCC_TRACE_##b} |
|
|
195 TMAC(admn,ADMN_BIT), |
|
|
196 TMAC(anon,ANON_BIT), |
|
|
197 TMAC(clnt,CLNT_BIT), |
|
|
198 TMAC(rlim,RLIM_BIT), |
|
|
199 TMAC(query,QUERY_BIT), |
|
|
200 TMAC(ridc,RIDC_BIT), |
|
|
201 TMAC(flood,FLOD_BIT), |
|
|
202 TMAC(flood2,FLOD2_BIT), |
|
|
203 TMAC(ids,IDS_BIT), |
|
|
204 TMAC(bl,BL_BIT), |
|
|
205 TMAC(db,DB_BIT), |
|
|
206 TMAC(wlist,WLIST_BIT), |
|
|
207 #undef TMAC |
|
|
208 |
|
|
209 {"stop", "", DCC_AOP_STOP, 1, 0}, |
|
|
210 {"system stop", "", DCC_AOP_STOP, 1, 1}, |
|
|
211 {"clean stop", "", DCC_AOP_STOP, 1, 2}, |
|
|
212 {"flood check", "", DCC_AOP_FLOD, 1, DCC_AOP_FLOD_CHECK}, |
|
|
213 {"flod check", 0, DCC_AOP_FLOD, 1, DCC_AOP_FLOD_CHECK}, |
|
|
214 {"flood shutdown", "", DCC_AOP_FLOD, 1, DCC_AOP_FLOD_SHUTDOWN}, |
|
|
215 {"flood shutdown", 0, DCC_AOP_FLOD, 1, DCC_AOP_FLOD_SHUTDOWN}, |
|
|
216 {"flood halt", "", DCC_AOP_FLOD, 1, DCC_AOP_FLOD_HALT}, |
|
|
217 {"flood halt", 0, DCC_AOP_FLOD, 1, DCC_AOP_FLOD_HALT}, |
|
|
218 {"flood resume", "", DCC_AOP_FLOD, 1, DCC_AOP_FLOD_RESUME}, |
|
|
219 {"flood resume", 0, DCC_AOP_FLOD, 1, DCC_AOP_FLOD_RESUME}, |
|
|
220 {"flood list", "", DCC_AOP_FLOD, 0, DCC_AOP_FLOD_LIST}, |
|
|
221 {"flood list", 0, DCC_AOP_FLOD, 0, DCC_AOP_FLOD_LIST}, |
|
|
222 {"DB clean", "", DCC_AOP_DB_CLEAN, 1, 0}, |
|
|
223 {"DB new", "", DCC_AOP_DB_NEW, 1, 0}, |
|
|
224 {"DB flush cache", "", DCC_AOP_DB_UNLOAD, 1, 0}, |
|
|
225 {"DB cache ok", "", DCC_AOP_DB_UNLOAD, 1, 1}, |
|
|
226 }; |
|
|
227 |
|
|
228 |
|
|
229 static void NRATTRIB |
|
|
230 usage(void) |
|
|
231 { |
|
|
232 dcc_logbad(EX_USAGE, |
|
|
233 "usage: [-Vdq] [-h homedir] [-c ids] [op1 [op2] ... ]\n"); |
|
|
234 } |
|
|
235 |
|
|
236 |
|
|
237 |
|
|
238 int NRATTRIB |
|
|
239 main(int argc, char **argv) |
|
|
240 { |
|
|
241 char cmd_buf[500]; |
|
|
242 int i; |
|
|
243 |
|
|
244 srvr.port = htons(DCC_SRVR_PORT); |
|
|
245 |
|
|
246 dcc_init_priv(); |
|
|
247 dcc_syslog_init(0, argv[0], 0); |
|
|
248 |
|
|
249 while ((i = getopt(argc, argv, "Vdqh:c:")) != -1) { |
|
|
250 switch (i) { |
|
|
251 case 'V': |
|
|
252 fprintf(stderr, DCC_VERSION"\n"); |
|
|
253 break; |
|
|
254 |
|
|
255 case 'd': |
|
|
256 ++dcc_clnt_debug; |
|
|
257 break; |
|
|
258 |
|
|
259 case 'q': |
|
|
260 ++quiet; |
|
|
261 break; |
|
|
262 |
|
|
263 case 'h': |
|
|
264 homedir = optarg; |
|
|
265 break; |
|
|
266 |
|
|
267 case 'c': |
|
|
268 ids_nm = optarg; |
|
|
269 break; |
|
|
270 |
|
|
271 default: |
|
|
272 usage(); |
|
|
273 } |
|
|
274 } |
|
|
275 argc -= optind; |
|
|
276 argv += optind; |
|
|
277 |
|
|
278 dcc_clnt_unthread_init(); |
|
|
279 dcc_cdhome(0, homedir, 1); |
|
|
280 set_ids_path(0, ids_nm); |
|
|
281 dcc_wf_init(&cmn_wf, 0); |
|
|
282 |
|
|
283 dcc_all_srvrs = 1; |
|
|
284 |
|
|
285 if (!init_map(!quiet, 0)) |
|
|
286 set_which_map(MAP_TMP); |
|
|
287 |
|
|
288 /* with a list of commands, act as a batch utility */ |
|
|
289 if (argc != 0) { |
|
|
290 for (;;) { |
|
|
291 /* a final arg of "-" says switch to interactive mode */ |
|
|
292 if (argc == 1 && !strcmp(*argv, "-")) |
|
|
293 break; |
|
|
294 |
|
|
295 if (!do_cmds(*argv)) { |
|
|
296 fputs(" ?\n", stderr); |
|
|
297 exit(EX_UNAVAILABLE); |
|
|
298 } |
|
|
299 assert_ctxts_unlocked(); |
|
|
300 assert_info_unlocked(); |
|
|
301 |
|
|
302 ++argv; |
|
|
303 if (!--argc) { |
|
|
304 exit(EX_OK); |
|
|
305 } |
|
|
306 } |
|
|
307 } |
|
|
308 |
|
|
309 /* Without an arg list of commands, look for commands from STDIN. |
|
|
310 * Commands end with a semicolon or newline. */ |
|
|
311 for (;;) { |
|
|
312 assert_ctxts_unlocked(); |
|
|
313 assert_info_unlocked(); |
|
|
314 printf("cdcc %s> ", |
|
|
315 which_map == MAP_INFO ? info_map_nm : "-"); |
|
|
316 fflush(stderr); |
|
|
317 fflush(stdout); |
|
|
318 if (!fgets(cmd_buf, sizeof(cmd_buf), stdin)) { |
|
|
319 fputc('\n', stdout); |
|
|
320 exit(EX_OK); |
|
|
321 } |
|
|
322 if (!do_cmds(cmd_buf)) |
|
|
323 fputs(" ?\n", stderr); |
|
|
324 } |
|
|
325 } |
|
|
326 |
|
|
327 |
|
|
328 |
|
|
329 /* see if don't need a server-ID password, have one or if we can get it */ |
|
|
330 static u_char /* 0=failed, 1=ok */ |
|
|
331 get_passwd(u_char privileged) /* 0=no privileges need, 1=need power */ |
|
|
332 { |
|
|
333 const ID_TBL *srvr_clnt_tbl; |
|
|
334 |
|
|
335 srvr.clnt_id = srvr_clnt_id; |
|
|
336 if (passwd_set) { |
|
|
337 /* set to use the manual password */ |
|
|
338 memcpy(srvr.passwd, passwd, sizeof(srvr.passwd)); |
|
|
339 /* succeed if this is not a priviledge command |
|
|
340 * or if we won't be trying to get the server to do |
|
|
341 * something priviledge for the anonymous client-ID */ |
|
|
342 return (!privileged || srvr.clnt_id != DCC_ID_ANON); |
|
|
343 } |
|
|
344 memset(srvr.passwd, 0, sizeof(srvr.passwd)); |
|
|
345 |
|
|
346 /* fail if we would be trying to get the server to do something |
|
|
347 * powerful for the anonymous client-ID */ |
|
|
348 if (srvr.clnt_id == DCC_ID_ANON) |
|
|
349 return !privileged; |
|
|
350 |
|
|
351 /* Fetch the common server passwords only if we can read them without |
|
|
352 * set-UID. This keeps random local users from attacking local |
|
|
353 * or remote servers with privileged commands, but does not slow |
|
|
354 * down privilege users who could use an editor to read and use |
|
|
355 * the cleartext passwords manually. */ |
|
|
356 dcc_rel_priv(); |
|
|
357 if (0 > access(ids_path, R_OK) && errno == EACCES) { |
|
|
358 srvr.clnt_id = DCC_ID_ANON; |
|
|
359 if (!privileged) |
|
|
360 return 1; |
|
|
361 dcc_error_msg("access(%s): %s", |
|
|
362 fnm2abs_err(0, ids_path), ERROR_STR()); |
|
|
363 return 0; |
|
|
364 } |
|
|
365 |
|
|
366 if (0 >= load_ids(dcc_emsg, srvr_clnt_id, &srvr_clnt_tbl, 1)) { |
|
|
367 if (srvr_clnt_id != DCC_ID_ANON && privileged) |
|
|
368 dcc_error_msg("%s", dcc_emsg); |
|
|
369 srvr.clnt_id = DCC_ID_ANON; |
|
|
370 return !privileged; |
|
|
371 } |
|
|
372 if (srvr_clnt_tbl) |
|
|
373 memcpy(srvr.passwd, srvr_clnt_tbl->cur_passwd, |
|
|
374 sizeof(srvr.passwd)); |
|
|
375 return 1; |
|
|
376 } |
|
|
377 |
|
|
378 |
|
|
379 |
|
|
380 static void |
|
|
381 set_which_map(enum WHICH_MAP new) |
|
|
382 { |
|
|
383 /* release things even if nothing seems to be changing |
|
|
384 * to ensure that we bind a new socket */ |
|
|
385 if (ctxt) { |
|
|
386 dcc_ctxts_lock(); |
|
|
387 if (dcc_clnt_info) |
|
|
388 dcc_unmap_close_info(0); |
|
|
389 if (ctxt) { |
|
|
390 dcc_rel_ctxt(ctxt); |
|
|
391 ctxt = 0; |
|
|
392 } |
|
|
393 dcc_ctxts_unlock(); |
|
|
394 } |
|
|
395 |
|
|
396 map_changed = 1; |
|
|
397 which_map = new; |
|
|
398 if (new == MAP_INFO) { |
|
|
399 passwd_set = 0; |
|
|
400 src.family = AF_UNSPEC; |
|
|
401 } |
|
|
402 } |
|
|
403 |
|
|
404 |
|
|
405 |
|
|
406 static u_char |
|
|
407 cdcc_unlock(u_char complain) |
|
|
408 { |
|
|
409 u_char result; |
|
|
410 |
|
|
411 result = dcc_info_unlock(dcc_emsg); |
|
|
412 dcc_ctxts_unlock(); |
|
|
413 if (!result && complain) |
|
|
414 dcc_error_msg("%s", dcc_emsg); |
|
|
415 return result; |
|
|
416 } |
|
|
417 |
|
|
418 |
|
|
419 |
|
|
420 /* start talking to the local map file */ |
|
|
421 static u_char /* 0=failed 1=mapped and locked */ |
|
|
422 init_map(u_char complain, |
|
|
423 u_char lock) /* 1=keep both locks on success */ |
|
|
424 { |
|
|
425 u_char result; |
|
|
426 |
|
|
427 info_flags = 0; |
|
|
428 |
|
|
429 dcc_emsg[0] = '\0'; |
|
|
430 dcc_ctxts_lock(); |
|
|
431 if (which_map == MAP_TMP) { |
|
|
432 result = (dcc_map_tmp_info(dcc_emsg, &srvr, &src, info_flags) |
|
|
433 && dcc_info_lock(dcc_emsg)); |
|
|
434 } else { |
|
|
435 result = dcc_map_lock_info(dcc_emsg, info_map_nm, -1); |
|
|
436 } |
|
|
437 if (result) { |
|
|
438 info_flags = dcc_clnt_info->flags; |
|
|
439 if (!lock) |
|
|
440 result = cdcc_unlock(complain); |
|
|
441 } else { |
|
|
442 dcc_ctxts_unlock(); |
|
|
443 if (complain) |
|
|
444 dcc_error_msg("%s", dcc_emsg); |
|
|
445 } |
|
|
446 return result; |
|
|
447 } |
|
|
448 |
|
|
449 |
|
|
450 |
|
|
451 /* get ready start talking to a DCC server */ |
|
|
452 static u_char /* 0=failed, 1=ok */ |
|
|
453 rdy_ctxt(DCC_CLNT_FGS fgs) |
|
|
454 { |
|
|
455 u_char rdy_done, need_unlock; |
|
|
456 |
|
|
457 info_flags = 0; |
|
|
458 |
|
|
459 if (grey_on) |
|
|
460 fgs |= DCC_CLNT_FG_GREY; |
|
|
461 else |
|
|
462 fgs &= ~DCC_CLNT_FG_GREY; |
|
|
463 fgs |= DCC_CLNT_FG_NO_FAIL; |
|
|
464 |
|
|
465 if (!dcc_clnt_info && ctxt) { |
|
|
466 dcc_rel_ctxt(ctxt); |
|
|
467 ctxt = 0; |
|
|
468 } |
|
|
469 |
|
|
470 if (ctxt) { |
|
|
471 rdy_done = 0; |
|
|
472 } else { |
|
|
473 if (which_map == MAP_TMP) { |
|
|
474 /* create a new temporary map */ |
|
|
475 ctxt = dcc_tmp_clnt_init(dcc_emsg, ctxt, &srvr, &src, |
|
|
476 fgs, 0); |
|
|
477 } else { |
|
|
478 /* open official map file */ |
|
|
479 ctxt = dcc_clnt_init(dcc_emsg, ctxt, info_map_nm, fgs); |
|
|
480 } |
|
|
481 if (!ctxt) { |
|
|
482 dcc_error_msg("%s", dcc_emsg); |
|
|
483 return 0; |
|
|
484 } |
|
|
485 rdy_done = 1; |
|
|
486 } |
|
|
487 |
|
|
488 if (!grey_set && dcc_clnt_info |
|
|
489 && !grey_on |
|
|
490 && dcc_clnt_info->dcc.nms[0].hostname[0] == '\0' |
|
|
491 && dcc_clnt_info->grey.nms[0].hostname[0] != '\0') { |
|
|
492 grey_on = 1; |
|
|
493 fgs |= DCC_CLNT_FG_GREY; |
|
|
494 rdy_done = 0; |
|
|
495 } |
|
|
496 |
|
|
497 dcc_ctxts_lock(); |
|
|
498 if (rdy_done) { |
|
|
499 need_unlock = 0; |
|
|
500 } else { |
|
|
501 dcc_emsg[0] = '\0'; |
|
|
502 need_unlock = dcc_clnt_rdy(dcc_emsg, ctxt, fgs); |
|
|
503 if (!dcc_clnt_info) { |
|
|
504 dcc_rel_ctxt(ctxt); |
|
|
505 ctxt = 0; |
|
|
506 dcc_ctxts_unlock(); |
|
|
507 dcc_error_msg("%s", dcc_emsg); |
|
|
508 return 0; |
|
|
509 } |
|
|
510 } |
|
|
511 info_flags = dcc_clnt_info->flags; |
|
|
512 if (!(fgs & DCC_CLNT_FG_NO_PICK_SRVR)) |
|
|
513 map_changed = 0; |
|
|
514 |
|
|
515 if (need_unlock && !dcc_info_unlock(0)) { |
|
|
516 dcc_rel_ctxt(ctxt); |
|
|
517 ctxt = 0; |
|
|
518 dcc_ctxts_unlock(); |
|
|
519 dcc_error_msg("%s", dcc_emsg); |
|
|
520 return 0; |
|
|
521 } |
|
|
522 |
|
|
523 /* check the other (greylist or not) server */ |
|
|
524 if (which_map != MAP_TMP) { |
|
|
525 dcc_emsg[0] = '\0'; |
|
|
526 if (!dcc_clnt_rdy(dcc_emsg, ctxt, fgs ^ DCC_CLNT_FG_GREY)) { |
|
|
527 if (dcc_clnt_debug > 1) |
|
|
528 dcc_error_msg("%s", dcc_emsg); |
|
|
529 } else { |
|
|
530 dcc_info_unlock(0); |
|
|
531 } |
|
|
532 } |
|
|
533 |
|
|
534 dcc_ctxts_unlock(); |
|
|
535 return 1; |
|
|
536 } |
|
|
537 |
|
|
538 |
|
|
539 |
|
|
540 static void |
|
|
541 fix_info(DCC_SRVR_CLASS *class) |
|
|
542 { |
|
|
543 map_changed = 1; |
|
|
544 |
|
|
545 if (class) { |
|
|
546 dcc_force_measure_rtt(class); |
|
|
547 } else { |
|
|
548 dcc_force_measure_rtt(&dcc_clnt_info->dcc); |
|
|
549 dcc_force_measure_rtt(&dcc_clnt_info->grey); |
|
|
550 } |
|
|
551 cdcc_unlock(1); |
|
|
552 |
|
|
553 /* repair addresses in the real map file now */ |
|
|
554 if (!quiet |
|
|
555 && which_map == MAP_INFO) |
|
|
556 rdy_ctxt(DCC_CLNT_FG_BAD_SRVR_OK); |
|
|
557 } |
|
|
558 |
|
|
559 |
|
|
560 |
|
|
561 /* compare ignoring case */ |
|
|
562 static const char * /* 0 or mismatch in str */ |
|
|
563 cmd_cmp(const char *str, const char *op) |
|
|
564 { |
|
|
565 char op_c, str_c; |
|
|
566 int len; |
|
|
567 |
|
|
568 len = 0; |
|
|
569 for (;;) { |
|
|
570 op_c = *op; |
|
|
571 /* avoid tolower() to avoid build hassles on odd systems */ |
|
|
572 if (op_c >= 'A' && op_c <= 'Z') |
|
|
573 op_c += 'a'-'A'; |
|
|
574 str_c = *str; |
|
|
575 if (str_c == '\t') |
|
|
576 str_c = ' '; |
|
|
577 else if (str_c >= 'A' && str_c <= 'Z') |
|
|
578 str_c += 'a'-'A'; |
|
|
579 if (op_c != str_c) { |
|
|
580 /* compress bursts of blanks */ |
|
|
581 if (str_c == ' ' && len != 0 && *(op-1) == ' ') { |
|
|
582 ++str; |
|
|
583 continue; |
|
|
584 } |
|
|
585 return str; |
|
|
586 } |
|
|
587 if (op_c == '\0') |
|
|
588 return 0; |
|
|
589 ++op; |
|
|
590 ++str; |
|
|
591 ++len; |
|
|
592 } |
|
|
593 } |
|
|
594 |
|
|
595 |
|
|
596 |
|
|
597 /* Display our name for the server and its address, |
|
|
598 * while suppressing some duplicates */ |
|
|
599 static void |
|
|
600 print_aop(SRVR_INX srvr_inx) /* -1 or server index */ |
|
|
601 { |
|
|
602 const DCC_SRVR_CLASS *class; |
|
|
603 char date_buf[40]; |
|
|
604 char sustr[DCC_SU2STR_SIZE]; |
|
|
605 const char *srvr_nm; |
|
|
606 NAM_INX nam_inx; |
|
|
607 |
|
|
608 dcc_su2str2(sustr, sizeof(sustr), &op_result_su); |
|
|
609 class = DCC_GREY2CLASS(grey_on); |
|
|
610 /* Display the preferred server if srvr_inx is NO_SRVR */ |
|
|
611 if (!GOOD_SRVR(class, srvr_inx)) |
|
|
612 srvr_inx = class->srvr_inx; |
|
|
613 if (GOOD_SRVR(class, srvr_inx) |
|
|
614 && (GOOD_NAM(nam_inx = class->addrs[srvr_inx].nam_inx))) { |
|
|
615 srvr_nm = class->nms[nam_inx].hostname; |
|
|
616 if (strcmp(srvr_nm, sustr)) { |
|
|
617 fputs(srvr_nm, stdout); |
|
|
618 putchar(' '); |
|
|
619 } |
|
|
620 printf("%s\n server-ID %d", |
|
|
621 dcc_su2str_err(&op_result_su), |
|
|
622 class->addrs[srvr_inx].srvr_id); |
|
|
623 } else { |
|
|
624 printf("%s\n ", |
|
|
625 dcc_su2str_err(&op_result_su)); |
|
|
626 } |
|
|
627 if (srvr.clnt_id != DCC_ID_ANON) |
|
|
628 printf(" client-ID %d", srvr.clnt_id); |
|
|
629 if (which_map == MAP_INFO) |
|
|
630 printf(" %s", info_map_nm); |
|
|
631 dcc_time2str(date_buf, sizeof(date_buf), " %X", |
|
|
632 op_start.tv_sec); |
|
|
633 fputs(date_buf, stdout); |
|
|
634 putchar('\n'); |
|
|
635 } |
|
|
636 |
|
|
637 |
|
|
638 |
|
|
639 static u_char /* 0=some kind of problem, 1=done */ |
|
|
640 start_aop(DCC_AOPS aop, u_int32_t val1, SRVR_INX srvr_inx) |
|
|
641 { |
|
|
642 DCC_OPS result; |
|
|
643 |
|
|
644 if (!rdy_ctxt(0)) |
|
|
645 return 0; |
|
|
646 |
|
|
647 gettimeofday(&op_start, 0); |
|
|
648 result = dcc_aop(dcc_emsg, ctxt, grey_on ? DCC_CLNT_FG_GREY : 0, |
|
|
649 srvr_inx, clock_kludge, |
|
|
650 aop, val1, 0, 0, 0, 0, 0, &aop_resp, &op_result_su); |
|
|
651 gettimeofday(&op_end, 0); |
|
|
652 |
|
|
653 if (result == DCC_OP_INVALID |
|
|
654 || result == DCC_OP_ERROR) { |
|
|
655 dcc_error_msg("%s", dcc_emsg); |
|
|
656 return 0; |
|
|
657 } |
|
|
658 |
|
|
659 return 1; |
|
|
660 } |
|
|
661 |
|
|
662 |
|
|
663 |
|
|
664 static void |
|
|
665 fin_aop(SRVR_INX srvr_inx, /* index of server */ |
|
|
666 u_char psrvr) /* 1=print server name */ |
|
|
667 { |
|
|
668 if (quiet && !dcc_clnt_debug) |
|
|
669 return; |
|
|
670 |
|
|
671 if (psrvr) |
|
|
672 print_aop(srvr_inx); |
|
|
673 |
|
|
674 /* say what the server had to say */ |
|
|
675 if (aop_resp.resp.val.string[0] >= ' ' |
|
|
676 && aop_resp.resp.val.string[0] < 0x7f) { |
|
|
677 fputs(aop_resp.resp.val.string, stdout); |
|
|
678 putchar('\n'); |
|
|
679 } |
|
|
680 |
|
|
681 if (dcc_clnt_debug) { |
|
|
682 printf("%.2f ms\n", |
|
|
683 ((op_end.tv_sec-op_start.tv_sec)*1000.0 |
|
|
684 + (op_end.tv_usec-op_start.tv_usec)/1000.0)); |
|
|
685 } |
|
|
686 putchar('\n'); |
|
|
687 } |
|
|
688 |
|
|
689 |
|
|
690 |
|
|
691 static u_char /* 0=some kind of problem, 1=done */ |
|
|
692 do_aop(DCC_AOPS aop, u_int32_t val1, SRVR_INX srvr_inx, u_char psrvr) |
|
|
693 { |
|
|
694 if (!start_aop(aop, val1, srvr_inx)) |
|
|
695 return 0; |
|
|
696 fin_aop(srvr_inx, psrvr); |
|
|
697 return 1; |
|
|
698 } |
|
|
699 |
|
|
700 |
|
|
701 |
|
|
702 static u_char /* 0=not enough power */ |
|
|
703 ck_cmd_priv(const CMD_TBL_ENTRY *ce, |
|
|
704 u_char privileged, /* 1=need good server-ID & password */ |
|
|
705 u_char write_map) /* 1=write map, 2=write /var/dcc/map */ |
|
|
706 { |
|
|
707 /* always call get_passwd() so we have always fetched a password |
|
|
708 * fail if this command needs a good server-ID and password */ |
|
|
709 if (!get_passwd(privileged)) { |
|
|
710 dcc_error_msg("\"%s\" is a privileged server command"PRV_MSG, |
|
|
711 ce->cmd, ids_path); |
|
|
712 return 0; |
|
|
713 } |
|
|
714 |
|
|
715 if (!write_map) |
|
|
716 return 1; |
|
|
717 |
|
|
718 /* we can always write to our own throw-away map file */ |
|
|
719 if (write_map == 1 && which_map == MAP_TMP) |
|
|
720 return 1; |
|
|
721 |
|
|
722 if (0 > access(info_map_nm, R_OK) |
|
|
723 && errno != ENOENT && errno != ENOTDIR) { |
|
|
724 dcc_error_msg("\"%s\" is a privileged command changing %s", |
|
|
725 ce->cmd, fnm2abs_err(0, info_map_nm)); |
|
|
726 return 0; |
|
|
727 } |
|
|
728 return 1; |
|
|
729 } |
|
|
730 |
|
|
731 |
|
|
732 |
|
|
733 static u_char /* 1=ok 0=bad command */ |
|
|
734 cmd(const char *op) |
|
|
735 { |
|
|
736 const char *arg, *help_str; |
|
|
737 int op_num, j; |
|
|
738 const CMD_TBL_ENTRY *ce; |
|
|
739 |
|
|
740 /* look for the string as a command and execute it if we find */ |
|
|
741 ce = &cmds_tbl[0]; |
|
|
742 for (op_num = 0; op_num < DIM(cmds_tbl); ++op_num) { |
|
|
743 if (cmds_tbl[op_num].help_str) |
|
|
744 ce = &cmds_tbl[op_num]; |
|
|
745 arg = cmd_cmp(op, cmds_tbl[op_num].cmd); |
|
|
746 /* if the command table entry and the command completely |
|
|
747 * matched, then infer a null argument */ |
|
|
748 if (!arg) { |
|
|
749 if (!ck_cmd_priv(ce, ce->privileged, ce->write_map)) |
|
|
750 return 0; |
|
|
751 if (ce->args != 1) { |
|
|
752 j = ce->fnc("", ce); |
|
|
753 if (j >= 0) |
|
|
754 return j; |
|
|
755 } |
|
|
756 help_cmd(op, 0); |
|
|
757 return 0; |
|
|
758 } |
|
|
759 /* If the command table entry is an initial sustring of |
|
|
760 * the user's command, then the rest of the command must |
|
|
761 * start with white space or '='. (Allow '=' to let |
|
|
762 * homedir/fix-map not need use `eval` to quote blanks |
|
|
763 * `eval` in bash loses exit status. |
|
|
764 * Trim and use the rest of the string as the argument */ |
|
|
765 j = strspn(arg, DCC_WHITESPACE"="); |
|
|
766 if (j) { |
|
|
767 if (ce->args == 2) { |
|
|
768 help_cmd(op, 0); /* arg not allowed */ |
|
|
769 return 0; |
|
|
770 } |
|
|
771 if (!ck_cmd_priv(ce, ce->privileged, ce->write_map)) |
|
|
772 return 0; |
|
|
773 j = ce->fnc(arg+j, ce); |
|
|
774 if (j >= 0) |
|
|
775 return j; |
|
|
776 help_cmd(op, 0); |
|
|
777 return 0; |
|
|
778 } |
|
|
779 } |
|
|
780 |
|
|
781 |
|
|
782 /* otherwise try to interpret it as a DCC administrative packet */ |
|
|
783 op_num = 0; |
|
|
784 help_str = ""; |
|
|
785 for (;;) { |
|
|
786 if (op_num >= DIM(aops_tbl)) { |
|
|
787 dcc_error_msg("unrecognized command \"%s\"", op); |
|
|
788 return 0; |
|
|
789 } |
|
|
790 /* do a command */ |
|
|
791 if (aops_tbl[op_num].help_str) { |
|
|
792 help_str = aops_tbl[op_num].help_str; |
|
|
793 if (*help_str == '\0') |
|
|
794 help_str = aops_tbl[op_num].op; |
|
|
795 } |
|
|
796 if (!cmd_cmp(op, aops_tbl[op_num].op)) |
|
|
797 break; |
|
|
798 ++op_num; |
|
|
799 } |
|
|
800 |
|
|
801 /* send an administrative request to the server */ |
|
|
802 if (!get_passwd(aops_tbl[op_num].privileged)) { |
|
|
803 dcc_error_msg("\"%s\" is a privileged operation"PRV_MSG, |
|
|
804 help_str, ids_path); |
|
|
805 return 0; |
|
|
806 } |
|
|
807 |
|
|
808 /* try to send it */ |
|
|
809 return do_aop(aops_tbl[op_num].aop, aops_tbl[op_num].val, |
|
|
810 NO_SRVR, 1); |
|
|
811 } |
|
|
812 |
|
|
813 |
|
|
814 |
|
|
815 static u_char /* 0=bad command, 1=ok */ |
|
|
816 do_cmds(char *cmd_buf) |
|
|
817 { |
|
|
818 char *next_cmd, *cur_cmd, *cmd_end; |
|
|
819 char c; |
|
|
820 |
|
|
821 next_cmd = cmd_buf; |
|
|
822 for (;;) { |
|
|
823 cur_cmd = next_cmd + strspn(next_cmd, DCC_WHITESPACE";"); |
|
|
824 |
|
|
825 if (*cur_cmd == '#' || *cur_cmd == '\0') |
|
|
826 return 1; |
|
|
827 |
|
|
828 next_cmd = cur_cmd + strcspn(cur_cmd, ";\n\r"); |
|
|
829 cmd_end = next_cmd; |
|
|
830 next_cmd += strspn(next_cmd, ";\n\r"); |
|
|
831 |
|
|
832 /* null terminate and trim trailing white space from |
|
|
833 * command or arg */ |
|
|
834 do { |
|
|
835 *cmd_end-- = '\0'; |
|
|
836 c = *cmd_end; |
|
|
837 } while (cmd_end >= cur_cmd |
|
|
838 && strchr(DCC_WHITESPACE";", c)); |
|
|
839 |
|
|
840 if (*cur_cmd == '\0') /* ignore blank commands */ |
|
|
841 continue; |
|
|
842 |
|
|
843 if (!cmd(cur_cmd)) |
|
|
844 return 0; |
|
|
845 } |
|
|
846 } |
|
|
847 |
|
|
848 |
|
|
849 |
|
|
850 static int |
|
|
851 help_cmd_print(int pos, const char *str) |
|
|
852 { |
|
|
853 #define HELP_COL 24 |
|
|
854 int col, nl; |
|
|
855 |
|
|
856 if (str[0] == '\n') { |
|
|
857 nl = 100; |
|
|
858 ++str; |
|
|
859 } else { |
|
|
860 nl = 0; |
|
|
861 } |
|
|
862 col = strlen(str)+1; |
|
|
863 col += HELP_COL - (col % HELP_COL); |
|
|
864 pos += col; |
|
|
865 if (pos > 78) { |
|
|
866 putchar('\n'); |
|
|
867 pos = col; |
|
|
868 } |
|
|
869 printf("%-*s", col, str); |
|
|
870 pos += nl; |
|
|
871 |
|
|
872 return pos; |
|
|
873 #undef HELP_COL |
|
|
874 } |
|
|
875 |
|
|
876 |
|
|
877 |
|
|
878 static int |
|
|
879 help_cmd(const char *arg, const CMD_TBL_ENTRY *ce UATTRIB) |
|
|
880 { |
|
|
881 int i, pos; |
|
|
882 const char *help_str; |
|
|
883 const char *p; |
|
|
884 |
|
|
885 /* say something about one command */ |
|
|
886 if (arg) { |
|
|
887 help_str = ""; |
|
|
888 for (i = 0; i < DIM(cmds_tbl); ++i) { |
|
|
889 if (cmds_tbl[i].help_str) |
|
|
890 help_str = cmds_tbl[i].help_str; |
|
|
891 p = cmd_cmp(arg, cmds_tbl[i].cmd); |
|
|
892 if (!p || *p == ' ' || *p == '\t') { |
|
|
893 while (*help_str == '\n' || *help_str == '-') |
|
|
894 ++help_str; |
|
|
895 printf("usage: %s\n", help_str); |
|
|
896 if (cmds_tbl[i].fnc == stats_cmd) |
|
|
897 printf(stats_help); |
|
|
898 return 1; |
|
|
899 } |
|
|
900 } |
|
|
901 for (i = 0; i < DIM(aops_tbl); ++i) { |
|
|
902 if (aops_tbl[i].help_str) { |
|
|
903 help_str = aops_tbl[i].help_str; |
|
|
904 if (*help_str == '\0') |
|
|
905 help_str = aops_tbl[i].op; |
|
|
906 } |
|
|
907 p = cmd_cmp(arg, aops_tbl[i].op); |
|
|
908 if (!p || *p == ' ' || *p == '\t') { |
|
|
909 while (*help_str == '\n' || *help_str == '-') |
|
|
910 ++help_str; |
|
|
911 printf("usage: %s\n", help_str); |
|
|
912 return 1; |
|
|
913 } |
|
|
914 } |
|
|
915 } |
|
|
916 |
|
|
917 /* talk about all of the commands */ |
|
|
918 printf(" version "DCC_VERSION"\n"); |
|
|
919 pos = 0; |
|
|
920 for (i = 0; i < DIM(cmds_tbl); ++i) { |
|
|
921 if (cmds_tbl[i].help_str |
|
|
922 && cmds_tbl[i].help_str[0] != '-') |
|
|
923 pos = help_cmd_print(pos, cmds_tbl[i].help_str); |
|
|
924 } |
|
|
925 for (i = 0; i < DIM(aops_tbl); ++i) { |
|
|
926 help_str = aops_tbl[i].help_str; |
|
|
927 if (!help_str) |
|
|
928 continue; |
|
|
929 if (*help_str == '\0') |
|
|
930 help_str = aops_tbl[i].op; |
|
|
931 pos = help_cmd_print(pos, help_str); |
|
|
932 } |
|
|
933 putchar('\n'); |
|
|
934 |
|
|
935 return 1; |
|
|
936 } |
|
|
937 |
|
|
938 |
|
|
939 |
|
|
940 static int NRATTRIB |
|
|
941 exit_cmd(const char *arg UATTRIB, const CMD_TBL_ENTRY *ce UATTRIB) |
|
|
942 { |
|
|
943 exit(EX_OK); |
|
|
944 #ifndef HAVE_GCC_ATTRIBUTES |
|
|
945 return -1; |
|
|
946 #endif |
|
|
947 } |
|
|
948 |
|
|
949 |
|
|
950 static int |
|
|
951 grey_cmd(const char *arg, const CMD_TBL_ENTRY *ce UATTRIB) |
|
|
952 { |
|
|
953 if (arg[0] == '\0') { |
|
|
954 printf(" Greylist mode %s%s\n", |
|
|
955 grey_on ? "on" : "off", |
|
|
956 grey_set ? "" : " by default"); |
|
|
957 return 1; |
|
|
958 } |
|
|
959 if (!strcmp(arg, "off")) { |
|
|
960 grey_on = 0; |
|
|
961 grey_set = 1; |
|
|
962 set_which_map(which_map); |
|
|
963 } else if (!strcmp(arg, "on")) { |
|
|
964 grey_on = 1; |
|
|
965 grey_set = 1; |
|
|
966 set_which_map(which_map); |
|
|
967 } else { |
|
|
968 return -1; |
|
|
969 } |
|
|
970 if (!port_set) |
|
|
971 srvr.port = DCC_GREY2PORT(grey_on); |
|
|
972 return 1; |
|
|
973 } |
|
|
974 |
|
|
975 |
|
|
976 |
|
|
977 static int |
|
|
978 homedir_cmd(const char *arg, const CMD_TBL_ENTRY *ce UATTRIB) |
|
|
979 { |
|
|
980 if (arg[0] != '\0') { |
|
|
981 if (!dcc_cdhome(0, arg, 1)) |
|
|
982 return 0; |
|
|
983 if (ids_nm && !set_ids_path(dcc_emsg, ids_nm)) |
|
|
984 dcc_error_msg("%s", dcc_emsg); |
|
|
985 set_which_map(MAP_INFO); |
|
|
986 } |
|
|
987 printf(" homedir=%s\n", dcc_homedir); |
|
|
988 return 1; |
|
|
989 } |
|
|
990 |
|
|
991 |
|
|
992 |
|
|
993 /* set name of map file */ |
|
|
994 static int |
|
|
995 file_cmd(const char *arg, const CMD_TBL_ENTRY *ce UATTRIB) |
|
|
996 { |
|
|
997 if (arg[0] == '\0') { |
|
|
998 if (which_map == MAP_INFO) |
|
|
999 printf(" using map file %s\n", |
|
|
1000 fnm2abs_err(0, info_map_nm)); |
|
|
1001 else |
|
|
1002 printf(" map file %s but using temporary file\n", |
|
|
1003 fnm2abs_err(0, info_map_nm)); |
|
|
1004 return 1; |
|
|
1005 } |
|
|
1006 |
|
|
1007 BUFCPY(info_map_nm, arg); |
|
|
1008 set_which_map(MAP_INFO); |
|
|
1009 return 1; |
|
|
1010 } |
|
|
1011 |
|
|
1012 |
|
|
1013 |
|
|
1014 /* create a new client map or parameter file */ |
|
|
1015 static int |
|
|
1016 new_map_cmd(const char *arg, const CMD_TBL_ENTRY *ce UATTRIB) |
|
|
1017 { |
|
|
1018 if (arg[0] == '\0') |
|
|
1019 arg = DCC_MAP_NM_DEF; |
|
|
1020 |
|
|
1021 dcc_rel_priv(); |
|
|
1022 if (!dcc_create_map(dcc_emsg, arg, 0, 0, 0, 0, 0, 0, info_flags)) { |
|
|
1023 dcc_error_msg("%s", dcc_emsg); |
|
|
1024 return 0; |
|
|
1025 } |
|
|
1026 BUFCPY(info_map_nm, arg); |
|
|
1027 set_which_map(MAP_INFO); |
|
|
1028 if (!quiet) |
|
|
1029 printf(" created %s\n", fnm2abs_err(0, info_map_nm)); |
|
|
1030 return 1; |
|
|
1031 } |
|
|
1032 |
|
|
1033 |
|
|
1034 |
|
|
1035 static int |
|
|
1036 info_work(const char *arg, int fgs) |
|
|
1037 { |
|
|
1038 DCC_CLNT_INFO info; |
|
|
1039 u_char dcc, srcbad, names; |
|
|
1040 |
|
|
1041 if (*arg == '\0') { |
|
|
1042 names = 0; |
|
|
1043 } else if (!strcmp(arg, "-N")) { |
|
|
1044 names = 1; |
|
|
1045 } else { |
|
|
1046 return -1; |
|
|
1047 } |
|
|
1048 |
|
|
1049 if (!rdy_ctxt(fgs)) |
|
|
1050 return 0; |
|
|
1051 |
|
|
1052 /* Snapshot the data and then release it while we print it. */ |
|
|
1053 dcc_ctxts_lock(); |
|
|
1054 if (!dcc_info_lock(0)) { |
|
|
1055 dcc_ctxts_lock(); |
|
|
1056 return 0; |
|
|
1057 } |
|
|
1058 memcpy(&info, dcc_clnt_info, sizeof(info)); |
|
|
1059 srcbad = ctxt && (ctxt->flags & DCC_CTXT_SRCBAD); |
|
|
1060 cdcc_unlock(1); |
|
|
1061 |
|
|
1062 dcc_rel_priv(); |
|
|
1063 if (which_map == MAP_INFO) { |
|
|
1064 if (info.dcc.nms[0].hostname[0] != '\0' |
|
|
1065 || !grey_on) { |
|
|
1066 dcc_print_info(info_map_nm, &info, |
|
|
1067 quiet, 0, srcbad, names, |
|
|
1068 0 <= access(info_map_nm, R_OK)); |
|
|
1069 dcc = 1; |
|
|
1070 } else { |
|
|
1071 dcc = 0; |
|
|
1072 } |
|
|
1073 if (info.grey.nms[0].hostname[0] != '\0' |
|
|
1074 || grey_on) { |
|
|
1075 if (dcc && !quiet) |
|
|
1076 fputs("\n################\n", stdout); |
|
|
1077 dcc_print_info(info_map_nm, &info, |
|
|
1078 quiet, 1, srcbad, names, |
|
|
1079 0 <= access(info_map_nm, R_OK)); |
|
|
1080 } |
|
|
1081 } else { |
|
|
1082 dcc_print_info(0, &info, quiet, grey_on, srcbad, names, 1); |
|
|
1083 } |
|
|
1084 if (!quiet) |
|
|
1085 putchar('\n'); |
|
|
1086 return 1; |
|
|
1087 } |
|
|
1088 |
|
|
1089 |
|
|
1090 |
|
|
1091 /* server hostname */ |
|
|
1092 static int |
|
|
1093 host_cmd(const char *arg, const CMD_TBL_ENTRY *ce UATTRIB) |
|
|
1094 { |
|
|
1095 DCC_SRVR_NM nm; |
|
|
1096 int error; |
|
|
1097 |
|
|
1098 if (arg[0] == '\0') { |
|
|
1099 if (which_map == MAP_INFO) |
|
|
1100 return info_work(arg, DCC_CLNT_FG_BAD_SRVR_OK) ; |
|
|
1101 printf(" %s server hostname \"%s\"\n", |
|
|
1102 grey_on ? "greylist" : "DCC", srvr.hostname); |
|
|
1103 return 1; |
|
|
1104 } |
|
|
1105 if (!strcmp(arg, "-")) { |
|
|
1106 set_which_map(MAP_INFO); |
|
|
1107 if (!init_map(1, 0)) { |
|
|
1108 set_which_map(MAP_TMP); |
|
|
1109 return 0; |
|
|
1110 } |
|
|
1111 return 1; |
|
|
1112 } |
|
|
1113 |
|
|
1114 arg = dcc_parse_nm_port(0, arg, 0, |
|
|
1115 nm.hostname, sizeof(nm.hostname), |
|
|
1116 &nm.port, 0, 0, |
|
|
1117 0, 0); |
|
|
1118 if (!arg) |
|
|
1119 return 0; |
|
|
1120 arg += strspn(arg, DCC_WHITESPACE); |
|
|
1121 if (*arg != '\0') |
|
|
1122 return 0; |
|
|
1123 |
|
|
1124 set_which_map(MAP_TMP); |
|
|
1125 memcpy(srvr.hostname, nm.hostname, sizeof(srvr.hostname)); |
|
|
1126 if (nm.port != 0) { |
|
|
1127 srvr.port = nm.port; |
|
|
1128 port_set = 1; |
|
|
1129 } |
|
|
1130 |
|
|
1131 /* go with the flow for IPv6 */ |
|
|
1132 dcc_host_lock(); |
|
|
1133 if (!dcc_get_host(nm.hostname, |
|
|
1134 (info_flags & DCC_INFO_FG_IPV6) ? 2 : 3, |
|
|
1135 &error)) { |
|
|
1136 dcc_host_unlock(); |
|
|
1137 dcc_error_msg("%s: %s", nm.hostname, DCC_HSTRERROR(error)); |
|
|
1138 } else { |
|
|
1139 if (dcc_hostaddrs[0].sa.sa_family == AF_INET) |
|
|
1140 info_flags &= ~DCC_INFO_FG_IPV6; |
|
|
1141 else |
|
|
1142 info_flags |= DCC_INFO_FG_IPV6; |
|
|
1143 dcc_host_unlock(); |
|
|
1144 } |
|
|
1145 |
|
|
1146 return 1; |
|
|
1147 } |
|
|
1148 |
|
|
1149 |
|
|
1150 |
|
|
1151 /* server port # */ |
|
|
1152 static int |
|
|
1153 port_cmd(const char *arg, const CMD_TBL_ENTRY *ce UATTRIB) |
|
|
1154 { |
|
|
1155 u_int port; |
|
|
1156 |
|
|
1157 if (arg[0] == '\0') { |
|
|
1158 if (which_map == MAP_INFO) |
|
|
1159 return info_work(arg, DCC_CLNT_FG_BAD_SRVR_OK) ; |
|
|
1160 printf(" port=%d\n", ntohs(srvr.port)); |
|
|
1161 return 1; |
|
|
1162 } |
|
|
1163 |
|
|
1164 port = dcc_get_port(0, arg, DCC_GREY2PORT(grey_on), 0, 0); |
|
|
1165 if (port == DCC_GET_PORT_INVALID) |
|
|
1166 return 0; |
|
|
1167 |
|
|
1168 srvr.port = port; |
|
|
1169 port_set = 1; |
|
|
1170 set_which_map(MAP_TMP); |
|
|
1171 return 1; |
|
|
1172 } |
|
|
1173 |
|
|
1174 |
|
|
1175 |
|
|
1176 static int |
|
|
1177 ipv6_cmd(const char *arg, const CMD_TBL_ENTRY *ce) |
|
|
1178 { |
|
|
1179 u_char new_use_ipv6; |
|
|
1180 |
|
|
1181 if (arg[0] == '\0') { |
|
|
1182 if (!init_map(1, 0)) |
|
|
1183 return 0; |
|
|
1184 printf(" IPv6 %s\n", |
|
|
1185 (info_flags & DCC_INFO_FG_IPV6) ? "on" : "off"); |
|
|
1186 return 1; |
|
|
1187 } |
|
|
1188 |
|
|
1189 if (!strcasecmp(arg, "off")) { |
|
|
1190 new_use_ipv6 = 0; |
|
|
1191 } else if (!strcasecmp(arg, "on")) { |
|
|
1192 new_use_ipv6 = DCC_INFO_FG_IPV6; |
|
|
1193 } else { |
|
|
1194 return -1; |
|
|
1195 } |
|
|
1196 |
|
|
1197 if (!ck_cmd_priv(ce, 0, 1)) |
|
|
1198 return 0; |
|
|
1199 |
|
|
1200 if (!init_map(1, 1)) |
|
|
1201 return 0; |
|
|
1202 if ((dcc_clnt_info->flags & DCC_INFO_FG_IPV6) != new_use_ipv6) { |
|
|
1203 dcc_clnt_info->flags ^= DCC_INFO_FG_IPV6; |
|
|
1204 info_flags = dcc_clnt_info->flags; |
|
|
1205 fix_info(0); |
|
|
1206 } else if (!cdcc_unlock(1)) { |
|
|
1207 return 0; |
|
|
1208 } |
|
|
1209 |
|
|
1210 if (rdy_ctxt(0) |
|
|
1211 && (dcc_clnt_info->flags & DCC_INFO_FG_IPV6) != new_use_ipv6) { |
|
|
1212 #ifdef NO_IPV6 |
|
|
1213 dcc_error_msg("IPv6 switch not changed;" |
|
|
1214 " No IPv6 support in this system?"); |
|
|
1215 #else |
|
|
1216 dcc_error_msg("IPv6 switch not changed."); |
|
|
1217 #endif |
|
|
1218 return 0; |
|
|
1219 } |
|
|
1220 |
|
|
1221 return 1; |
|
|
1222 } |
|
|
1223 |
|
|
1224 |
|
|
1225 |
|
|
1226 static u_char |
|
|
1227 ck_new_src(DCC_IP *new_ip, const char *arg, u_char use_ipv6) |
|
|
1228 { |
|
|
1229 SOCKET soc; |
|
|
1230 DCC_SOCKU su; |
|
|
1231 int error; |
|
|
1232 |
|
|
1233 memset(new_ip, 0, sizeof(*new_ip)); |
|
|
1234 if (!strcmp(arg, "-")) |
|
|
1235 return 1; |
|
|
1236 |
|
|
1237 dcc_host_lock(); |
|
|
1238 if (!dcc_get_host(arg, use_ipv6 ? 1 : 0, &error)) { |
|
|
1239 dcc_host_unlock(); |
|
|
1240 dcc_error_msg("%s: %s", arg, DCC_HSTRERROR(error)); |
|
|
1241 return 0; |
|
|
1242 } |
|
|
1243 if (use_ipv6) |
|
|
1244 dcc_ipv4sutoipv6(&su, &dcc_hostaddrs[0]); |
|
|
1245 else |
|
|
1246 dcc_ipv6sutoipv4(&su, &dcc_hostaddrs[0]); |
|
|
1247 dcc_su2ip(new_ip, &su); |
|
|
1248 dcc_host_unlock(); |
|
|
1249 |
|
|
1250 soc = INVALID_SOCKET; |
|
|
1251 if (0 >= dcc_udp_bind(dcc_emsg, &soc, &su, 0)) { |
|
|
1252 dcc_error_msg("%s", dcc_emsg); |
|
|
1253 return 0; |
|
|
1254 } |
|
|
1255 closesocket(soc); |
|
|
1256 |
|
|
1257 return 1; |
|
|
1258 } |
|
|
1259 |
|
|
1260 |
|
|
1261 |
|
|
1262 static int |
|
|
1263 src_cmd(const char *arg, const CMD_TBL_ENTRY *ce) |
|
|
1264 { |
|
|
1265 DCC_IP new_ip; |
|
|
1266 char sustr[DCC_SU2STR_SIZE]; |
|
|
1267 |
|
|
1268 if (arg[0] == '\0') { |
|
|
1269 if (!init_map(1, 0)) |
|
|
1270 return 0; |
|
|
1271 |
|
|
1272 if (dcc_clnt_info->src.family == AF_UNSPEC) { |
|
|
1273 printf(" no source address specified\n"); |
|
|
1274 } else { |
|
|
1275 /* display what the system actually uses */ |
|
|
1276 printf(" source address=%s%s\n", |
|
|
1277 dcc_su2str2(sustr, sizeof(sustr), |
|
|
1278 &ctxt->bind_su), |
|
|
1279 (ctxt->flags & DCC_CTXT_SRCBAD) |
|
|
1280 ? " "DCC_INFO_USE_SRCBAD : ""); |
|
|
1281 } |
|
|
1282 return 1; |
|
|
1283 } |
|
|
1284 |
|
|
1285 if (!ck_new_src(&new_ip, arg, DCC_INFO_IPV6())) |
|
|
1286 return 0; |
|
|
1287 |
|
|
1288 if (!ck_cmd_priv(ce, 0, 1)) |
|
|
1289 return 0; |
|
|
1290 |
|
|
1291 if (!init_map(1, 1)) |
|
|
1292 return 0; |
|
|
1293 src = new_ip; |
|
|
1294 dcc_clnt_info->src = src; |
|
|
1295 |
|
|
1296 fix_info(0); |
|
|
1297 return 1; |
|
|
1298 } |
|
|
1299 |
|
|
1300 |
|
|
1301 |
|
|
1302 static int |
|
|
1303 socks_cmd(const char *arg, const CMD_TBL_ENTRY *ce) |
|
|
1304 { |
|
|
1305 u_char new_use_socks; |
|
|
1306 |
|
|
1307 if (arg[0] == '\0') { |
|
|
1308 if (!init_map(1, 0)) |
|
|
1309 return 0; |
|
|
1310 printf(" SOCKS %s\n", |
|
|
1311 (info_flags & DCC_INFO_FG_SOCKS) ? "on" : "off"); |
|
|
1312 return 1; |
|
|
1313 } |
|
|
1314 |
|
|
1315 if (!strcmp(arg, "off")) { |
|
|
1316 new_use_socks = 0; |
|
|
1317 } else if (!strcmp(arg, "on")) { |
|
|
1318 new_use_socks = DCC_INFO_FG_SOCKS; |
|
|
1319 } else { |
|
|
1320 return -1; |
|
|
1321 } |
|
|
1322 |
|
|
1323 if (!ck_cmd_priv(ce, 0, 1)) |
|
|
1324 return 0; |
|
|
1325 |
|
|
1326 if (!init_map(1, 1)) |
|
|
1327 return 0; |
|
|
1328 if ((dcc_clnt_info->flags & DCC_INFO_FG_SOCKS) == new_use_socks) |
|
|
1329 return cdcc_unlock(1); /* nothing to do */ |
|
|
1330 |
|
|
1331 dcc_clnt_info->flags ^= DCC_INFO_FG_SOCKS; |
|
|
1332 info_flags = dcc_clnt_info->flags; |
|
|
1333 |
|
|
1334 fix_info(0); |
|
|
1335 return 1; |
|
|
1336 } |
|
|
1337 |
|
|
1338 |
|
|
1339 |
|
|
1340 static int |
|
|
1341 passwd_cmd(const char *arg, const CMD_TBL_ENTRY *ce UATTRIB) |
|
|
1342 { |
|
|
1343 DCC_PASSWD new_passwd; |
|
|
1344 |
|
|
1345 if (arg[0] == '\0') { |
|
|
1346 if (which_map == MAP_INFO) { |
|
|
1347 printf(" using password in %s\n", |
|
|
1348 fnm2abs_err(0, info_map_nm)); |
|
|
1349 if (passwd_set) |
|
|
1350 printf(" but the password for explicitly" |
|
|
1351 " named servers is "DCC_PASSWD_PAT"\n", |
|
|
1352 passwd); |
|
|
1353 } else { |
|
|
1354 if (passwd_set) |
|
|
1355 printf(" password "DCC_PASSWD_PAT"\n", |
|
|
1356 passwd); |
|
|
1357 else |
|
|
1358 printf(" password not set\n"); |
|
|
1359 } |
|
|
1360 return 1; |
|
|
1361 } |
|
|
1362 |
|
|
1363 arg = parse_passwd(0, new_passwd, arg, "password", 0, 0); |
|
|
1364 if (!arg || *arg != '\0') |
|
|
1365 return -1; |
|
|
1366 memcpy(passwd, new_passwd, sizeof(passwd)); |
|
|
1367 passwd_set = 1; |
|
|
1368 set_which_map(MAP_TMP); |
|
|
1369 return 1; |
|
|
1370 } |
|
|
1371 |
|
|
1372 |
|
|
1373 |
|
|
1374 static int |
|
|
1375 id_cmd(const char *arg, const CMD_TBL_ENTRY *ce UATTRIB) |
|
|
1376 { |
|
|
1377 DCC_CLNT_ID id; |
|
|
1378 |
|
|
1379 if (arg[0] == '\0') { |
|
|
1380 printf(" ID=%d\n", srvr_clnt_id); |
|
|
1381 return 1; |
|
|
1382 } |
|
|
1383 |
|
|
1384 id = dcc_get_id(0, arg, 0, 0); |
|
|
1385 if (id == DCC_ID_INVALID) |
|
|
1386 return -1; |
|
|
1387 |
|
|
1388 srvr_clnt_id = id; |
|
|
1389 set_which_map(MAP_TMP); |
|
|
1390 return 1; |
|
|
1391 } |
|
|
1392 |
|
|
1393 |
|
|
1394 |
|
|
1395 static int |
|
|
1396 debug_cmd(const char *arg, const CMD_TBL_ENTRY *ce UATTRIB) |
|
|
1397 { |
|
|
1398 char debug_str[24]; |
|
|
1399 char ttl_str[24]; |
|
|
1400 int new_ttl, new_debug; |
|
|
1401 char *p; |
|
|
1402 |
|
|
1403 if (arg[0] == '\0') { |
|
|
1404 if (!dcc_clnt_debug) |
|
|
1405 snprintf(debug_str, sizeof(debug_str), |
|
|
1406 "debug off"); |
|
|
1407 else if (dcc_clnt_debug == 1) |
|
|
1408 snprintf(debug_str, sizeof(debug_str), |
|
|
1409 "debug on"); |
|
|
1410 else |
|
|
1411 snprintf(debug_str, sizeof(debug_str), |
|
|
1412 "debug on+%d\n", dcc_clnt_debug-1); |
|
|
1413 if (dcc_debug_ttl != 0) |
|
|
1414 snprintf(ttl_str, sizeof(ttl_str), |
|
|
1415 " TTL=%d", dcc_debug_ttl); |
|
|
1416 else |
|
|
1417 ttl_str[0] = '\0'; |
|
|
1418 printf(" %s%s\n", debug_str, ttl_str); |
|
|
1419 return 1; |
|
|
1420 } |
|
|
1421 |
|
|
1422 new_ttl = dcc_debug_ttl; |
|
|
1423 new_debug = dcc_clnt_debug; |
|
|
1424 for (;;) { |
|
|
1425 if (!CLITCMP(arg, "off")) { |
|
|
1426 new_debug = 0; |
|
|
1427 arg += LITZ("off"); |
|
|
1428 } else if (!CLITCMP(arg, "on")) { |
|
|
1429 ++new_debug; |
|
|
1430 arg += LITZ("on"); |
|
|
1431 } else if (!CLITCMP(arg, "ttl=")) { |
|
|
1432 new_ttl = strtoul(arg+LITZ("ttl="), &p, 10); |
|
|
1433 #if defined(IPPROTO_IP) && defined(IP_TTL) |
|
|
1434 if (new_ttl < 256) |
|
|
1435 arg = p; |
|
|
1436 #else |
|
|
1437 printf(" TTL setting not supported\n"); |
|
|
1438 #endif |
|
|
1439 } |
|
|
1440 |
|
|
1441 if (*arg == '\0') |
|
|
1442 break; |
|
|
1443 if (*arg == ' ' || *arg == '\t') { |
|
|
1444 arg += strspn(arg, DCC_WHITESPACE); |
|
|
1445 } else { |
|
|
1446 return -1; |
|
|
1447 } |
|
|
1448 } |
|
|
1449 dcc_debug_ttl = new_ttl; |
|
|
1450 if (dcc_debug_ttl != 0) |
|
|
1451 set_which_map(MAP_TMP); |
|
|
1452 dcc_clnt_debug = new_debug; |
|
|
1453 if (dcc_clnt_debug > 1) |
|
|
1454 printf(" debug on+%d\n", dcc_clnt_debug-1); |
|
|
1455 return 1; |
|
|
1456 } |
|
|
1457 |
|
|
1458 |
|
|
1459 |
|
|
1460 static int |
|
|
1461 no_fail_cmd(const char *arg UATTRIB, const CMD_TBL_ENTRY *ce UATTRIB) |
|
|
1462 { |
|
|
1463 if (!init_map(1, 1)) |
|
|
1464 return 0; |
|
|
1465 DCC_GREY2CLASS(grey_on)->fail_time= 0; |
|
|
1466 cdcc_unlock(1); |
|
|
1467 return 1; |
|
|
1468 } |
|
|
1469 |
|
|
1470 |
|
|
1471 |
|
|
1472 static int |
|
|
1473 quiet_cmd(const char *arg UATTRIB, const CMD_TBL_ENTRY *ce UATTRIB) |
|
|
1474 { |
|
|
1475 if (arg[0] == '\0') { |
|
|
1476 printf(" %s\n", quiet ? "on" : "off"); |
|
|
1477 return 1; |
|
|
1478 } else if (!CLITCMP(arg, "on")) { |
|
|
1479 quiet = 1; |
|
|
1480 return 1; |
|
|
1481 } else if (!CLITCMP(arg, "off")) { |
|
|
1482 quiet = 0; |
|
|
1483 return 1; |
|
|
1484 } |
|
|
1485 return -1; |
|
|
1486 } |
|
|
1487 |
|
|
1488 |
|
|
1489 |
|
|
1490 static int |
|
|
1491 ckludge_cmd(const char *arg UATTRIB, const CMD_TBL_ENTRY *ce UATTRIB) |
|
|
1492 { |
|
|
1493 char *p; |
|
|
1494 long l; |
|
|
1495 |
|
|
1496 if (arg[0] == '\0') { |
|
|
1497 printf(" clock kludge=%d\n", (int)clock_kludge); |
|
|
1498 return 1; |
|
|
1499 } |
|
|
1500 |
|
|
1501 l = strtol(arg, &p, 10); |
|
|
1502 if (*p != '\0') { |
|
|
1503 dcc_error_msg("invalid clock kludge \"%s\"", arg); |
|
|
1504 return -1; |
|
|
1505 } |
|
|
1506 clock_kludge = l; |
|
|
1507 return 1; |
|
|
1508 } |
|
|
1509 |
|
|
1510 |
|
|
1511 |
|
|
1512 static int |
|
|
1513 delete_cmd(const char *arg, const CMD_TBL_ENTRY *ce UATTRIB) |
|
|
1514 { |
|
|
1515 DCC_SRVR_CLASS *class; |
|
|
1516 DCC_SRVR_NM nm, *nmp; |
|
|
1517 DCC_SRVR_ADDR *addr; |
|
|
1518 u_char del_grey; |
|
|
1519 |
|
|
1520 del_grey = grey_on; |
|
|
1521 if (!dcc_parse_srvr_nm(dcc_emsg, &nm, &del_grey, arg, 0, 0)) { |
|
|
1522 dcc_error_msg("%s", dcc_emsg); |
|
|
1523 return 0; |
|
|
1524 } |
|
|
1525 |
|
|
1526 /* map and lock */ |
|
|
1527 set_which_map(MAP_INFO); |
|
|
1528 if (!init_map(1, 1)) |
|
|
1529 return 0; |
|
|
1530 |
|
|
1531 class = DCC_GREY2CLASS(del_grey); |
|
|
1532 for (nmp = class->nms; nmp <= LAST(class->nms); ++nmp) { |
|
|
1533 if (strcasecmp(nmp->hostname, nm.hostname) |
|
|
1534 || nmp->port != nm.port) |
|
|
1535 continue; |
|
|
1536 |
|
|
1537 /* Found it. */ |
|
|
1538 |
|
|
1539 /* zap its IP addresses so they won't be used |
|
|
1540 * if resolving the remaining names fails */ |
|
|
1541 for (addr = class->addrs; addr <= LAST(class->addrs); ++addr) { |
|
|
1542 if (addr->nam_inx == nmp - class->nms) { |
|
|
1543 addr->rtt = DCC_RTT_BAD; |
|
|
1544 addr->nam_inx = NO_NAM; |
|
|
1545 } |
|
|
1546 } |
|
|
1547 if (nmp != LAST(class->nms)) |
|
|
1548 memmove(nmp, nmp+1, |
|
|
1549 (LAST(class->nms) - nmp)*sizeof(*nmp)); |
|
|
1550 memset(LAST(class->nms), 0, sizeof(*nmp)); |
|
|
1551 ++class->gen; |
|
|
1552 fix_info(class); |
|
|
1553 return 1; |
|
|
1554 } |
|
|
1555 |
|
|
1556 dcc_error_msg("server \"%s,%d\" not found", |
|
|
1557 nm.hostname, ntohs(nm.port)); |
|
|
1558 cdcc_unlock(1); |
|
|
1559 return 0; |
|
|
1560 } |
|
|
1561 |
|
|
1562 |
|
|
1563 |
|
|
1564 static int |
|
|
1565 add_cmd(const char *arg, const CMD_TBL_ENTRY *ce UATTRIB) |
|
|
1566 { |
|
|
1567 DCC_SRVR_CLASS *class; |
|
|
1568 DCC_SRVR_NM nm, *nmp, *tgt_nmp; |
|
|
1569 u_char add_grey; |
|
|
1570 |
|
|
1571 add_grey = grey_set && grey_on; |
|
|
1572 |
|
|
1573 if (0 >= dcc_parse_srvr_nm(dcc_emsg, &nm, &add_grey, arg, 0, 0)) { |
|
|
1574 dcc_error_msg("%s", dcc_emsg); |
|
|
1575 return 0; |
|
|
1576 } |
|
|
1577 if (nm.clnt_id == DCC_ID_ANON && add_grey) { |
|
|
1578 dcc_error_msg("anonymous client-ID invalid" |
|
|
1579 " for Greylist server %s", |
|
|
1580 nm.hostname); |
|
|
1581 return 0; |
|
|
1582 } |
|
|
1583 |
|
|
1584 /* map and lock the information */ |
|
|
1585 set_which_map(MAP_INFO); |
|
|
1586 if (!init_map(1, 1)) |
|
|
1587 return 0; |
|
|
1588 |
|
|
1589 /* look for the old entry or a new, free entry */ |
|
|
1590 class = DCC_GREY2CLASS(add_grey); |
|
|
1591 tgt_nmp = 0; |
|
|
1592 for (nmp = class->nms; nmp <= LAST(class->nms); ++nmp) { |
|
|
1593 if (nmp->hostname[0] == '\0') { |
|
|
1594 if (!tgt_nmp) |
|
|
1595 tgt_nmp = nmp; |
|
|
1596 continue; |
|
|
1597 } |
|
|
1598 if (!strcmp(nmp->hostname, nm.hostname) |
|
|
1599 && nmp->port == nm.port) { |
|
|
1600 printf(" overwriting existing entry\n"); |
|
|
1601 tgt_nmp = nmp; |
|
|
1602 break; |
|
|
1603 } |
|
|
1604 } |
|
|
1605 |
|
|
1606 if (tgt_nmp) { |
|
|
1607 memcpy(tgt_nmp, &nm, sizeof(*tgt_nmp)); |
|
|
1608 fix_info(class); |
|
|
1609 return 1; |
|
|
1610 } |
|
|
1611 |
|
|
1612 cdcc_unlock(1); |
|
|
1613 if (add_grey) |
|
|
1614 dcc_error_msg("too many Greylist server names"); |
|
|
1615 else |
|
|
1616 dcc_error_msg("too many DCC server names"); |
|
|
1617 return 0; |
|
|
1618 } |
|
|
1619 |
|
|
1620 |
|
|
1621 |
|
|
1622 static void |
|
|
1623 add_new_nms(const DCC_SRVR_NM new_nms[DCC_MAX_SRVR_NMS], |
|
|
1624 DCC_SRVR_NM old_nms[DCC_MAX_SRVR_NMS]) |
|
|
1625 { |
|
|
1626 const DCC_SRVR_NM *new_nmp; |
|
|
1627 DCC_SRVR_NM *old_nmp; |
|
|
1628 |
|
|
1629 for (new_nmp = new_nms; |
|
|
1630 new_nmp < &new_nms[DCC_MAX_SRVR_NMS] |
|
|
1631 && new_nmp->hostname[0] != '\0'; |
|
|
1632 ++new_nmp) { |
|
|
1633 for (old_nmp = old_nms; |
|
|
1634 old_nmp <= &old_nms[DCC_MAX_SRVR_NMS]; |
|
|
1635 ++old_nmp) { |
|
|
1636 if (old_nmp->hostname[0] == '\0' |
|
|
1637 || (!strcmp(old_nmp->hostname, new_nmp->hostname) |
|
|
1638 && old_nmp->port == new_nmp->port)) { |
|
|
1639 memcpy(old_nmp, new_nmp, sizeof(*old_nmp)); |
|
|
1640 break; |
|
|
1641 } |
|
|
1642 } |
|
|
1643 } |
|
|
1644 } |
|
|
1645 |
|
|
1646 |
|
|
1647 |
|
|
1648 static int |
|
|
1649 load_cmd(const char *lfile, const CMD_TBL_ENTRY *ce UATTRIB) |
|
|
1650 { |
|
|
1651 u_char new_info_flags, load_grey; |
|
|
1652 int flags_set; |
|
|
1653 DCC_SRVR_NM new_nm; |
|
|
1654 DCC_SRVR_NM dcc_nms[DCC_MAX_SRVR_NMS]; |
|
|
1655 int num_dcc_nms; |
|
|
1656 DCC_SRVR_NM grey_nms[DCC_MAX_SRVR_NMS]; |
|
|
1657 int num_grey_nms; |
|
|
1658 char src_addr[INET6_ADDRSTRLEN+1]; |
|
|
1659 char buf[sizeof(DCC_SRVR_NM)*3]; |
|
|
1660 DCC_IP new_src; |
|
|
1661 const char *bufp, *cp; |
|
|
1662 FILE *f; |
|
|
1663 int fd, lno; |
|
|
1664 |
|
|
1665 if (*lfile == '\0') |
|
|
1666 return -1; |
|
|
1667 |
|
|
1668 dcc_rel_priv(); |
|
|
1669 if (!strcmp(lfile,"-")) { |
|
|
1670 lfile = 0; |
|
|
1671 fd = dup(fileno(stdin)); |
|
|
1672 if (fd < 0) { |
|
|
1673 dcc_error_msg("dup(stdin): %s", ERROR_STR()); |
|
|
1674 return 0; |
|
|
1675 } |
|
|
1676 f = fdopen(fd, "r"); |
|
|
1677 if (!f) { |
|
|
1678 dcc_error_msg("fdopen(): %s", ERROR_STR()); |
|
|
1679 return 0; |
|
|
1680 } |
|
|
1681 } else { |
|
|
1682 f = dcc_open_srvr_nm(dcc_emsg, lfile); |
|
|
1683 if (!f) { |
|
|
1684 dcc_error_msg("%s", dcc_emsg); |
|
|
1685 return 0; |
|
|
1686 } |
|
|
1687 } |
|
|
1688 |
|
|
1689 /* parse the text file to create a pair of lists of server names */ |
|
|
1690 flags_set = 0; |
|
|
1691 new_info_flags = info_flags; |
|
|
1692 num_dcc_nms = 0; |
|
|
1693 memset(dcc_nms, 0, sizeof(dcc_nms)); |
|
|
1694 num_grey_nms = 0; |
|
|
1695 memset(grey_nms, 0, sizeof(grey_nms)); |
|
|
1696 memset(&new_src, 0, sizeof(new_src)); |
|
|
1697 lno = 0; |
|
|
1698 for (;;) { |
|
|
1699 bufp = fgets(buf, sizeof(buf), f); |
|
|
1700 if (!bufp) { |
|
|
1701 if (ferror(f)) { |
|
|
1702 dcc_error_msg("fgets(%s): %s", |
|
|
1703 !lfile |
|
|
1704 ? "STDIN" |
|
|
1705 : fnm2abs_err(0, lfile), |
|
|
1706 ERROR_STR()); |
|
|
1707 fclose(f); |
|
|
1708 return 0; |
|
|
1709 } |
|
|
1710 break; |
|
|
1711 } |
|
|
1712 |
|
|
1713 ++lno; |
|
|
1714 |
|
|
1715 /* skip blank lines and comments */ |
|
|
1716 bufp += strspn(bufp, DCC_WHITESPACE); |
|
|
1717 if (*bufp == '\0' || *bufp == '#') |
|
|
1718 continue; |
|
|
1719 |
|
|
1720 /* look for flags in the first non-comment line */ |
|
|
1721 if (!flags_set++) { |
|
|
1722 cp = bufp; |
|
|
1723 if (!CLITCMP(cp, DCC_INFO_USE_IPV4)) { |
|
|
1724 cp += LITZ(DCC_INFO_USE_IPV4); |
|
|
1725 new_info_flags &= ~DCC_INFO_FG_IPV6; |
|
|
1726 } else if (!CLITCMP(cp, DCC_INFO_USE_IPV6)) { |
|
|
1727 cp += LITZ(DCC_INFO_USE_IPV6); |
|
|
1728 new_info_flags |= DCC_INFO_FG_IPV6; |
|
|
1729 } else { |
|
|
1730 ++flags_set; |
|
|
1731 } |
|
|
1732 if (flags_set == 1) { |
|
|
1733 /* We found "IPv6 on" or "off". |
|
|
1734 * Look for "use SOCKS" and "src=x.y.z.w" */ |
|
|
1735 cp += strspn(cp, DCC_WHITESPACE); |
|
|
1736 if (!CLITCMP(cp, DCC_INFO_USE_SOCKS)) { |
|
|
1737 new_info_flags |= DCC_INFO_FG_SOCKS; |
|
|
1738 cp += LITZ(DCC_INFO_USE_SOCKS); |
|
|
1739 cp += strspn(cp, DCC_WHITESPACE); |
|
|
1740 } |
|
|
1741 if (!CLITCMP(cp, DCC_INFO_USE_SRC)) { |
|
|
1742 cp += LITZ(DCC_INFO_USE_SRC); |
|
|
1743 cp = dcc_parse_word(dcc_emsg, |
|
|
1744 src_addr, |
|
|
1745 sizeof(src_addr), |
|
|
1746 cp, 0, 0, 0); |
|
|
1747 if (!cp) { |
|
|
1748 dcc_error_msg("%s", dcc_emsg); |
|
|
1749 continue; |
|
|
1750 } |
|
|
1751 if (!CLITCMP(cp, DCC_INFO_USE_SRCBAD)) { |
|
|
1752 cp += LITZ(DCC_INFO_USE_SRCBAD); |
|
|
1753 cp += strspn(cp, DCC_WHITESPACE); |
|
|
1754 } |
|
|
1755 ck_new_src(&new_src, src_addr, |
|
|
1756 (new_info_flags |
|
|
1757 & DCC_INFO_FG_SOCKS)); |
|
|
1758 } |
|
|
1759 } |
|
|
1760 if (*cp == '\0') |
|
|
1761 continue; |
|
|
1762 /* the first non-comment line must be a server name */ |
|
|
1763 } |
|
|
1764 |
|
|
1765 load_grey = 0; |
|
|
1766 if (0 >= dcc_parse_srvr_nm(dcc_emsg, &new_nm, &load_grey, |
|
|
1767 bufp, lfile, lno)) { |
|
|
1768 dcc_error_msg("%s", dcc_emsg); |
|
|
1769 fclose(f); |
|
|
1770 return 0; |
|
|
1771 } |
|
|
1772 if (load_grey) { |
|
|
1773 if (new_nm.clnt_id == DCC_ID_ANON) { |
|
|
1774 dcc_error_msg("anonymous client-ID invalid" |
|
|
1775 " for Greylist server %s%s", |
|
|
1776 new_nm.hostname, |
|
|
1777 fnm_lno(&fnm_buf, lfile, lno)); |
|
|
1778 fclose(f); |
|
|
1779 return 0; |
|
|
1780 } |
|
|
1781 if (num_grey_nms >= DIM(grey_nms)) { |
|
|
1782 dcc_error_msg("too many Greylist server names" |
|
|
1783 "%s", |
|
|
1784 fnm_lno(&fnm_buf, lfile, lno)); |
|
|
1785 fclose(f); |
|
|
1786 return 0; |
|
|
1787 } |
|
|
1788 grey_nms[num_grey_nms++] = new_nm; |
|
|
1789 } else { |
|
|
1790 if (num_dcc_nms >= DIM(dcc_nms)) { |
|
|
1791 dcc_error_msg("too many DCC server names%s", |
|
|
1792 fnm_lno(&fnm_buf, lfile, lno)); |
|
|
1793 fclose(f); |
|
|
1794 return 0; |
|
|
1795 } |
|
|
1796 dcc_nms[num_dcc_nms++] = new_nm; |
|
|
1797 } |
|
|
1798 } |
|
|
1799 fclose(f); |
|
|
1800 if (num_grey_nms == 0 && num_dcc_nms == 0) { |
|
|
1801 dcc_error_msg("no DCC server names%s", |
|
|
1802 fnm_lno(&fnm_buf, lfile, lno)); |
|
|
1803 return 0; |
|
|
1804 } |
|
|
1805 |
|
|
1806 /* create the map, without set-UID powers to prevent games, |
|
|
1807 * and then lock, install, and unlock the information */ |
|
|
1808 dcc_rel_priv(); |
|
|
1809 |
|
|
1810 if (which_map != MAP_INFO) |
|
|
1811 set_which_map(MAP_INFO); |
|
|
1812 if (!init_map(0, 1)) { |
|
|
1813 /* create a new map */ |
|
|
1814 if (!dcc_create_map(0, info_map_nm, 0, |
|
|
1815 0, 0, 0, 0, &new_src, new_info_flags)) |
|
|
1816 return 0; |
|
|
1817 printf(" created %s\n", fnm2abs_err(0, info_map_nm)); |
|
|
1818 if (!init_map(1, 1)) |
|
|
1819 return 0; |
|
|
1820 } |
|
|
1821 |
|
|
1822 /* merge the old and new entries */ |
|
|
1823 add_new_nms(grey_nms, dcc_clnt_info->grey.nms); |
|
|
1824 add_new_nms(dcc_nms, dcc_clnt_info->dcc.nms); |
|
|
1825 dcc_clnt_info->flags = info_flags = new_info_flags; |
|
|
1826 if (new_src.family != AF_UNSPEC) |
|
|
1827 dcc_clnt_info->src = new_src; |
|
|
1828 |
|
|
1829 fix_info(0); |
|
|
1830 |
|
|
1831 if (!quiet) { |
|
|
1832 if (!lfile) |
|
|
1833 printf("##################\n\n"); |
|
|
1834 return info_work("", DCC_CLNT_FG_BAD_SRVR_OK) ; |
|
|
1835 } |
|
|
1836 return 1; |
|
|
1837 } |
|
|
1838 |
|
|
1839 |
|
|
1840 |
|
|
1841 static int |
|
|
1842 info_cmd(const char *arg, const CMD_TBL_ENTRY *ce UATTRIB) |
|
|
1843 { |
|
|
1844 /* map, copy, and unlock the information |
|
|
1845 * prefer to talk to the server, but don't wait |
|
|
1846 * unless we have changed the file */ |
|
|
1847 return info_work(arg, |
|
|
1848 map_changed |
|
|
1849 ? DCC_CLNT_FG_BAD_SRVR_OK |
|
|
1850 : (DCC_CLNT_FG_NO_PICK_SRVR |
|
|
1851 | DCC_CLNT_FG_BAD_SRVR_OK)); |
|
|
1852 } |
|
|
1853 |
|
|
1854 |
|
|
1855 |
|
|
1856 static int |
|
|
1857 rtt_cmd(const char *arg, const CMD_TBL_ENTRY *ce UATTRIB) |
|
|
1858 { |
|
|
1859 if (!init_map(1, 1)) |
|
|
1860 return 0; |
|
|
1861 dcc_force_measure_rtt(&dcc_clnt_info->dcc); |
|
|
1862 dcc_force_measure_rtt(&dcc_clnt_info->grey); |
|
|
1863 cdcc_unlock(1); |
|
|
1864 |
|
|
1865 /* wait to talk to the server, but don't insist */ |
|
|
1866 return info_work(arg, quiet ? DCC_CLNT_FG_BAD_SRVR_OK : 0); |
|
|
1867 } |
|
|
1868 |
|
|
1869 |
|
|
1870 /* delete a checksum */ |
|
|
1871 static int /* 1=ok, 0=bad checksum, -1=fatal */ |
|
|
1872 delck_sub(DCC_EMSG emsg, DCC_WF *wf UATTRIB, |
|
|
1873 DCC_CK_TYPES type, DCC_SUM sum, DCC_TGTS tgts UATTRIB) |
|
|
1874 { |
|
|
1875 struct timeval cmd_start, cmd_end; |
|
|
1876 char type_buf[DCC_XHDR_MAX_TYPE_LEN]; |
|
|
1877 char ck_buf[sizeof(DCC_SUM)*3+2]; |
|
|
1878 DCC_DELETE del; |
|
|
1879 DCC_OP_RESP resp; |
|
|
1880 char ob[DCC_OPBUF]; |
|
|
1881 u_char result; |
|
|
1882 |
|
|
1883 printf(" deleting %s %s\n", |
|
|
1884 dcc_type2str(type_buf, sizeof(type_buf), type, 0, 1, grey_on), |
|
|
1885 dcc_ck2str(ck_buf, sizeof(ck_buf), type, sum, 0)); |
|
|
1886 |
|
|
1887 memset(&del, 0, sizeof(del)); |
|
|
1888 gettimeofday(&cmd_start, 0); |
|
|
1889 del.date = htonl(cmd_start.tv_sec); |
|
|
1890 del.ck.type = type; |
|
|
1891 del.ck.len = sizeof(del.ck); |
|
|
1892 memcpy(&del.ck.sum, sum, sizeof(DCC_SUM)); |
|
|
1893 result = dcc_clnt_op(emsg, ctxt, DCC_CLNT_FG_NO_FAIL, |
|
|
1894 0, 0, 0, &del.hdr, sizeof(del), |
|
|
1895 DCC_OP_DELETE, &resp, sizeof(resp)); |
|
|
1896 gettimeofday(&cmd_end, 0); |
|
|
1897 if (!result) { |
|
|
1898 dcc_error_msg("%s", dcc_emsg); |
|
|
1899 } else { |
|
|
1900 switch (resp.hdr.op) { |
|
|
1901 case DCC_OP_OK: |
|
|
1902 break; |
|
|
1903 |
|
|
1904 case DCC_OP_ERROR: |
|
|
1905 dcc_error_msg(" %.*s", |
|
|
1906 (ntohs(resp.hdr.len) |
|
|
1907 -(int)(sizeof(resp.error) |
|
|
1908 - sizeof(resp.error.msg))), |
|
|
1909 resp.error.msg); |
|
|
1910 result = 0; |
|
|
1911 break; |
|
|
1912 |
|
|
1913 default: |
|
|
1914 dcc_error_msg("unexpected response: %s", |
|
|
1915 dcc_hdr_op2str(ob,sizeof(ob), &resp.hdr)); |
|
|
1916 result = 0; |
|
|
1917 break; |
|
|
1918 } |
|
|
1919 } |
|
|
1920 |
|
|
1921 if (dcc_clnt_debug) { |
|
|
1922 printf("%.2f ms\n", |
|
|
1923 ((cmd_end.tv_sec-cmd_start.tv_sec)*1000.0 |
|
|
1924 + (cmd_end.tv_usec-cmd_start.tv_usec)/1000.0)); |
|
|
1925 } |
|
|
1926 return result; |
|
|
1927 } |
|
|
1928 |
|
|
1929 |
|
|
1930 |
|
|
1931 /* delete a simple checksum */ |
|
|
1932 static int |
|
|
1933 delck_cmd(const char *arg, const CMD_TBL_ENTRY *ce UATTRIB) |
|
|
1934 { |
|
|
1935 char type_str[DCC_XHDR_MAX_TYPE_LEN+1]; |
|
|
1936 |
|
|
1937 if (*arg == '\0') |
|
|
1938 return -1; |
|
|
1939 arg = dcc_parse_word(0, type_str, sizeof(type_str), |
|
|
1940 arg, 0, 0, 0); |
|
|
1941 if (!arg) |
|
|
1942 return -1; |
|
|
1943 |
|
|
1944 if (!rdy_ctxt(0)) |
|
|
1945 return 0; |
|
|
1946 return 0 < dcc_parse_hex_ck(0, &cmn_wf, |
|
|
1947 type_str, dcc_str2type_del(type_str, -1), |
|
|
1948 arg, 0, delck_sub); |
|
|
1949 } |
|
|
1950 |
|
|
1951 |
|
|
1952 |
|
|
1953 static int |
|
|
1954 sleep_cmd(const char *arg, const CMD_TBL_ENTRY *ce UATTRIB) |
|
|
1955 { |
|
|
1956 double s; |
|
|
1957 char *p; |
|
|
1958 |
|
|
1959 s = strtod(arg, &p); |
|
|
1960 if (*p != '\0' || s < 0.001 || s > 1000) |
|
|
1961 return -1; |
|
|
1962 usleep((u_int)(s*1000000.0)); |
|
|
1963 return 1; |
|
|
1964 } |
|
|
1965 |
|
|
1966 |
|
|
1967 |
|
|
1968 |
|
|
1969 static const u_char * |
|
|
1970 client_unpack4(const u_char *cp, |
|
|
1971 u_int *vp) |
|
|
1972 { |
|
|
1973 u_char c; |
|
|
1974 u_int v; |
|
|
1975 int shift; |
|
|
1976 |
|
|
1977 v = 0; |
|
|
1978 shift = 0; |
|
|
1979 do { |
|
|
1980 c = *cp++; |
|
|
1981 v |= (c & 0x7f) << shift; |
|
|
1982 shift += 7; |
|
|
1983 } while (c & 0x80); |
|
|
1984 |
|
|
1985 *vp = v; |
|
|
1986 return cp; |
|
|
1987 } |
|
|
1988 |
|
|
1989 |
|
|
1990 |
|
|
1991 static int |
|
|
1992 client_unpack(const u_char *cp0, |
|
|
1993 u_char *flagsp, |
|
|
1994 u_int *clnt_idp, |
|
|
1995 u_int *last_usedp, |
|
|
1996 u_int *requestsp, |
|
|
1997 u_int *nopsp, |
|
|
1998 u_char *versp, |
|
|
1999 DCC_SOCKU *su) |
|
|
2000 { |
|
|
2001 const u_char *cp; |
|
|
2002 u_char flags; |
|
|
2003 u_int v; |
|
|
2004 struct in6_addr in6_addr; |
|
|
2005 struct in_addr in_addr; |
|
|
2006 |
|
|
2007 #ifdef DCC_PKT_VERSION6 |
|
|
2008 if (aop_resp.hdr.pkt_vers <= DCC_PKT_VERSION6) { |
|
|
2009 #define CPY2(s) ((s[0]<<8) | s[1]) |
|
|
2010 #define CPY3(s) ((s[0]<<16) | (s[1]<<8) | s[2]) |
|
|
2011 #define CPY4(s) ((s[0]<<24) | (s[1]<<16) | (s[2]<<8) | s[3]) |
|
|
2012 const DCC_ADMN_RESP_CLIENTSv6 *cl; |
|
|
2013 |
|
|
2014 cl = (DCC_ADMN_RESP_CLIENTSv6 *)cp0; |
|
|
2015 flags = cl->flags; |
|
|
2016 *flagsp = flags & (DCC_ADMN_RESP_CLIENTS_BL |
|
|
2017 | DCC_ADMN_RESP_CLIENTS_SKIP); |
|
|
2018 *clnt_idp = CPY4(cl->clnt_id); |
|
|
2019 *last_usedp = CPY4(cl->last_used); |
|
|
2020 if (flags & DCC_ADMN_RESP_CLIENTS_SKIP) { |
|
|
2021 /* skip place keepers */ |
|
|
2022 *last_usedp = CPY3(cl->requests); |
|
|
2023 *requestsp = 0; |
|
|
2024 } else { |
|
|
2025 *requestsp = CPY3(cl->requests); |
|
|
2026 } |
|
|
2027 *nopsp = CPY2(cl->nops); |
|
|
2028 if (flags & DCC_ADMN_RESP_CLIENTS_IPV6) { |
|
|
2029 memcpy(&in6_addr, &cl->addr, sizeof(in6_addr)); |
|
|
2030 dcc_mk_su(su, AF_INET6, &in6_addr, 0); |
|
|
2031 return (sizeof(*cl) - sizeof(cl->addr) |
|
|
2032 + sizeof(cl->addr.ipv6)); |
|
|
2033 } |
|
|
2034 memcpy(&in_addr, &cl->addr, sizeof(in_addr)); |
|
|
2035 dcc_mk_su(su, AF_INET, &in_addr, 0); |
|
|
2036 return (sizeof(*cl) - sizeof(cl->addr) |
|
|
2037 + sizeof(cl->addr.ipv4)); |
|
|
2038 } |
|
|
2039 #undef CPY2 |
|
|
2040 #undef CPY3 |
|
|
2041 #undef CPY4 |
|
|
2042 #endif |
|
|
2043 |
|
|
2044 cp = cp0; |
|
|
2045 flags = *cp++; |
|
|
2046 *flagsp = flags & (DCC_ADMN_RESP_CLIENTS_BL |
|
|
2047 | DCC_ADMN_RESP_CLIENTS_BAD |
|
|
2048 | DCC_ADMN_RESP_CLIENTS_SKIP |
|
|
2049 | DCC_ADMN_RESP_CLIENTS_LAST); |
|
|
2050 /* if the version is absent, |
|
|
2051 * then it must be the same as the previous value */ |
|
|
2052 if (flags & DCC_ADMN_RESP_CLIENTS_VERS) |
|
|
2053 *versp = *cp++; |
|
|
2054 v = *cp++ << 24; |
|
|
2055 v |= *cp++ << 16; |
|
|
2056 v |= *cp++ << 8; |
|
|
2057 v |= *cp++; |
|
|
2058 *last_usedp = v; |
|
|
2059 if ((flags & DCC_ADMN_RESP_CLIENTS_ID1) != 0) |
|
|
2060 *clnt_idp = DCC_ID_ANON; |
|
|
2061 else |
|
|
2062 cp = client_unpack4(cp, clnt_idp); |
|
|
2063 cp = client_unpack4(cp, requestsp); |
|
|
2064 cp = client_unpack4(cp, nopsp); |
|
|
2065 if (flags & DCC_ADMN_RESP_CLIENTS_IPV6) { |
|
|
2066 memcpy(&in6_addr, cp, sizeof(in6_addr)); |
|
|
2067 dcc_mk_su(su, AF_INET6, &in6_addr, 0); |
|
|
2068 cp += 16; |
|
|
2069 } else { |
|
|
2070 memcpy(&in_addr, cp, sizeof(in_addr)); |
|
|
2071 dcc_mk_su(su, AF_INET, &in_addr, 0); |
|
|
2072 cp += 4; |
|
|
2073 } |
|
|
2074 return cp - cp0; |
|
|
2075 } |
|
|
2076 |
|
|
2077 |
|
|
2078 |
|
|
2079 /* get the server's list of recent clients */ |
|
|
2080 static int |
|
|
2081 clients_cmd(const char *arg, const CMD_TBL_ENTRY *ce UATTRIB) |
|
|
2082 { |
|
|
2083 u_char nonames, sort, ids, req_flags; |
|
|
2084 u_char passed_flags, passed_max_clients, passed_thold, passed_cidr; |
|
|
2085 struct in6_addr addr6; |
|
|
2086 DCC_AOP_CLIENTS_CIDR addr_bits; |
|
|
2087 u_int max_clients, thold; |
|
|
2088 u_int total, subtotal; |
|
|
2089 u_int max_ops, max_nops; |
|
|
2090 int ops_width, nops_width; |
|
|
2091 u_int offset; /* next client wanted from server */ |
|
|
2092 u_int num_clients; |
|
|
2093 DCC_SOCKU su; |
|
|
2094 struct ct { |
|
|
2095 struct ct *lt, *gt, *up; |
|
|
2096 time_t last_used; |
|
|
2097 u_int requests; |
|
|
2098 u_int nops; |
|
|
2099 u_int rank; |
|
|
2100 u_char flags; |
|
|
2101 u_char vers; |
|
|
2102 DCC_CLNT_ID clnt_id; |
|
|
2103 DCC_SOCKU su; |
|
|
2104 } *clist, **ctptr, *ctup, *ct, *ctnew; |
|
|
2105 u_int versions[DCC_PKT_VERSION_MAX+1]; |
|
|
2106 |
|
|
2107 char date_buf[40]; |
|
|
2108 struct tm last, now; |
|
|
2109 char *p; |
|
|
2110 const char *ac; |
|
|
2111 u_char need_head; |
|
|
2112 int i; |
|
|
2113 |
|
|
2114 passed_flags = 0; |
|
|
2115 thold = 0; |
|
|
2116 passed_thold = 0; |
|
|
2117 max_clients = DCC_ADMIN_RESP_MAX_CLIENTS; |
|
|
2118 passed_max_clients = 0; |
|
|
2119 passed_cidr = 0; |
|
|
2120 memset(addr_bits, 0, sizeof(addr_bits)); |
|
|
2121 |
|
|
2122 ac = strpbrk(arg, "/.:"); |
|
|
2123 |
|
|
2124 /* look for "-n", "-ns", "-n -s", etc. */ |
|
|
2125 nonames = 0; |
|
|
2126 sort = 0; |
|
|
2127 ids = 0; |
|
|
2128 req_flags = 0; |
|
|
2129 while (*arg != 0) { |
|
|
2130 arg += strspn(arg, " \t"); |
|
|
2131 if (*arg == '-' && !passed_flags) { |
|
|
2132 ++arg; |
|
|
2133 do { |
|
|
2134 switch (*arg) { |
|
|
2135 case 'n': |
|
|
2136 nonames = 1; |
|
|
2137 break; |
|
|
2138 case 's': |
|
|
2139 sort = 1; |
|
|
2140 break; |
|
|
2141 case 'i': |
|
|
2142 ids = 1; |
|
|
2143 break; |
|
|
2144 case 'a': |
|
|
2145 req_flags |= DCC_AOP_CLIENTS_AVG; |
|
|
2146 break; |
|
|
2147 case 'V': |
|
|
2148 req_flags |= DCC_AOP_CLIENTS_VERS; |
|
|
2149 break; |
|
|
2150 case 'A': |
|
|
2151 req_flags |= DCC_AOP_CLIENTS_ANON; |
|
|
2152 req_flags &= ~DCC_AOP_CLIENTS_NON_ANON; |
|
|
2153 break; |
|
|
2154 case 'K': |
|
|
2155 req_flags |= DCC_AOP_CLIENTS_NON_ANON; |
|
|
2156 req_flags &= ~DCC_AOP_CLIENTS_ANON; |
|
|
2157 break; |
|
|
2158 default: |
|
|
2159 help_cmd("clients", 0); |
|
|
2160 return -1; |
|
|
2161 } |
|
|
2162 } while (*++arg != ' ' && *arg != '\t' && *arg != '\0'); |
|
|
2163 continue; |
|
|
2164 } |
|
|
2165 if (!passed_cidr && ac && !strpbrk(arg, DCC_WHITESPACE)) { |
|
|
2166 int bits; |
|
|
2167 |
|
|
2168 bits = dcc_str2cidr(0, &addr6, 0, 0, arg, 0, 0); |
|
|
2169 if (bits <= 0) |
|
|
2170 return -1; |
|
|
2171 memcpy(addr_bits, &addr6, sizeof(addr6)); |
|
|
2172 addr_bits[sizeof(addr6)] = bits; |
|
|
2173 arg = ""; |
|
|
2174 passed_cidr = 1; |
|
|
2175 passed_flags = 1; |
|
|
2176 passed_max_clients = 1; |
|
|
2177 passed_thold = 1; |
|
|
2178 continue; |
|
|
2179 } |
|
|
2180 if (!passed_max_clients |
|
|
2181 && (i = strtoul(arg, &p, 10)) != 0 |
|
|
2182 && (*p == ' ' || *p == '\t' || *p == '\0')) { |
|
|
2183 max_clients = i; |
|
|
2184 arg = p; |
|
|
2185 passed_max_clients = 1; |
|
|
2186 passed_flags = 1; |
|
|
2187 continue; |
|
|
2188 } |
|
|
2189 if (!passed_thold |
|
|
2190 && (i = strtoul(arg, &p, 10)) > 0 |
|
|
2191 && (*p == ' ' || *p == '\t' || *p == '\0') |
|
|
2192 && i <= DCC_ADMIN_RESP_CLIENTS_MAX_THOLD) { |
|
|
2193 thold = i; |
|
|
2194 arg = p; |
|
|
2195 passed_thold = 1; |
|
|
2196 passed_max_clients = 1; |
|
|
2197 passed_flags = 1; |
|
|
2198 continue; |
|
|
2199 } |
|
|
2200 help_cmd("clients", 0); |
|
|
2201 return -1; |
|
|
2202 } |
|
|
2203 |
|
|
2204 if (ids) |
|
|
2205 req_flags &= ~DCC_AOP_CLIENTS_VERS; |
|
|
2206 |
|
|
2207 /* Require a server password for client IP addresses |
|
|
2208 * The server demands only client ID for "clients -i" */ |
|
|
2209 if (!ids |
|
|
2210 && !ck_cmd_priv(ce, 1, 0)) |
|
|
2211 return 0; |
|
|
2212 |
|
|
2213 if (!rdy_ctxt(0)) |
|
|
2214 return 0; |
|
|
2215 |
|
|
2216 /* Collect all of the information before printing it to minimize |
|
|
2217 * the changes in the position of hosts and so deleted or missing |
|
|
2218 * entries. */ |
|
|
2219 total = 0; |
|
|
2220 subtotal = 0; |
|
|
2221 max_ops = 0; |
|
|
2222 max_nops = 0; |
|
|
2223 memset(versions, 0, sizeof(versions)); |
|
|
2224 offset = 0; |
|
|
2225 num_clients = 0; |
|
|
2226 clist = 0; |
|
|
2227 for (;;) { |
|
|
2228 DCC_OPS result; |
|
|
2229 int len, result_len; |
|
|
2230 u_char vers, result_flags; |
|
|
2231 # define BL_FLAGS (DCC_ADMN_RESP_CLIENTS_BL | DCC_ADMN_RESP_CLIENTS_BAD) |
|
|
2232 u_int clnt_id, last_used, requests, nops; |
|
|
2233 |
|
|
2234 if (offset > DCC_AOP_CLIENTS_MAX_OFFSET) { |
|
|
2235 dcc_error_msg("%d are too many clients", offset); |
|
|
2236 break; |
|
|
2237 } |
|
|
2238 |
|
|
2239 gettimeofday(&op_start, 0); |
|
|
2240 result = dcc_aop(dcc_emsg, ctxt, grey_on ? DCC_CLNT_FG_GREY : 0, |
|
|
2241 NO_SRVR, clock_kludge, |
|
|
2242 ids ? DCC_AOP_CLIENTS_ID : DCC_AOP_CLIENTS, |
|
|
2243 (offset << 16) |
|
|
2244 + min(thold, |
|
|
2245 DCC_ADMIN_RESP_CLIENTS_MAX_THOLD), |
|
|
2246 ISZ(aop_resp.resp.val.string |
|
|
2247 ) >> DCC_ADMIN_RESP_CLIENTS_SHIFT, |
|
|
2248 req_flags, |
|
|
2249 offset >> 16, |
|
|
2250 addr_bits, passed_cidr ? sizeof(addr_bits) : 0, |
|
|
2251 &aop_resp, &op_result_su); |
|
|
2252 if (result == DCC_OP_INVALID |
|
|
2253 || result == DCC_OP_ERROR) { |
|
|
2254 dcc_error_msg("%s", dcc_emsg); |
|
|
2255 break; |
|
|
2256 } |
|
|
2257 |
|
|
2258 /* print heading before the first chunk */ |
|
|
2259 if (!offset) |
|
|
2260 print_aop(-1); |
|
|
2261 |
|
|
2262 result_len = (ntohs(aop_resp.hdr.len) |
|
|
2263 - (sizeof(aop_resp.resp) |
|
|
2264 - sizeof(aop_resp.resp.val.string))); |
|
|
2265 /* stop when the server has nothing to add */ |
|
|
2266 if (result_len <= 1) |
|
|
2267 break; |
|
|
2268 |
|
|
2269 len = 0; |
|
|
2270 vers = 0; |
|
|
2271 do { |
|
|
2272 len += client_unpack(&aop_resp.resp.val.clients[len], |
|
|
2273 &result_flags, &clnt_id, |
|
|
2274 &last_used, |
|
|
2275 &requests, &nops, &vers, |
|
|
2276 &su); |
|
|
2277 if (result_flags & DCC_ADMN_RESP_CLIENTS_SKIP) { |
|
|
2278 offset += last_used; |
|
|
2279 continue; |
|
|
2280 } |
|
|
2281 |
|
|
2282 if (vers != 0) { |
|
|
2283 if (vers < DIM(versions)) |
|
|
2284 versions[vers] += requests; |
|
|
2285 else |
|
|
2286 versions[0] += requests; |
|
|
2287 } |
|
|
2288 |
|
|
2289 |
|
|
2290 /* quit if we are in some kind of loop */ |
|
|
2291 if (++num_clients > DCC_ADMIN_RESP_MAX_CLIENTS) |
|
|
2292 goto stop; |
|
|
2293 ++offset; |
|
|
2294 |
|
|
2295 /* add the new entry to the possibly sorted list */ |
|
|
2296 |
|
|
2297 ctnew = dcc_malloc(sizeof(*ctnew)); |
|
|
2298 memset(ctnew, 0, sizeof(*ctnew)); |
|
|
2299 ctnew->flags = (result_flags & BL_FLAGS ); |
|
|
2300 ctnew->vers = vers; |
|
|
2301 ctnew->clnt_id = clnt_id; |
|
|
2302 ctnew->last_used = last_used; |
|
|
2303 ctnew->requests = requests; |
|
|
2304 if (max_ops < requests) |
|
|
2305 max_ops = requests; |
|
|
2306 total += requests; |
|
|
2307 ctnew->nops = nops; |
|
|
2308 if (max_nops < nops) |
|
|
2309 max_nops = nops; |
|
|
2310 ctnew->su = su; |
|
|
2311 |
|
|
2312 ctptr = &clist; |
|
|
2313 ctup = 0; |
|
|
2314 for (;;) { |
|
|
2315 ct = *ctptr; |
|
|
2316 if (!ct) { |
|
|
2317 ctnew->up = ctup; |
|
|
2318 *ctptr = ctnew; |
|
|
2319 break; |
|
|
2320 } |
|
|
2321 i = !sort; |
|
|
2322 if (!i) { |
|
|
2323 i = (0!= (ct->flags & BL_FLAGS)); |
|
|
2324 i -= (0 != (ctnew->flags & BL_FLAGS)); |
|
|
2325 } |
|
|
2326 if (!i) { |
|
|
2327 i = ct->requests; |
|
|
2328 i -= ctnew->requests; |
|
|
2329 } |
|
|
2330 ctup = ct; |
|
|
2331 if (i >= 0) { |
|
|
2332 ctptr = &ct->lt; |
|
|
2333 } else { |
|
|
2334 /* update the threshold if sorting */ |
|
|
2335 if (++ct->rank >= max_clients |
|
|
2336 && thold < ct->requests) { |
|
|
2337 thold = ct->requests; |
|
|
2338 } |
|
|
2339 ctptr = &ct->gt; |
|
|
2340 } |
|
|
2341 } |
|
|
2342 } while (len < result_len); |
|
|
2343 if (len != result_len) { |
|
|
2344 dcc_error_msg("wrong sized clients response; %d != %d", |
|
|
2345 result_len, len); |
|
|
2346 break; |
|
|
2347 } |
|
|
2348 |
|
|
2349 /* quit if the server ran out of things to say */ |
|
|
2350 if (result_flags & DCC_ADMN_RESP_CLIENTS_LAST) |
|
|
2351 break; |
|
|
2352 |
|
|
2353 /* Quit if we want only part of the list and we have it. |
|
|
2354 * We must get everything the server sends if we are sorting. |
|
|
2355 * The server uses our threshold to avoid sending everything |
|
|
2356 * it know. */ |
|
|
2357 if (!sort && offset >= max_clients) |
|
|
2358 break; |
|
|
2359 #undef BL_FLAGS |
|
|
2360 } |
|
|
2361 stop: |
|
|
2362 if (!total) |
|
|
2363 total = 1; |
|
|
2364 |
|
|
2365 dcc_localtime(time(0), &now); |
|
|
2366 |
|
|
2367 if (max_ops > 99*1000*1000) |
|
|
2368 ops_width = 9; |
|
|
2369 else if (max_ops > 9*1000*1000) |
|
|
2370 ops_width = 8; |
|
|
2371 else |
|
|
2372 ops_width = 7; |
|
|
2373 if (max_nops > 99*1000) |
|
|
2374 nops_width = 6; |
|
|
2375 else if (max_nops > 9*1000) |
|
|
2376 nops_width = 5; |
|
|
2377 else |
|
|
2378 nops_width = 4; |
|
|
2379 |
|
|
2380 /* print the list */ |
|
|
2381 num_clients = 0; |
|
|
2382 for (ct = clist; ct; ct = ctnew) { |
|
|
2383 ctnew = ct->gt; |
|
|
2384 if (ctnew) { |
|
|
2385 ct->gt = 0; |
|
|
2386 continue; |
|
|
2387 } |
|
|
2388 |
|
|
2389 if (num_clients == 0) { |
|
|
2390 if (sort) { |
|
|
2391 printf(" %*s %*s ", |
|
|
2392 ops_width, "ops", |
|
|
2393 nops_width, "nops"); |
|
|
2394 if (ids) |
|
|
2395 fputs(" ID ", stdout); |
|
|
2396 fputs(" last ", stdout); |
|
|
2397 if (req_flags & DCC_AOP_CLIENTS_VERS) |
|
|
2398 fputs(" v", stdout); |
|
|
2399 } else { |
|
|
2400 printf("%*s %*s last ID ", |
|
|
2401 ops_width, "ops", |
|
|
2402 nops_width, "nops"); |
|
|
2403 if (req_flags & DCC_AOP_CLIENTS_VERS) |
|
|
2404 fputs(" v", stdout); |
|
|
2405 } |
|
|
2406 putchar('\n'); |
|
|
2407 } |
|
|
2408 if (++num_clients <= max_clients) { |
|
|
2409 if (sort) { |
|
|
2410 subtotal += ct->requests; |
|
|
2411 printf("%3d%% %3d%% ", |
|
|
2412 (int)(ct->requests*100.0/total), |
|
|
2413 (int)(subtotal*100.0/total)); |
|
|
2414 } |
|
|
2415 printf("%*d %*d", |
|
|
2416 ops_width, ct->requests, |
|
|
2417 nops_width, ct->nops); |
|
|
2418 if (sort && ids) |
|
|
2419 printf(" %6d", ct->clnt_id); |
|
|
2420 /* print year and no time if it was long ago */ |
|
|
2421 dcc_localtime(ct->last_used, &last); |
|
|
2422 printf(" %s", dcc_time2str(date_buf, sizeof(date_buf), |
|
|
2423 (last.tm_year != now.tm_year |
|
|
2424 && (last.tm_mon < 6 |
|
|
2425 || now.tm_mon > 2)) |
|
|
2426 ? "%Y/%m/%d" : "%m/%d %X", |
|
|
2427 ct->last_used)); |
|
|
2428 if (!sort) |
|
|
2429 printf(" %6d", ct->clnt_id); |
|
|
2430 if (req_flags & DCC_AOP_CLIENTS_VERS) { |
|
|
2431 if (ct->vers != 0) |
|
|
2432 printf(" %d", ct->vers); |
|
|
2433 else |
|
|
2434 fputs(" ?", stdout); |
|
|
2435 } |
|
|
2436 if (ct->flags & DCC_ADMN_RESP_CLIENTS_BL) |
|
|
2437 fputs(" BLACKLIST", stdout); |
|
|
2438 else if (ct->flags & DCC_ADMN_RESP_CLIENTS_BAD) |
|
|
2439 fputs(" BAD", stdout); |
|
|
2440 if (!ids) { |
|
|
2441 char name[DCC_MAXDOMAINLEN]; |
|
|
2442 char sustr[DCC_SU2STR_SIZE]; |
|
|
2443 |
|
|
2444 if (nonames) { |
|
|
2445 printf(" %s", |
|
|
2446 dcc_su2str2(sustr, sizeof(sustr), |
|
|
2447 &ct->su)); |
|
|
2448 } else { |
|
|
2449 printf(" %-16s %s", |
|
|
2450 dcc_su2str2(sustr, sizeof(sustr), |
|
|
2451 &ct->su), |
|
|
2452 dcc_su2name(name, sizeof(name), |
|
|
2453 &ct->su)); |
|
|
2454 } |
|
|
2455 } |
|
|
2456 putchar('\n'); |
|
|
2457 |
|
|
2458 ctnew = ct->lt; |
|
|
2459 if (!ctnew) { |
|
|
2460 ctnew = ct->up; |
|
|
2461 } else { |
|
|
2462 ctnew->up = ct->up; |
|
|
2463 } |
|
|
2464 } |
|
|
2465 |
|
|
2466 memset(ct, 0, sizeof(*ct)); |
|
|
2467 dcc_free(ct); |
|
|
2468 } |
|
|
2469 putchar('\n'); |
|
|
2470 |
|
|
2471 |
|
|
2472 need_head = 1; |
|
|
2473 for (i = 0; i < DIM(versions); ++i) { |
|
|
2474 if (versions[i] == 0) |
|
|
2475 continue; |
|
|
2476 if (need_head) { |
|
|
2477 need_head = 0; |
|
|
2478 fputs("version total\n", stdout); |
|
|
2479 } |
|
|
2480 printf("%6d %8d\n", i, versions[i]); |
|
|
2481 } |
|
|
2482 |
|
|
2483 return 1; |
|
|
2484 } |
|
|
2485 |
|
|
2486 |
|
|
2487 |
|
|
2488 /* get and set the server's default anonymous client delay */ |
|
|
2489 static int |
|
|
2490 anon_cmd(const char *arg, const CMD_TBL_ENTRY *ce UATTRIB) |
|
|
2491 { |
|
|
2492 int new_delay, old_delay, inflate; |
|
|
2493 DCC_OPS result; |
|
|
2494 char *inflate_str, *p; |
|
|
2495 |
|
|
2496 inflate = 0; |
|
|
2497 if (*arg == '\0') { |
|
|
2498 new_delay = DCC_NO_ANON_DELAY; |
|
|
2499 } else { |
|
|
2500 if (!strcasecmp(arg, "forever")) { |
|
|
2501 new_delay = DCC_ANON_DELAY_FOREVER; |
|
|
2502 } else { |
|
|
2503 new_delay = strtoul(arg, &inflate_str, 10); |
|
|
2504 if (new_delay > DCC_ANON_DELAY_MAX |
|
|
2505 || (*inflate_str != '\0' && *inflate_str != ',' |
|
|
2506 && *inflate_str != '*')) { |
|
|
2507 dcc_error_msg("invalid delay: \"%s\"", arg); |
|
|
2508 return 0; |
|
|
2509 } |
|
|
2510 if (*inflate_str != '\0') { |
|
|
2511 ++inflate_str; |
|
|
2512 inflate_str += strspn(inflate_str, |
|
|
2513 DCC_WHITESPACE); |
|
|
2514 } |
|
|
2515 if (*inflate_str != '\0' |
|
|
2516 && strcasecmp(inflate_str, "none")) { |
|
|
2517 inflate = strtoul(inflate_str, &p, 10); |
|
|
2518 if (*p != '\0') { |
|
|
2519 dcc_error_msg("invalid delay inflation:" |
|
|
2520 " \"%s\"", inflate_str); |
|
|
2521 return 0; |
|
|
2522 } |
|
|
2523 } |
|
|
2524 } |
|
|
2525 if (!ck_cmd_priv(ce, 1, 0)) |
|
|
2526 return 0; |
|
|
2527 } |
|
|
2528 |
|
|
2529 if (!rdy_ctxt(0)) |
|
|
2530 return 0; |
|
|
2531 |
|
|
2532 gettimeofday(&op_start, 0); |
|
|
2533 result = dcc_aop(dcc_emsg, ctxt, grey_on ? DCC_CLNT_FG_GREY : 0, |
|
|
2534 NO_SRVR, clock_kludge, DCC_AOP_ANON_DELAY, |
|
|
2535 inflate, new_delay>>8, new_delay, 0, 0, 0, |
|
|
2536 &aop_resp, &op_result_su); |
|
|
2537 if (result == DCC_OP_INVALID |
|
|
2538 || result == DCC_OP_ERROR) { |
|
|
2539 dcc_error_msg("%s", dcc_emsg); |
|
|
2540 return 0; |
|
|
2541 } |
|
|
2542 |
|
|
2543 old_delay = ((aop_resp.resp.val.anon_delay.delay[0]<<8) |
|
|
2544 + aop_resp.resp.val.anon_delay.delay[1]); |
|
|
2545 if (old_delay == DCC_ANON_DELAY_FOREVER) { |
|
|
2546 printf(" anon delay %s FOREVER\n", |
|
|
2547 new_delay != DCC_NO_ANON_DELAY ? "was" : "is"); |
|
|
2548 } else { |
|
|
2549 printf(" anon delay %s %d", |
|
|
2550 new_delay != DCC_NO_ANON_DELAY ? "was" : "is", |
|
|
2551 old_delay); |
|
|
2552 inflate = ((aop_resp.resp.val.anon_delay.inflate[0]<<24) |
|
|
2553 +(aop_resp.resp.val.anon_delay.inflate[1]<<16) |
|
|
2554 +(aop_resp.resp.val.anon_delay.inflate[2]<<8) |
|
|
2555 +aop_resp.resp.val.anon_delay.inflate[3]); |
|
|
2556 if (inflate != 0) |
|
|
2557 printf(",%d", inflate); |
|
|
2558 putchar('\n'); |
|
|
2559 } |
|
|
2560 return 1; |
|
|
2561 } |
|
|
2562 |
|
|
2563 |
|
|
2564 |
|
|
2565 /* rewind the flood from a single server */ |
|
|
2566 static int |
|
|
2567 flod_rewind(const char *arg UATTRIB, const CMD_TBL_ENTRY *ce UATTRIB) |
|
|
2568 { |
|
|
2569 DCC_CLNT_ID id; |
|
|
2570 |
|
|
2571 if (!arg) |
|
|
2572 return -1; |
|
|
2573 id = dcc_get_id(0, arg, 0, 0); |
|
|
2574 if (id == DCC_ID_INVALID) |
|
|
2575 return -1; |
|
|
2576 |
|
|
2577 return do_aop(DCC_AOP_FLOD, id*256 + DCC_AOP_FLOD_REWIND, NO_SRVR, 1); |
|
|
2578 } |
|
|
2579 |
|
|
2580 |
|
|
2581 |
|
|
2582 /* fast forward the flood to a single server */ |
|
|
2583 static int |
|
|
2584 ffwd_out(const char *arg UATTRIB, const CMD_TBL_ENTRY *ce UATTRIB) |
|
|
2585 { |
|
|
2586 DCC_CLNT_ID id; |
|
|
2587 |
|
|
2588 if (!arg) |
|
|
2589 return -1; |
|
|
2590 id = dcc_get_id(0, arg, 0, 0); |
|
|
2591 if (id == DCC_ID_INVALID) |
|
|
2592 return -1; |
|
|
2593 |
|
|
2594 return do_aop(DCC_AOP_FLOD, id*256 + DCC_AOP_FLOD_FFWD_OUT, NO_SRVR, 1); |
|
|
2595 } |
|
|
2596 |
|
|
2597 |
|
|
2598 |
|
|
2599 /* fast forward the flood to a single server */ |
|
|
2600 static int |
|
|
2601 ffwd_in(const char *arg UATTRIB, const CMD_TBL_ENTRY *ce UATTRIB) |
|
|
2602 { |
|
|
2603 DCC_CLNT_ID id; |
|
|
2604 |
|
|
2605 if (!arg) |
|
|
2606 return -1; |
|
|
2607 id = dcc_get_id(0, arg, 0, 0); |
|
|
2608 if (id == DCC_ID_INVALID) |
|
|
2609 return -1; |
|
|
2610 |
|
|
2611 return do_aop(DCC_AOP_FLOD, id*256 + DCC_AOP_FLOD_FFWD_IN, NO_SRVR, 1); |
|
|
2612 } |
|
|
2613 |
|
|
2614 |
|
|
2615 |
|
|
2616 /* get the flood counts for a server */ |
|
|
2617 static int |
|
|
2618 flod_stats(const char *arg UATTRIB, const CMD_TBL_ENTRY *ce UATTRIB) |
|
|
2619 { |
|
|
2620 u_int32_t id, next_id; |
|
|
2621 DCC_AOP_FLODS op; |
|
|
2622 u_char heading; |
|
|
2623 int sresult; |
|
|
2624 |
|
|
2625 if (!arg) |
|
|
2626 return -1; |
|
|
2627 if (!CLITCMP(arg, "clear")) { |
|
|
2628 arg += LITZ("clear"); |
|
|
2629 arg += strspn(arg, DCC_WHITESPACE); |
|
|
2630 op = DCC_AOP_FLOD_STATS_CLEAR; |
|
|
2631 } else { |
|
|
2632 op = DCC_AOP_FLOD_STATS; |
|
|
2633 } |
|
|
2634 |
|
|
2635 heading = 1; |
|
|
2636 if (!strcasecmp(arg, "all")) { |
|
|
2637 id = DCC_SRVR_ID_MAX+1; |
|
|
2638 for (;;) { |
|
|
2639 if (!start_aop(DCC_AOP_FLOD, id*256 + op, NO_SRVR)) |
|
|
2640 return 0; |
|
|
2641 sresult = sscanf(aop_resp.resp.val.string, |
|
|
2642 DCC_AOP_FLOD_STATS_ID, &next_id); |
|
|
2643 if (1 == sresult |
|
|
2644 && id == next_id) { |
|
|
2645 if (id == DCC_SRVR_ID_MAX+1) { |
|
|
2646 BUFCPY(aop_resp.resp.val.string, |
|
|
2647 " (no flooding peers)"); |
|
|
2648 fin_aop(NO_SRVR, 1); |
|
|
2649 } |
|
|
2650 return 1; |
|
|
2651 } |
|
|
2652 fin_aop(NO_SRVR, heading); |
|
|
2653 heading = 0; |
|
|
2654 if (1 != sresult) |
|
|
2655 return 0; |
|
|
2656 id = next_id+DCC_SRVR_ID_MAX+1; |
|
|
2657 } |
|
|
2658 } |
|
|
2659 |
|
|
2660 id = dcc_get_id(0, arg, 0, 0); |
|
|
2661 if (id == DCC_ID_INVALID) |
|
|
2662 return -1; |
|
|
2663 return do_aop(DCC_AOP_FLOD, id*256 + op, NO_SRVR, heading); |
|
|
2664 } |
|
|
2665 |
|
|
2666 |
|
|
2667 |
|
|
2668 static const char *stats_help = ""; |
|
|
2669 |
|
|
2670 /* get the statistics from all known servers */ |
|
|
2671 static int |
|
|
2672 stats_cmd(const char *arg, const CMD_TBL_ENTRY *ce UATTRIB) |
|
|
2673 { |
|
|
2674 DCC_SRVR_CLASS *class; |
|
|
2675 SRVR_INX srvr_inx; |
|
|
2676 int srvrs_gen; |
|
|
2677 DCC_AOPS aop; |
|
|
2678 |
|
|
2679 /* look for "clear" or "all" */ |
|
|
2680 srvr_inx = NO_SRVR; |
|
|
2681 aop = DCC_AOP_STATS; |
|
|
2682 while (*arg != 0) { |
|
|
2683 arg += strspn(arg, " \t"); |
|
|
2684 if (srvr_inx == NO_SRVR |
|
|
2685 && !CLITCMP(arg, "clear")) { |
|
|
2686 arg += LITZ("clear"); |
|
|
2687 aop = DCC_AOP_STATS_CLEAR; |
|
|
2688 if (!get_passwd(aops_tbl[aop].privileged)) { |
|
|
2689 dcc_error_msg("\"stats clear\"" |
|
|
2690 " is a privileged operation" |
|
|
2691 PRV_MSG, ids_path); |
|
|
2692 return 0; |
|
|
2693 } |
|
|
2694 } else if (aop == DCC_AOP_STATS |
|
|
2695 && !CLITCMP(arg, "all")) { |
|
|
2696 arg += LITZ("all"); |
|
|
2697 srvr_inx = 0; |
|
|
2698 } |
|
|
2699 if (*arg != '\0' && *arg != ' ' && *arg != '\t') |
|
|
2700 return -1; |
|
|
2701 } |
|
|
2702 |
|
|
2703 if (!rdy_ctxt(0)) |
|
|
2704 return 0; |
|
|
2705 class = DCC_GREY2CLASS(grey_on); |
|
|
2706 srvrs_gen = class->gen; |
|
|
2707 do { |
|
|
2708 if (srvrs_gen != class->gen) { |
|
|
2709 dcc_error_msg("list of servers changed"); |
|
|
2710 return 0; |
|
|
2711 } |
|
|
2712 /* skip dead servers */ |
|
|
2713 if (srvr_inx != NO_SRVR |
|
|
2714 && class->addrs[srvr_inx].srvr_id == DCC_ID_INVALID ) |
|
|
2715 continue; |
|
|
2716 |
|
|
2717 do_aop(aop, sizeof(aop_resp.resp.val.string), srvr_inx, 1); |
|
|
2718 fflush(stderr); |
|
|
2719 fflush(stdout); |
|
|
2720 } while (srvr_inx != NO_SRVR && ++srvr_inx < class->num_srvrs); |
|
|
2721 |
|
|
2722 return 1; |
|
|
2723 } |
|
|
2724 |
|
|
2725 |
|
|
2726 |
|
|
2727 static int |
|
|
2728 clock_ck_cmd(const char *arg UATTRIB, const CMD_TBL_ENTRY *ce UATTRIB) |
|
|
2729 { |
|
|
2730 if (!rdy_ctxt(0)) |
|
|
2731 return 0; |
|
|
2732 do_aop(DCC_AOP_CLOCK_CHECK, sizeof(aop_resp.resp.val.string), |
|
|
2733 NO_SRVR, 1); |
|
|
2734 |
|
|
2735 return 1; |
|
|
2736 } |
|
|
2737 |
|
|
2738 |
|
|
2739 |
|
|
2740 /* restore tracing to default */ |
|
|
2741 static int |
|
|
2742 trace_def(const char *arg UATTRIB, const CMD_TBL_ENTRY *ce UATTRIB) |
|
|
2743 { |
|
|
2744 if (!rdy_ctxt(0)) |
|
|
2745 return 0; |
|
|
2746 |
|
|
2747 return (do_aop(DCC_AOP_TRACE_ON, DCC_TRACE_ON_DEF_BITS, |
|
|
2748 NO_SRVR, 1) |
|
|
2749 && do_aop(DCC_AOP_TRACE_OFF, DCC_TRACE_OFF_DEF_BITS, |
|
|
2750 NO_SRVR, 1)); |
|
|
2751 |
|
|
2752 } |
