Attachment #360248 for bug #486864

View | Details | Raw Unified | Return to bug 486864
Collapse All | Expand All




static void *
pknock_seq_start(struct seq_file *s, loff_t *pos)
{
	const struct xt_pknock_rule *rule = s->private;
	const struct xt_pknock_rule *rule = pde->data;

	spin_lock_bh(&list_lock);


static void *
pknock_seq_next(struct seq_file *s, void *v, loff_t *pos)
{
	const struct xt_pknock_rule *rule = s->private;
	const struct xt_pknock_rule *rule = pde->data;

	++*pos;
	if (*pos >= peer_hashsize)

	unsigned long time;
	const struct list_head *peer_head = v;

	const struct xt_pknock_rule *rule = s->private;
	const struct xt_pknock_rule *rule = pde->data;

	list_for_each_safe(pos, n, peer_head) {
		peer = list_entry(pos, struct peer, head);

	int ret = seq_open(file, &pknock_seq_ops);
	if (ret == 0) {
		struct seq_file *sf = file->private_data;
		sf->private = PDE_DATA(inode);
	}
	return ret;
}

	rule->timer.function	= peer_gc;
	rule->timer.data	= (unsigned long)rule;

	rule->status_proc = proc_create_data(info->rule_name, 0, pde,
	                    &pknock_proc_ops, rule);
	if (rule->status_proc == NULL)
		goto out;

	rule->status_proc->proc_fops = &pknock_proc_ops;
	rule->status_proc->data = rule;

	list_add(&rule->head, &rule_hashtable[hash]);
	pr_debug("(A) rule_name: %s - created.\n", rule->rule_name);
	return true;

Return to bug 486864

Lines 190-197 Link Here

(-)xtables-addons-2.1/extensions/pknock/xt_pknock.c (-11 / +6 lines)
190	static void *	190	static void *
191	pknock_seq_start(struct seq_file s, loff_t pos)	191	pknock_seq_start(struct seq_file s, loff_t pos)
192	{	192	{
193	const struct proc_dir_entry *pde = s->private;	193	const struct xt_pknock_rule *rule = s->private;
194	const struct xt_pknock_rule *rule = pde->data;
195		194
196	spin_lock_bh(&list_lock);	195	spin_lock_bh(&list_lock);
197		196
Lines 210-217 Link Here
210	static void *	209	static void *
211	pknock_seq_next(struct seq_file s, void v, loff_t *pos)	210	pknock_seq_next(struct seq_file s, void v, loff_t *pos)
212	{	211	{
213	const struct proc_dir_entry *pde = s->private;	212	const struct xt_pknock_rule *rule = s->private;
214	const struct xt_pknock_rule *rule = pde->data;
215		213
216	++*pos;	214	++*pos;
217	if (*pos >= peer_hashsize)	215	if (*pos >= peer_hashsize)
Lines 243-250 Link Here
243	unsigned long time;	241	unsigned long time;
244	const struct list_head *peer_head = v;	242	const struct list_head *peer_head = v;
245		243
246	const struct proc_dir_entry *pde = s->private;	244	const struct xt_pknock_rule *rule = s->private;
247	const struct xt_pknock_rule *rule = pde->data;
248		245
249	list_for_each_safe(pos, n, peer_head) {	246	list_for_each_safe(pos, n, peer_head) {
250	peer = list_entry(pos, struct peer, head);	247	peer = list_entry(pos, struct peer, head);
Lines 295-301 Link Here
295	int ret = seq_open(file, &pknock_seq_ops);	292	int ret = seq_open(file, &pknock_seq_ops);
296	if (ret == 0) {	293	if (ret == 0) {
297	struct seq_file *sf = file->private_data;	294	struct seq_file *sf = file->private_data;
298	sf->private = PDE(inode);	295	sf->private = PDE_DATA(inode);
299	}	296	}
300	return ret;	297	return ret;
301	}	298	}
Lines 478-490 Link Here
478	rule->timer.function = peer_gc;	475	rule->timer.function = peer_gc;
479	rule->timer.data = (unsigned long)rule;	476	rule->timer.data = (unsigned long)rule;
480		477
481	rule->status_proc = create_proc_entry(info->rule_name, 0, pde);	478	rule->status_proc = proc_create_data(info->rule_name, 0, pde,
		479	&pknock_proc_ops, rule);
482	if (rule->status_proc == NULL)	480	if (rule->status_proc == NULL)
483	goto out;	481	goto out;
484		482
485	rule->status_proc->proc_fops = &pknock_proc_ops;
486	rule->status_proc->data = rule;
487
488	list_add(&rule->head, &rule_hashtable[hash]);	483	list_add(&rule->head, &rule_hashtable[hash]);
489	pr_debug("(A) rule_name: %s - created.\n", rule->rule_name);	484	pr_debug("(A) rule_name: %s - created.\n", rule->rule_name);
490	return true;	485	return true;