21 |
*/ |
*/ |
22 |
|
|
23 |
#include <sys/types.h> |
#include <sys/types.h> |
24 |
|
#include <stdlib.h> |
25 |
#include <netinet/in.h> |
#include <netinet/in.h> |
26 |
|
|
27 |
|
#include "buffer.h" |
28 |
|
#include "log.h" |
29 |
#include "protocol.h" |
#include "protocol.h" |
30 |
#include "fdo.h" |
#include "fdo.h" |
31 |
|
#include "fdo/init.h" |
32 |
|
|
33 |
|
#define MAX_MODULES 500 |
34 |
|
struct |
35 |
|
{ |
36 |
|
token_t token; |
37 |
|
token_handler_t handler; |
38 |
|
} |
39 |
|
module[MAX_MODULES]; |
40 |
|
|
41 |
|
int nbmodules; |
42 |
|
|
43 |
void |
void |
44 |
fdo_recv (data, data_size) |
fdo_init () |
45 |
|
{ |
46 |
|
nbmodules = 0; |
47 |
|
init_register (); |
48 |
|
} |
49 |
|
|
50 |
|
void |
51 |
|
fdo_recv (out, data, data_size) |
52 |
|
buffer_t *out; |
53 |
char *data; |
char *data; |
54 |
size_t data_size; |
size_t data_size; |
55 |
{ |
{ |
56 |
|
int i, index = -1; |
57 |
token_t *token; |
token_t *token; |
58 |
|
|
59 |
token=(token_t *)data; |
token = (token_t *) data; |
60 |
/* make sure we have a code into the packet */ |
/* make sure we have a code into the packet */ |
61 |
if (data_size < sizeof (token_t)) |
if (data_size < sizeof (token_t)) |
62 |
return; |
return; |
63 |
|
|
64 |
*token = ntohs (*token); |
*token = ntohs (*token); |
65 |
|
for (i = 0; i < nbmodules; i++) |
66 |
|
{ |
67 |
|
if (module[i].token == *token && module[i].handler != NULL) |
68 |
|
{ |
69 |
|
index = i; |
70 |
|
break; |
71 |
|
} |
72 |
|
} |
73 |
|
if (index != -1) |
74 |
|
module[index].handler (*token, data, data_size, out); |
75 |
|
else |
76 |
|
log (LOG_NOTICE, "FDO - unregistered token received.", |
77 |
|
(*token >> 8) & 0xff, *token & 0xff); |
78 |
} |
} |
79 |
|
|
80 |
|
|
86 |
size_t data_size; |
size_t data_size; |
87 |
{ |
{ |
88 |
token_t *t; |
token_t *t; |
89 |
|
|
90 |
t=(token_t *)data; |
t = (token_t *) data; |
91 |
*t = htons (token); |
*t = htons (token); |
92 |
protocol->put_data (buffer, data, data_size + sizeof (*t)); |
protocol->put_data (buffer, data, data_size + sizeof (*t)); |
93 |
} |
} |
94 |
|
|
95 |
|
void |
96 |
|
fdo_register (token, handler) |
97 |
|
token_t token; |
98 |
|
token_handler_t handler; |
99 |
|
{ |
100 |
|
int i; |
101 |
|
int index = nbmodules; |
102 |
|
|
103 |
|
for (i = 0; i < nbmodules; i++) |
104 |
|
{ |
105 |
|
if (module[i].token == token) |
106 |
|
{ |
107 |
|
index = i; |
108 |
|
break; |
109 |
|
} |
110 |
|
} |
111 |
|
|
112 |
|
if (index == nbmodules) |
113 |
|
{ |
114 |
|
/* It's a new handler */ |
115 |
|
if (nbmodules < MAX_MODULES) |
116 |
|
nbmodules++; |
117 |
|
else |
118 |
|
return; |
119 |
|
} |
120 |
|
|
121 |
|
/* Fill structure */ |
122 |
|
module[index].token = token; |
123 |
|
module[index].handler = handler; |
124 |
|
|
125 |
|
debug (1, "FDO - Token '%c%c' registered.\n", (token >> 8) & 0xff, |
126 |
|
token & 0xff); |
127 |
|
} |
128 |
|
|
129 |
|
void |
130 |
|
fdo_unregister (token) |
131 |
|
token_t token; |
132 |
|
{ |
133 |
|
int i; |
134 |
|
int index = -1; |
135 |
|
|
136 |
|
for (i = 0; i < nbmodules; i++) |
137 |
|
{ |
138 |
|
if (module[i].token == token) |
139 |
|
{ |
140 |
|
index = i; |
141 |
|
break; |
142 |
|
} |
143 |
|
} |
144 |
|
|
145 |
|
if (index == -1) |
146 |
|
return; |
147 |
|
|
148 |
|
if (index < nbmodules - 1) |
149 |
|
{ |
150 |
|
/* Shift all next modules */ |
151 |
|
memcpy (&module[index], &module[index + 1], |
152 |
|
(nbmodules - index) * sizeof (module[0])); |
153 |
|
} |
154 |
|
|
155 |
|
nbmodules--; |
156 |
|
debug (1, "FDO - Token '%c%c' unregistered.\n", (token >> 8) & 0xff, |
157 |
|
token & 0xff); |
158 |
|
} |