ViewVC Help

View File | Revision Log | Show Annotations | View Changeset | Root Listing

root/svn/ircd-hybrid/branches/8.2.x/modules/m_dline.c

Comparing:
ircd-hybrid/trunk/modules/m_dline.c (file contents), Revision 1652 by michael, Tue Nov 13 20:28:53 2012 UTC vs.
ircd-hybrid/branches/8.2.x/modules/m_dline.c (file contents), Revision 3930 by michael, Mon Jun 9 14:58:12 2014 UTC

#	Line 1 | Line 1
1		/*
2	<	*  ircd-hybrid: an advanced Internet Relay Chat Daemon(ircd).
3	<	*  m_dline.c: Bans a user.
2	>	*  ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
3		*
4	<	*  Copyright (C) 2002 by the past and present ircd coders, and others.
4	>	*  Copyright (c) 1997-2014 ircd-hybrid development team
5		*
6		*  This program is free software; you can redistribute it and/or modify
7		*  it under the terms of the GNU General Public License as published by
#	Line 18 | Line 17
17		*  along with this program; if not, write to the Free Software
18		*  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
19		*  USA
20	<	*
21	<	*  $Id$
20	>	*/
21	>
22	>	/*! \file m_dline.c
23	>	* \brief Includes required functions for processing the DLINE command.
24	>	* \version $Id$
25		*/
26
27		#include "stdinc.h"
28		#include "list.h"
27	–	#include "channel.h"
29		#include "client.h"
30		#include "irc_string.h"
30	–	#include "sprintf_irc.h"
31		#include "conf.h"
32		#include "ircd.h"
33		#include "hostmask.h"
34		#include "numeric.h"
35	–	#include "fdlist.h"
36	–	#include "s_bsd.h"
35		#include "log.h"
36	<	#include "s_misc.h"
36	>	#include "misc.h"
37		#include "send.h"
38		#include "hash.h"
39	<	#include "s_serv.h"
39	>	#include "server.h"
40		#include "parse.h"
41		#include "modules.h"
42		#include "conf_db.h"
43	+	#include "memory.h"
44	+
45	+
46	+	static void
47	+	check_dline(struct AddressRec *arec)
48	+	{
49	+	dlink_node *ptr = NULL, *ptr_next = NULL;
50	+
51	+	DLINK_FOREACH_SAFE(ptr, ptr_next, local_client_list.head)
52	+	{
53	+	struct Client *client_p = ptr->data;
54	+
55	+	if (IsDead(client_p))
56	+	continue;
57	+
58	+	switch (arec->masktype)
59	+	{
60	+	case HM_IPV4:
61	+	if (client_p->localClient->aftype == AF_INET)
62	+	if (match_ipv4(&client_p->localClient->ip, &arec->Mask.ipa.addr, arec->Mask.ipa.bits))
63	+	conf_try_ban(client_p, arec->conf);
64	+	break;
65	+	case HM_IPV6:
66	+	if (client_p->localClient->aftype == AF_INET6)
67	+	if (match_ipv6(&client_p->localClient->ip, &arec->Mask.ipa.addr, arec->Mask.ipa.bits))
68	+	conf_try_ban(client_p, arec->conf);
69	+	break;
70	+	default: break;
71	+	}
72	+	}
73	+
74	+	DLINK_FOREACH_SAFE(ptr, ptr_next, unknown_list.head)
75	+	{
76	+	struct Client *client_p = ptr->data;
77	+
78	+	if (IsDead(client_p))
79	+	continue;
80	+
81	+	switch (arec->masktype)
82	+	{
83	+	case HM_IPV4:
84	+	if (client_p->localClient->aftype == AF_INET)
85	+	if (match_ipv4(&client_p->localClient->ip, &arec->Mask.ipa.addr, arec->Mask.ipa.bits))
86	+	conf_try_ban(client_p, arec->conf);
87	+	break;
88	+	case HM_IPV6:
89	+	if (client_p->localClient->aftype == AF_INET6)
90	+	if (match_ipv6(&client_p->localClient->ip, &arec->Mask.ipa.addr, arec->Mask.ipa.bits))
91	+	conf_try_ban(client_p, arec->conf);
92	+	break;
93	+	default: break;
94	+	}
95	+	}
96	+	}
97
98
99		/* apply_tdline()
#	Line 61 | Line 113 | apply_dline(struct Client *source_p, str
113		"%s added temporary %d min. D-Line for [%s] [%s]",
114		get_oper_name(source_p), tkline_time/60,
115		conf->host, conf->reason);
116	<	sendto_one(source_p, ":%s NOTICE %s :Added temporary %d min. D-Line [%s]",
117	<	MyConnect(source_p) ? me.name : ID_or_name(&me, source_p->from),
66	<	source_p->name, tkline_time/60, conf->host);
116	>	sendto_one_notice(source_p, &me, ":Added temporary %d min. D-Line [%s]",
117	>	tkline_time/60, conf->host);
118		ilog(LOG_TYPE_DLINE, "%s added temporary %d min. D-Line for [%s] [%s]",
119		get_oper_name(source_p), tkline_time/60, conf->host, conf->reason);
120		}
#	Line 72 | Line 123 | apply_dline(struct Client *source_p, str
123		sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
124		"%s added D-Line for [%s] [%s]",
125		get_oper_name(source_p), conf->host, conf->reason);
126	<	sendto_one(source_p, ":%s NOTICE %s :Added D-Line [%s]",
76	<	MyConnect(source_p) ? me.name : ID_or_name(&me, source_p->from),
77	<	source_p->name, conf->host);
126	>	sendto_one_notice(source_p, &me, ":Added D-Line [%s]", conf->host);
127		ilog(LOG_TYPE_DLINE, "%s added D-Line for [%s] [%s]",
128		get_oper_name(source_p), conf->host, conf->reason);
129
#	Line 82 | Line 131 | apply_dline(struct Client *source_p, str
131
132		SetConfDatabase(conf);
133		conf->setat = CurrentTime;
134	<	add_conf_by_address(CONF_DLINE, conf);
86	<	rehashed_klines = 1;
87	<	}
88	<
89	<	/* static int remove_tdline_match(const char *host, const char *user)
90	<	* Input: An ip to undline.
91	<	* Output: returns YES on success, NO if no tdline removed.
92	<	* Side effects: Any matching tdlines are removed.
93	<	*/
94	<	static int
95	<	remove_dline_match(const char *host)
96	<	{
97	<	struct irc_ssaddr iphost, *piphost;
98	<	struct MaskItem *conf;
99	<	int t = 0;
100	<	int aftype = 0;
101	<
102	<	if ((t = parse_netmask(host, &iphost, NULL)) != HM_HOST)
103	<	{
104	<	#ifdef IPV6
105	<	if (t == HM_IPV6)
106	<	aftype = AF_INET6;
107	<	else
108	<	#endif
109	<	aftype = AF_INET;
110	<	piphost = &iphost;
111	<	}
112	<	else
113	<	piphost = NULL;
114	<
115	<	if ((conf = find_conf_by_address(host, piphost, CONF_DLINE, aftype, NULL, NULL, 0)))
116	<	{
117	<	if (IsConfDatabase(conf))
118	<	{
119	<	delete_one_address_conf(host, conf);
120	<	return 1;
121	<	}
122	<	}
123	<
124	<	return 0;
134	>	check_dline(add_conf_by_address(CONF_DLINE, conf));
135		}
136
137		/* mo_dline()
#	Line 134 | Line 144 | remove_dline_match(const char *host)
144		* side effects - D line is added
145		*
146		*/
147	<	static void
148	<	mo_dline(struct Client *client_p, struct Client *source_p,
139	<	int parc, char *parv[])
147	>	static int
148	>	mo_dline(struct Client *source_p, int parc, char *parv[])
149		{
150	<	char def_reason[] = "<No reason specified>";
150	>	char def_reason[] = CONF_NOREASON;
151		char *dlhost = NULL, *reason = NULL;
152		char *target_server = NULL;
153		const char *creason;
#	Line 148 | Line 157 | mo_dline(struct Client *client_p, struct
157		time_t tkline_time=0;
158		int bits = 0, aftype = 0, t = 0;
159		const char *current_date = NULL;
151	–	time_t cur_time;
160		char hostip[HOSTIPLEN + 1];
161		char buffer[IRCD_BUFSIZE];
162
163		if (!HasOFlag(source_p, OPER_FLAG_DLINE))
164		{
165	<	sendto_one(source_p, form_str(ERR_NOPRIVS),
166	<	me.name, source_p->name, "dline");
159	<	return;
165	>	sendto_one_numeric(source_p, &me, ERR_NOPRIVS, "dline");
166	>	return 0;
167		}
168
169		if (parse_aline("DLINE", source_p,  parc, parv, AWILD, &dlhost,
170		NULL, &tkline_time, &target_server, &reason) < 0)
171	<	return;
171	>	return 0;
172
173	<	if (target_server != NULL)
173	>	if (target_server)
174		{
175	<	if (HasID(source_p))
176	<	{
177	<	sendto_server(NULL, CAP_DLN|CAP_TS6, NOCAPS,
171	<	":%s DLINE %s %lu %s :%s",
172	<	source_p->id, target_server, (unsigned long)tkline_time,
173	<	dlhost, reason);
174	<	sendto_server(NULL, CAP_DLN, CAP_TS6,
175	<	":%s DLINE %s %lu %s :%s",
176	<	source_p->name, target_server, (unsigned long)tkline_time,
177	<	dlhost, reason);
178	<	}
179	<	else
180	<	sendto_server(NULL, CAP_DLN, NOCAPS,
181	<	":%s DLINE %s %lu %s :%s",
182	<	source_p->name, target_server, (unsigned long)tkline_time,
183	<	dlhost, reason);
175	>	sendto_match_servs(source_p, target_server, CAP_DLN, "DLINE %s %lu %s :%s",
176	>	target_server, (unsigned long)tkline_time,
177	>	dlhost, reason);
178
179		/* Allow ON to apply local kline as well if it matches */
180		if (match(target_server, me.name))
181	<	return;
181	>	return 0;
182		}
183		else
184		cluster_a_line(source_p, "DLINE", CAP_DLN, SHARED_DLINE,
#	Line 192 | Line 186 | mo_dline(struct Client *client_p, struct
186
187		if ((t = parse_netmask(dlhost, NULL, &bits)) == HM_HOST)
188		{
189	<	if ((target_p = find_chasing(client_p, source_p, dlhost, NULL)) == NULL)
190	<	return;
189	>	if ((target_p = find_chasing(source_p, dlhost)) == NULL)
190	>	return 0;  /* find_chasing sends ERR_NOSUCHNICK */
191
192		if (!MyConnect(target_p))
193		{
194	<	sendto_one(source_p,
195	<	":%s NOTICE %s :Can't DLINE nick on another server",
202	<	me.name, source_p->name);
203	<	return;
194	>	sendto_one_notice(source_p, &me, ":Cannot DLINE nick on another server");
195	>	return 0;
196		}
197
198		if (IsExemptKline(target_p))
199		{
200	<	sendto_one(source_p,
201	<	":%s NOTICE %s :%s is E-lined", me.name,
202	<	source_p->name, target_p->name);
211	<	return;
200	>	sendto_one_notice(source_p, &me, ":%s is E-lined",
201	>	target_p->name);
202	>	return 0;
203		}
204
205		getnameinfo((struct sockaddr *)&target_p->localClient->ip,
#	Line 221 | Line 212 | mo_dline(struct Client *client_p, struct
212
213		if (bits < 8)
214		{
215	<	sendto_one(source_p,
216	<	":%s NOTICE %s :For safety, bitmasks less than 8 require conf access.",
226	<	me.name, source_p->name);
227	<	return;
215	>	sendto_one_notice(source_p, &me, ":For safety, bitmasks less than 8 require conf access.");
216	>	return 0;
217		}
218
219		#ifdef IPV6
#	Line 236 | Line 225 | mo_dline(struct Client *client_p, struct
225
226		parse_netmask(dlhost, &daddr, NULL);
227
228	<	if ((conf = find_dline_conf(&daddr, aftype)) != NULL)
228	>	if ((conf = find_dline_conf(&daddr, aftype)))
229		{
230		creason = conf->reason ? conf->reason : def_reason;
231	+
232		if (IsConfExemptKline(conf))
233	<	sendto_one(source_p,
234	<	":%s NOTICE %s :[%s] is (E)d-lined by [%s] - %s",
245	<	me.name, source_p->name, dlhost, conf->host, creason);
233	>	sendto_one_notice(source_p, &me, ":[%s] is (E)d-lined by [%s] - %s",
234	>	dlhost, conf->host, creason);
235		else
236	<	sendto_one(source_p,
237	<	":%s NOTICE %s :[%s] already D-lined by [%s] - %s",
238	<	me.name, source_p->name, dlhost, conf->host, creason);
250	<	return;
236	>	sendto_one_notice(source_p, &me, ":[%s] already D-lined by [%s] - %s",
237	>	dlhost, conf->host, creason);
238	>	return 0;
239		}
240
241	<	cur_time = CurrentTime;
254	<	current_date = smalldate(cur_time);
241	>	current_date = smalldate(0);
242
243		if (!valid_comment(source_p, reason, 1))
244	<	return;
244	>	return 0;
245
246		conf = conf_make(CONF_DLINE);
247		conf->host = xstrdup(dlhost);
248
249	<	if (tkline_time != 0)
249	>	if (tkline_time)
250		snprintf(buffer, sizeof(buffer), "Temporary D-line %d min. - %s (%s)",
251		(int)(tkline_time/60), reason, current_date);
252		else
#	Line 267 | Line 254 | mo_dline(struct Client *client_p, struct
254
255		conf->reason = xstrdup(buffer);
256		apply_dline(source_p, conf, tkline_time);
257	<	rehashed_klines = 1;
257	>	return 0;
258		}
259
260	<	static void
261	<	ms_dline(struct Client *client_p, struct Client *source_p,
275	<	int parc, char *parv[])
260	>	static int
261	>	ms_dline(struct Client *source_p, int parc, char *parv[])
262		{
263	<	char def_reason[] = "<No reason specified>";
263	>	char def_reason[] = CONF_NOREASON;
264		char *dlhost, *reason;
265		const char *creason;
266		const struct Client *target_p = NULL;
#	Line 283 | Line 269 | ms_dline(struct Client *client_p, struct
269		time_t tkline_time=0;
270		int bits = 0, aftype = 0, t = 0;
271		const char *current_date = NULL;
286	–	time_t cur_time;
272		char hostip[HOSTIPLEN + 1];
273		char buffer[IRCD_BUFSIZE];
274
275		if (parc != 5 || EmptyString(parv[4]))
276	<	return;
276	>	return 0;
277
278		/* parv[0]  parv[1]        parv[2]      parv[3]  parv[4] */
279		/* oper     target_server  tkline_time  host     reason  */
#	Line 297 | Line 282 | ms_dline(struct Client *client_p, struct
282		parv[1], parv[2], parv[3], parv[4]);
283
284		if (match(parv[1], me.name))
285	<	return;
285	>	return 0;
286
287		tkline_time = valid_tkline(parv[2], TK_SECONDS);
288		dlhost = parv[3];
289		reason = parv[4];
290
291	<	if (HasFlag(source_p, FLAGS_SERVICE) || find_matching_name_conf(CONF_ULINE, source_p->servptr->name,
291	>	if (HasFlag(source_p, FLAGS_SERVICE) ||
292	>	find_matching_name_conf(CONF_ULINE, source_p->servptr->name,
293		source_p->username, source_p->host,
294		SHARED_DLINE))
295		{
296		if (!IsClient(source_p))
297	<	return;
297	>	return 0;
298	>
299		if ((t = parse_netmask(dlhost, NULL, &bits)) == HM_HOST)
300		{
301	<	if ((target_p = find_chasing(client_p, source_p, dlhost, NULL)) == NULL)
302	<	return;
301	>	if ((target_p = find_chasing(source_p, dlhost)) == NULL)
302	>	return 0;  /* find_chasing sends ERR_NOSUCHNICK */
303
304		if (!MyConnect(target_p))
305		{
306	<	sendto_one(source_p,
307	<	":%s NOTICE %s :Can't DLINE nick on another server",
321	<	me.name, source_p->name);
322	<	return;
306	>	sendto_one_notice(source_p, &me, ":Cannot DLINE nick on another server");
307	>	return 0;
308		}
309
310		if (IsExemptKline(target_p))
311		{
312	<	sendto_one(source_p,
313	<	":%s NOTICE %s :%s is E-lined", me.name,
329	<	source_p->name, target_p->name);
330	<	return;
312	>	sendto_one_notice(source_p, &me, ":%s is E-lined", target_p->name);
313	>	return 0;
314		}
315
316		getnameinfo((struct sockaddr *)&target_p->localClient->ip,
#	Line 340 | Line 323 | ms_dline(struct Client *client_p, struct
323
324		if (bits < 8)
325		{
326	<	sendto_one(source_p,
327	<	":%s NOTICE %s :For safety, bitmasks less than 8 require conf access.",
345	<	me.name, source_p->name);
346	<	return;
326	>	sendto_one_notice(source_p, &me, ":For safety, bitmasks less than 8 require conf access.");
327	>	return 0;
328		}
329
330		#ifdef IPV6
#	Line 355 | Line 336 | ms_dline(struct Client *client_p, struct
336
337		parse_netmask(dlhost, &daddr, NULL);
338
339	<	if ((conf = find_dline_conf(&daddr, aftype)) != NULL)
339	>	if ((conf = find_dline_conf(&daddr, aftype)))
340		{
341		creason = conf->reason ? conf->reason : def_reason;
342		if (IsConfExemptKline(conf))
343	<	sendto_one(source_p,
344	<	":%s NOTICE %s :[%s] is (E)d-lined by [%s] - %s",
364	<	me.name, source_p->name, dlhost, conf->host, creason);
343	>	sendto_one_notice(source_p, &me, ":[%s] is (E)d-lined by [%s] - %s",
344	>	dlhost, conf->host, creason);
345		else
346	<	sendto_one(source_p,
347	<	":%s NOTICE %s :[%s] already D-lined by [%s] - %s",
348	<	me.name, source_p->name, dlhost, conf->host, creason);
369	<	return;
346	>	sendto_one_notice(source_p, &me, ":[%s] already D-lined by [%s] - %s",
347	>	dlhost, conf->host, creason);
348	>	return 0;
349		}
350
351	<	cur_time = CurrentTime;
373	<	current_date = smalldate(cur_time);
351	>	current_date = smalldate(0);
352
353		if (!valid_comment(source_p, reason, 1))
354	<	return;
354	>	return 0;
355
356		conf = conf_make(CONF_DLINE);
357		conf->host = xstrdup(dlhost);
358
359	<	if (tkline_time != 0)
359	>	if (tkline_time)
360		snprintf(buffer, sizeof(buffer), "Temporary D-line %d min. - %s (%s)",
361		(int)(tkline_time/60), reason, current_date);
362		else
#	Line 386 | Line 364 | ms_dline(struct Client *client_p, struct
364
365		conf->reason = xstrdup(buffer);
366		apply_dline(source_p, conf, tkline_time);
389	–	rehashed_klines = 1;
390	–	}
391	–	}
392	–
393	–	/*
394	–	** m_undline
395	–	** added May 28th 2000 by Toby Verrall <toot@melnet.co.uk>
396	–	** based totally on m_unkline
397	–	** added to hybrid-7 7/11/2000 --is
398	–	**
399	–	**      parv[0] = sender nick
400	–	**      parv[1] = dline to remove
401	–	*/
402	–	static void
403	–	mo_undline(struct Client *client_p, struct Client *source_p,
404	–	int parc, char *parv[])
405	–	{
406	–	char *addr = NULL, *user = NULL;
407	–	char *target_server = NULL;
408	–
409	–	if (!HasOFlag(source_p, OPER_FLAG_UNDLINE))
410	–	{
411	–	sendto_one(source_p, form_str(ERR_NOPRIVS),
412	–	me.name, source_p->name, "undline");
413	–	return;
367		}
368
369	<	if (parc < 2 || EmptyString(parv[1]))
417	<	{
418	<	sendto_one(source_p, form_str(ERR_NEEDMOREPARAMS),
419	<	me.name, source_p->name, "UNDLINE");
420	<	return;
421	<	}
422	<
423	<	if (parse_aline("UNDLINE", source_p, parc, parv, 0, &user,
424	<	&addr, NULL, &target_server, NULL) < 0)
425	<	return;
426	<
427	<	if (target_server != NULL)
428	<	{
429	<	sendto_match_servs(source_p, target_server, CAP_UNDLN,
430	<	"UNDLINE %s %s", target_server, addr);
431	<
432	<	/* Allow ON to apply local unkline as well if it matches */
433	<	if (match(target_server, me.name))
434	<	return;
435	<	}
436	<	else
437	<	cluster_a_line(source_p, "UNDLINE", CAP_UNDLN, SHARED_UNDLINE,
438	<	"%s", addr);
439	<
440	<	if (remove_dline_match(addr))
441	<	{
442	<	sendto_one(source_p,
443	<	":%s NOTICE %s :D-Line for [%s] is removed",
444	<	me.name, source_p->name, addr);
445	<	sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
446	<	"%s has removed the D-Line for: [%s]",
447	<	get_oper_name(source_p), addr);
448	<	ilog(LOG_TYPE_DLINE, "%s removed D-Line for [%s]",
449	<	get_oper_name(source_p), addr);
450	<	}
451	<	else
452	<	sendto_one(source_p, ":%s NOTICE %s :No D-Line for [%s] found",
453	<	me.name, source_p->name, addr);
454	<	}
455	<
456	<	static void
457	<	me_undline(struct Client *client_p, struct Client *source_p,
458	<	int parc, char *parv[])
459	<	{
460	<	const char *addr = NULL;
461	<
462	<	if (parc != 3 || EmptyString(parv[2]))
463	<	return;
464	<
465	<	addr = parv[2];
466	<
467	<	if (!IsClient(source_p) || match(parv[1], me.name))
468	<	return;
469	<
470	<	if (HasFlag(source_p, FLAGS_SERVICE) || find_matching_name_conf(CONF_ULINE,
471	<	source_p->servptr->name,
472	<	source_p->username, source_p->host,
473	<	SHARED_UNDLINE))
474	<	{
475	<	if (remove_dline_match(addr))
476	<	{
477	<	sendto_one(source_p,
478	<	":%s NOTICE %s :D-Line for [%s] is removed",
479	<	me.name, source_p->name, addr);
480	<	sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
481	<	"%s has removed the D-Line for: [%s]",
482	<	get_oper_name(source_p), addr);
483	<	ilog(LOG_TYPE_DLINE, "%s removed temporary D-Line for [%s]",
484	<	get_oper_name(source_p), addr);
485	<	}
486	<	else
487	<	sendto_one(source_p, ":%s NOTICE %s :No D-Line for [%s] found",
488	<	me.name, source_p->name, addr);
489	<	}
369	>	return 0;
370		}
371
372	<	static void
493	<	ms_undline(struct Client *client_p, struct Client *source_p,
494	<	int parc, char *parv[])
372	>	static struct Message dline_msgtab =
373		{
496	–	if (parc != 3 || EmptyString(parv[2]))
497	–	return;
498	–
499	–	sendto_match_servs(source_p, parv[1], CAP_UNDLN,
500	–	"UNDLINE %s %s %s",
501	–	parv[1], parv[2]);
502	–
503	–	me_undline(client_p, source_p, parc, parv);
504	–	}
505	–
506	–	static struct Message dline_msgtab = {
374		"DLINE", 0, 0, 2, MAXPARA, MFLG_SLOW, 0,
375	<	{m_unregistered, m_not_oper, ms_dline, m_ignore, mo_dline, m_ignore}
509	<	};
510	<
511	<	static struct Message undline_msgtab = {
512	<	"UNDLINE", 0, 0, 2, MAXPARA, MFLG_SLOW, 0,
513	<	{m_unregistered, m_not_oper, ms_undline, m_ignore, mo_undline, m_ignore}
375	>	{ m_unregistered, m_not_oper, ms_dline, m_ignore, mo_dline, m_ignore }
376		};
377
378		static void
379		module_init(void)
380		{
381		mod_add_cmd(&dline_msgtab);
520	–	mod_add_cmd(&undline_msgtab);
382		add_capability("DLN", CAP_DLN, 1);
522	–	add_capability("UNDLN", CAP_UNDLN, 1);
383		}
384
385		static void
386		module_exit(void)
387		{
388		mod_del_cmd(&dline_msgtab);
529	–	mod_del_cmd(&undline_msgtab);
530	–	delete_capability("UNDLN");
389		delete_capability("DLN");
390		}
391
392	<	struct module module_entry = {
392	>	struct module module_entry =
393	>	{
394		.node    = { NULL, NULL, NULL },
395		.name    = NULL,
396		.version = "$Revision$",

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)