File: sig_eth.c

package info (click to toggle)
faumachine 20180503-4
  • links: PTS
  • area: main
  • in suites: bullseye, buster, sid
  • size: 61,272 kB
  • sloc: ansic: 272,290; makefile: 6,199; asm: 4,251; sh: 3,022; perl: 886; xml: 563; pascal: 311; lex: 214; vhdl: 204
file content (130 lines) | stat: -rw-r--r-- 2,236 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
/*
 * Copyright (C) 2007-2009 FAUmachine Team <info@faumachine.org>.
 * This program is free software. You can redistribute it and/or modify it
 * under the terms of the GNU General Public License, either version 2 of
 * the License, or (at your option) any later version. See COPYING.
 */

#include <assert.h>
#include <stdio.h>
#include <string.h>

#include "glue.h"

#include "sig_eth.h"

void
sig_eth_send(
	struct sig_eth *b,
	void *s,
	const void *buf,
	unsigned int buflen
)
{
	unsigned int nr;

	for (nr = 0; nr < b->nmembers; nr++) {
		if (b->member[nr].s == s) {
			continue;
		}
		(*b->member[nr].f->recv)(b->member[nr].s, buf, buflen);
	}
}

void
sig_eth_connect(struct sig_eth *b, void *s, const struct sig_eth_funcs *f)
{
	assert(b);
	assert(b->type == SIG_GEN_ETH);
	assert(b->nmembers < sizeof(b->member) / sizeof(b->member[0]));

	b->member[b->nmembers].s = s;
	b->member[b->nmembers].f = f;
	b->nmembers++;
}

static void
sig_eth_s0_recv(void *_f, const void *buf, unsigned int buflen)
{
	struct sig_eth_merge *f = _f;

	sig_eth_send(f->s1, f, buf, buflen);
}

static void
sig_eth_s1_recv(void *_f, const void *buf, unsigned int buflen)
{
	struct sig_eth_merge *f = _f;

	sig_eth_send(f->s0, f, buf, buflen);
}

struct sig_eth_merge *
sig_eth_merge(struct sig_eth *s0, struct sig_eth *s1)
{
	static struct sig_eth_funcs s0_funcs = {
		.recv = sig_eth_s0_recv,
	};
	static struct sig_eth_funcs s1_funcs = {
		.recv = sig_eth_s1_recv,
	};
	struct sig_eth_merge *m;

	m = shm_alloc(sizeof(*m));
	assert(m);

	/* Out */
	m->s0 = s0;
	m->s1 = s1;

	/* In */
	sig_eth_connect(s0, m, &s0_funcs);
	sig_eth_connect(s1, m, &s1_funcs);

	return m;
}

void
sig_eth_split(struct sig_eth_merge *m)
{
	fixme();
}

struct sig_eth *
sig_eth_create(const char *name)
{
	struct sig_eth *b;

	b = shm_alloc(sizeof(*b));
	assert(b);

	b->type = SIG_GEN_ETH;
	b->nmembers = 0;

	return b;
}

void
sig_eth_destroy(struct sig_eth *sig)
{
	assert(sig);
	assert(sig->type == SIG_GEN_ETH);

	shm_free(sig);
}

void
sig_eth_suspend(struct sig_eth *b, FILE *fSig)
{
	size_t size = sizeof(*b);
	
	generic_suspend(b, size, fSig);
}

void
sig_eth_resume(struct sig_eth *b, FILE *fSig)
{
	size_t size = sizeof(*b);
	
	generic_resume(b, size, fSig);
}