c95d99db5408b821d3dacd6a8b506ba86c7116d2
[bbaumbach/samba-autobuild/.git] / source4 / libcli / nbt / libnbt.h
1 /*
2    Unix SMB/CIFS implementation.
3
4    a raw async NBT library
5
6    Copyright (C) Andrew Tridgell 2005
7
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 3 of the License, or
11    (at your option) any later version.
12
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
20 */
21
22 #ifndef __LIBNBT_H__
23 #define __LIBNBT_H__
24
25 #include "librpc/gen_ndr/nbt.h"
26
27 /*
28   possible states for pending requests
29 */
30 enum nbt_request_state {NBT_REQUEST_SEND, 
31                         NBT_REQUEST_WAIT, 
32                         NBT_REQUEST_DONE,
33                         NBT_REQUEST_TIMEOUT,
34                         NBT_REQUEST_ERROR};
35
36 /*
37   a nbt name request
38 */
39 struct nbt_name_request {
40         struct nbt_name_request *next, *prev;
41
42         enum nbt_request_state state;
43
44         NTSTATUS status;
45
46         /* the socket this was on */
47         struct nbt_name_socket *nbtsock;
48
49         /* where to send the request */
50         struct socket_address *dest;
51
52         /* timeout between retries */
53         int timeout;
54
55         /* how many retries to send on timeout */
56         int num_retries;
57
58         /* whether we have received a WACK */
59         bool received_wack;
60
61         /* the timeout event */
62         struct timed_event *te;
63
64         /* the name transaction id */
65         uint16_t name_trn_id;
66
67         /* is it a reply? */
68         bool is_reply;
69         
70         /* the encoded request */
71         DATA_BLOB encoded;
72
73         /* shall we allow multiple replies? */
74         bool allow_multiple_replies;
75
76         unsigned int num_replies;
77         struct nbt_name_reply {
78                 struct nbt_name_packet *packet;
79                 struct socket_address *dest;
80         } *replies;
81
82         /* information on what to do on completion */
83         struct {
84                 void (*fn)(struct nbt_name_request *);
85                 void *private;
86         } async;
87 };
88
89
90
91 /*
92   context structure for operations on name queries
93 */
94 struct nbt_name_socket {
95         struct socket_context *sock;
96         struct event_context *event_ctx;
97
98         /* a queue of requests pending to be sent */
99         struct nbt_name_request *send_queue;
100
101         /* the fd event */
102         struct fd_event *fde;
103
104         /* mapping from name_trn_id to pending event */
105         struct idr_context *idr;
106
107         /* how many requests are waiting for a reply */
108         uint16_t num_pending;
109
110         /* what to do with incoming request packets */
111         struct {
112                 void (*handler)(struct nbt_name_socket *, struct nbt_name_packet *, 
113                                 struct socket_address *);
114                 void *private;
115         } incoming;
116
117         /* what to do with unexpected replies */
118         struct {
119                 void (*handler)(struct nbt_name_socket *, struct nbt_name_packet *, 
120                                 struct socket_address *);
121                 void *private;
122         } unexpected;
123 };
124
125
126 /* a simple name query */
127 struct nbt_name_query {
128         struct {
129                 struct nbt_name name;
130                 const char *dest_addr;
131                 uint16_t dest_port;
132                 bool broadcast;
133                 bool wins_lookup;
134                 int timeout; /* in seconds */
135                 int retries;
136         } in;
137         struct {
138                 const char *reply_from;
139                 struct nbt_name name;
140                 int16_t num_addrs;
141                 const char **reply_addrs;
142         } out;
143 };
144
145 /* a simple name status query */
146 struct nbt_name_status {
147         struct {
148                 struct nbt_name name;
149                 const char *dest_addr;
150                 uint16_t dest_port;
151                 int timeout; /* in seconds */
152                 int retries;
153         } in;
154         struct {
155                 const char *reply_from;
156                 struct nbt_name name;
157                 struct nbt_rdata_status status;
158         } out;
159 };
160
161 /* a name registration request */
162 struct nbt_name_register {
163         struct {
164                 struct nbt_name name;
165                 const char *dest_addr;
166                 uint16_t dest_port;
167                 const char *address;
168                 uint16_t nb_flags;
169                 bool register_demand;
170                 bool broadcast;
171                 bool multi_homed;
172                 uint32_t ttl;
173                 int timeout; /* in seconds */
174                 int retries;
175         } in;
176         struct {
177                 const char *reply_from;
178                 struct nbt_name name;
179                 const char *reply_addr;
180                 uint8_t rcode;
181         } out;
182 };
183
184 /* a send 3 times then demand name broadcast name registration */
185 struct nbt_name_register_bcast {
186         struct {
187                 struct nbt_name name;
188                 const char *dest_addr;
189                 uint16_t dest_port;
190                 const char *address;
191                 uint16_t nb_flags;
192                 uint32_t ttl;
193         } in;
194 };
195
196
197 /* wins name register with multiple wins servers to try and multiple
198    addresses to register */
199 struct nbt_name_register_wins {
200         struct {
201                 struct nbt_name name;
202                 const char **wins_servers;
203                 uint16_t wins_port;
204                 const char **addresses;
205                 uint16_t nb_flags;
206                 uint32_t ttl;
207         } in;
208         struct {
209                 const char *wins_server;
210                 uint8_t rcode;
211         } out;
212 };
213
214
215
216 /* a name refresh request */
217 struct nbt_name_refresh {
218         struct {
219                 struct nbt_name name;
220                 const char *dest_addr;
221                 uint16_t dest_port;
222                 const char *address;
223                 uint16_t nb_flags;
224                 bool broadcast;
225                 uint32_t ttl;
226                 int timeout; /* in seconds */
227                 int retries;
228         } in;
229         struct {
230                 const char *reply_from;
231                 struct nbt_name name;
232                 const char *reply_addr;
233                 uint8_t rcode;
234         } out;
235 };
236
237 /* wins name refresh with multiple wins servers to try and multiple
238    addresses to register */
239 struct nbt_name_refresh_wins {
240         struct {
241                 struct nbt_name name;
242                 const char **wins_servers;
243                 uint16_t wins_port;
244                 const char **addresses;
245                 uint16_t nb_flags;
246                 uint32_t ttl;
247         } in;
248         struct {
249                 const char *wins_server;
250                 uint8_t rcode;
251         } out;
252 };
253
254
255 /* a name release request */
256 struct nbt_name_release {
257         struct {
258                 struct nbt_name name;
259                 const char *dest_addr;
260                 uint16_t dest_port;
261                 const char *address;
262                 uint16_t nb_flags;
263                 bool broadcast;
264                 int timeout; /* in seconds */
265                 int retries;
266         } in;
267         struct {
268                 const char *reply_from;
269                 struct nbt_name name;
270                 const char *reply_addr;
271                 uint8_t rcode;
272         } out;
273 };
274
275 #include "libcli/nbt/nbt_proto.h"
276
277 #endif /* __LIBNBT_H__ */