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 2 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, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 #include "librpc/gen_ndr/ndr_nbt.h"
  24
  25 /*
  26   possible states for pending requests
  27 */
  28 enum nbt_request_state {NBT_REQUEST_SEND,
  29                         NBT_REQUEST_WAIT,
  30                         NBT_REQUEST_DONE,
  31                         NBT_REQUEST_TIMEOUT,
  32                         NBT_REQUEST_ERROR};
  33
  34 /*
  35   a nbt name request
  36 */
  37 struct nbt_name_request {
  38         struct nbt_name_request *next, *prev;
  39
  40         enum nbt_request_state state;
  41
  42         NTSTATUS status;
  43
  44         /* the socket this was on */
  45         struct nbt_name_socket *nbtsock;
  46
  47         /* where to send the request */
  48         const char *dest_addr;
  49         int dest_port;
  50
  51         /* timeout between retries */
  52         int timeout;
  53
  54         /* how many retries to send on timeout */
  55         int num_retries;
  56
  57         /* whether we have received a WACK */
  58         BOOL received_wack;
  59
  60         /* the timeout event */
  61         struct timed_event *te;
  62
  63         /* the name transaction id */
  64         uint16_t name_trn_id;
  65
  66         /* is it a reply? */
  67         BOOL is_reply;
  68
  69         /* the encoded request */
  70         DATA_BLOB encoded;
  71
  72         /* shall we allow multiple replies? */
  73         BOOL allow_multiple_replies;
  74
  75         uint_t num_replies;
  76         struct nbt_name_reply {
  77                 struct nbt_name_packet *packet;
  78                 const char *reply_addr;
  79                 int reply_port;
  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                                 const char *, int );
 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                                 const char *, int );
 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                 BOOL broadcast;
 132                 BOOL wins_lookup;
 133                 int timeout; /* in seconds */
 134                 int retries;
 135         } in;
 136         struct {
 137                 const char *reply_from;
 138                 struct nbt_name name;
 139                 int16_t num_addrs;
 140                 const char **reply_addrs;
 141         } out;
 142 };
 143
 144 /* a simple name status query */
 145 struct nbt_name_status {
 146         struct {
 147                 struct nbt_name name;
 148                 const char *dest_addr;
 149                 int timeout; /* in seconds */
 150                 int retries;
 151         } in;
 152         struct {
 153                 const char *reply_from;
 154                 struct nbt_name name;
 155                 struct nbt_rdata_status status;
 156         } out;
 157 };
 158
 159 /* a name registration request */
 160 struct nbt_name_register {
 161         struct {
 162                 struct nbt_name name;
 163                 const char *dest_addr;
 164                 const char *address;
 165                 uint16_t nb_flags;
 166                 BOOL register_demand;
 167                 BOOL broadcast;
 168                 BOOL multi_homed;
 169                 uint32_t ttl;
 170                 int timeout; /* in seconds */
 171                 int retries;
 172         } in;
 173         struct {
 174                 const char *reply_from;
 175                 struct nbt_name name;
 176                 const char *reply_addr;
 177                 uint8_t rcode;
 178         } out;
 179 };
 180
 181 /* a send 3 times then demand name broadcast name registration */
 182 struct nbt_name_register_bcast {
 183         struct {
 184                 struct nbt_name name;
 185                 const char *dest_addr;
 186                 const char *address;
 187                 uint16_t nb_flags;
 188                 uint32_t ttl;
 189         } in;
 190 };
 191
 192
 193 /* wins name register with multiple wins servers to try and multiple
 194    addresses to register */
 195 struct nbt_name_register_wins {
 196         struct {
 197                 struct nbt_name name;
 198                 const char **wins_servers;
 199                 const char **addresses;
 200                 uint16_t nb_flags;
 201                 uint32_t ttl;
 202         } in;
 203         struct {
 204                 const char *wins_server;
 205                 uint8_t rcode;
 206         } out;
 207 };
 208
 209
 210
 211 /* a name refresh request */
 212 struct nbt_name_refresh {
 213         struct {
 214                 struct nbt_name name;
 215                 const char *dest_addr;
 216                 const char *address;
 217                 uint16_t nb_flags;
 218                 BOOL broadcast;
 219                 uint32_t ttl;
 220                 int timeout; /* in seconds */
 221                 int retries;
 222         } in;
 223         struct {
 224                 const char *reply_from;
 225                 struct nbt_name name;
 226                 const char *reply_addr;
 227                 uint8_t rcode;
 228         } out;
 229 };
 230
 231 /* wins name refresh with multiple wins servers to try and multiple
 232    addresses to register */
 233 struct nbt_name_refresh_wins {
 234         struct {
 235                 struct nbt_name name;
 236                 const char **wins_servers;
 237                 const char **addresses;
 238                 uint16_t nb_flags;
 239                 uint32_t ttl;
 240         } in;
 241         struct {
 242                 const char *wins_server;
 243                 uint8_t rcode;
 244         } out;
 245 };
 246
 247
 248 /* a name release request */
 249 struct nbt_name_release {
 250         struct {
 251                 struct nbt_name name;
 252                 const char *dest_addr;
 253                 const char *address;
 254                 uint16_t nb_flags;
 255                 BOOL broadcast;
 256                 int timeout; /* in seconds */
 257                 int retries;
 258         } in;
 259         struct {
 260                 const char *reply_from;
 261                 struct nbt_name name;
 262                 const char *reply_addr;
 263                 uint8_t rcode;
 264         } out;
 265 };