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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
|
% Internal SCCP link database keeping
% (C) 2011 by Harald Welte <laforge@gnumonks.org>
%
% All Rights Reserved
%
% This program is free software; you can redistribute it and/or modify
% it under the terms of the GNU Affero General Public License as
% published by the Free Software Foundation; either version 3 of the
% License, or (at your option) any later version.
%
% This program is distributed in the hope that it will be useful,
% but WITHOUT ANY WARRANTY; without even the implied warranty of
% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
% GNU General Public License for more details.
%
% You should have received a copy of the GNU Affero General Public License
% along with this program. If not, see <http://www.gnu.org/licenses/>.
-module(sccp_links).
-behaviour(gen_server).
% gen_fsm callbacks
-export([init/1, handle_call/3, handle_cast/2, handle_info/2,
terminate/2, code_change/3]).
% our published API
-export([start_link/0]).
% client functions, may internally talk to our sccp_user server
-export([register_linkset/3, unregister_linkset/1]).
-export([register_link/3, unregister_link/2, set_link_state/3]).
-export([get_pid_for_link/2]).
-record(slink, {
key, % {linkset_name, sls}
name,
linkset_name,
sls,
user_pid,
state
}).
-record(slinkset, {
name,
local_pc,
remote_pc,
user_pid,
state,
links
}).
-record(su_state, {
linkset_tbl,
link_tbl
}).
% initialization code
start_link() ->
gen_server:start_link({local, ?MODULE}, ?MODULE, [], []).
init(_Arg) ->
LinksetTbl = ets:new(sccp_linksets, [ordered_set,
{keypos, #slinkset.name}]),
% create a named table so we can query without reference directly
% within client/caller process
LinkTbl = ets:new(sccp_link_table, [ordered_set, named_table,
{keypos, #slink.key}]),
{ok, #su_state{linkset_tbl = LinksetTbl, link_tbl = LinkTbl}}.
% client side API
% all write operations go through gen_server:call(), as only the ?MODULE
% process has permission to modify the table content
register_linkset(LocalPc, RemotePc, Name) ->
gen_server:call(?MODULE, {register_linkset, {LocalPc, RemotePc, Name}}).
unregister_linkset(Name) ->
gen_server:call(?MODULE, {unregister_linkset, {Name}}).
register_link(LinksetName, Sls, Name) ->
gen_server:call(?MODULE, {register_link, {LinksetName, Sls, Name}}).
unregister_link(LinksetName, Sls) ->
gen_server:call(?MODULE, {unregister_link, {LinksetName, Sls}}).
set_link_state(LinksetName, Sls, State) ->
gen_server:call(?MODULE, {set_link_state, {LinksetName, Sls, State}}).
% the lookup functions can directly use the ets named_table from within
% the client process, no need to go through a synchronous IPC
get_pid_for_link(LinksetName, Sls) ->
case ets:lookup(sccp_link_table, {LinksetName, Sls}) of
[#slink{user_pid = Pid}] ->
% FIXME: check the link state
{ok, Pid};
_ ->
{error, no_such_link}
end.
% server side code
handle_call({register_linkset, {LocalPc, RemotePc, Name}},
{FromPid, _FromRef}, S) ->
#su_state{linkset_tbl = Tbl} = S,
Ls = #slinkset{local_pc = LocalPc, remote_pc = RemotePc,
name = Name, user_pid = FromPid},
case ets:insert_new(Tbl, Ls) of
false ->
{reply, {error, ets_insert}, S};
_ ->
% FIXME: We need to trap the user Pid for EXIT
% in order to automatically remove any links/linksets if
% the user process dies
{reply, ok, S}
end;
handle_call({unregister_linkset, {Name}}, {FromPid, _FromRef}, S) ->
#su_state{linkset_tbl = Tbl} = S,
ets:delete(Tbl, Name),
{reply, ok, S};
handle_call({register_link, {LsName, Sls, Name}},
{FromPid, _FromRef}, S) ->
#su_state{linkset_tbl = LinksetTbl, link_tbl = LinkTbl} = S,
% check if linkset actually exists
case ets:lookup(LinksetTbl, LsName) of
[#slinkset{}] ->
Link = #slink{name = Name, sls = Sls,
user_pid = FromPid, key = {LsName, Sls}},
case ets:insert_new(LinkTbl, Link) of
false ->
{reply, {error, link_exists}, S};
_ ->
% FIXME: We need to trap the user Pid for EXIT
% in order to automatically remove any links if
% the user process dies
{reply, ok, S}
end;
_ ->
{reply, {error, no_such_linkset}, S}
end;
handle_call({unregister_link, {LsName, Sls}}, {FromPid, _FromRef}, S) ->
#su_state{link_tbl = LinkTbl} = S,
ets:delete(LinkTbl, {LsName, Sls}),
{reply, ok, S};
handle_call({set_link_state, {LsName, Sls, State}}, {FromPid, _}, S) ->
#su_state{link_tbl = LinkTbl} = S,
case ets:lookup(LinkTbl, {LsName, Sls}) of
[] ->
{reply, {error, no_such_link}, S};
[Link] ->
NewLink = Link#slink{state = State},
ets:insert(LinkTbl, NewLink),
{reply, ok, S}
end.
handle_cast(Info, S) ->
error_logger:error_report(["unknown handle_cast",
{module, ?MODULE},
{info, Info}, {state, S}]),
{noreply, S}.
handle_info(Info, S) ->
error_logger:error_report(["unknown handle_info",
{module, ?MODULE},
{info, Info}, {state, S}]),
{noreply, S}.
terminate(Reason, _S) ->
io:format("terminating ~p with reason ~p", [?MODULE, Reason]),
ok.
code_change(_OldVsn, State, _Extra) ->
{ok, State}.
|
