source3/librpc/idl/smbXsrv.idl

   1 #include "idl_types.h"
   2
   3 import "misc.idl";
   4 import "server_id.idl";
   5 import "security.idl";
   6 import "auth.idl";
   7
   8 [
   9         uuid("07408340-ae31-11e1-97dc-539f7fddc06f"),
  10         version(0.0),
  11         pointer_default(unique),
  12         helpstring("smbXsrv structures")
  13 ]
  14 interface smbXsrv
  15 {
  16         /*
  17          * smbXsrv_version* is designed to allow
  18          * rolling code upgrades in future (within a cluster).
  19          *
  20          * This just adds the infrastructure,
  21          * but we does not implement it yet!
  22          *
  23          * Currently it only prevents that
  24          * nodes with a different version numbers
  25          * cannot run at the same time.
  26          *
  27          * Each node checks at startup, if the version
  28          * matches the version of all other nodes.
  29          * And it exits if the version does not match
  30          * to avoid corruption.
  31          *
  32          * While it would be possible to add versioning
  33          * to each of our internal databases it is easier
  34          * use a dedicated database "smbXsrv_version_global.tdb"
  35          * to hold the global version information.
  36          *
  37          * This removes extra complexity from the individual
  38          * databases and allows that we add/remove databases
  39          * or use different indexing keys.
  40          *
  41          */
  42         typedef [v1_enum] enum {
  43                 /*
  44                  * NOTE: Version 0 is designed to be unstable and the format
  45                  * may change during development.
  46                  */
  47                 SMBXSRV_VERSION_0 = 0x00000000
  48         } smbXsrv_version_values;
  49
  50         const uint32 SMBXSRV_VERSION_CURRENT = SMBXSRV_VERSION_0;
  51
  52         typedef struct {
  53                 server_id                               server_id;
  54                 smbXsrv_version_values                  min_version;
  55                 smbXsrv_version_values                  max_version;
  56                 smbXsrv_version_values                  current_version;
  57         } smbXsrv_version_node0;
  58
  59         typedef struct {
  60                 [ignore] db_record                      *db_rec;
  61                 [range(1, 1024)] uint32                 num_nodes;
  62                 smbXsrv_version_node0                   nodes[num_nodes];
  63         } smbXsrv_version_global0;
  64
  65         typedef union {
  66                 [case(0)] smbXsrv_version_global0       *info0;
  67                 [default] hyper                         *dummy;
  68         } smbXsrv_version_globalU;
  69
  70         typedef [public] struct {
  71                 smbXsrv_version_values                  version;
  72                 uint32                                  seqnum;
  73                 [switch_is(version)] smbXsrv_version_globalU info;
  74         } smbXsrv_version_globalB;
  75
  76         void smbXsrv_version_global_decode(
  77                 [in] smbXsrv_version_globalB blob
  78                 );
  79
  80         /* client */
  81
  82         typedef [public] struct {
  83                 [ignore] struct tevent_context          *ev_ctx;
  84                 [ignore] struct messaging_context       *msg_ctx;
  85
  86                 /*
  87                  * There's just one 'sconn' per client.
  88                  * It holds the FSA layer details, which are global
  89                  * per client (process).
  90                  */
  91                 [ignore] struct smbd_server_connection  *sconn;
  92
  93                 /*
  94                  * this session_table is used for SMB1 and SMB2,
  95                  */
  96                 [ignore] struct smbXsrv_session_table   *session_table;
  97                 [ignore] hyper                          last_session_id;
  98                 /*
  99                  * this tcon_table is only used for SMB1.
 100                  */
 101                 [ignore] struct smbXsrv_tcon_table      *tcon_table;
 102                 /*
 103                  * this open_table is used for SMB1 and SMB2,
 104                  * because we have a global sconn->real_max_open_files
 105                  * limit.
 106                  */
 107                 [ignore] struct smbXsrv_open_table      *open_table;
 108
 109                 /*
 110                  * For now this is only one connection!
 111                  * With multi-channel support we'll get more than
 112                  * one in future.
 113                  */
 114                 [ignore] struct smbXsrv_connection      *connections;
 115         } smbXsrv_client;
 116
 117         /* sessions */
 118
 119         typedef struct {
 120                 server_id                               server_id;
 121                 [charset(UTF8),string] char             local_address[];
 122                 [charset(UTF8),string] char             remote_address[];
 123                 [charset(UTF8),string] char             remote_name[];
 124                 [noprint] DATA_BLOB                     signing_key;
 125                 uint32                                  auth_session_info_seqnum;
 126                 [ignore] smbXsrv_connection             *connection;
 127         } smbXsrv_channel_global0;
 128
 129         typedef struct {
 130                 [ignore] db_record                      *db_rec;
 131                 uint32                                  session_global_id;
 132                 hyper                                   session_wire_id;
 133                 NTTIME                                  creation_time;
 134                 NTTIME                                  expiration_time;
 135                 /*
 136                  * auth_session is NULL until the
 137                  * session is valid for the first time.
 138                  */
 139                 NTTIME                                  auth_time;
 140                 uint32                                  auth_session_info_seqnum;
 141                 auth_session_info                       *auth_session_info;
 142                 uint16                                  connection_dialect;
 143                 boolean8                                signing_required;
 144                 boolean8                                encryption_required;
 145                 [noprint] DATA_BLOB                     signing_key;
 146                 [noprint] DATA_BLOB                     encryption_key;
 147                 [noprint] DATA_BLOB                     decryption_key;
 148                 [noprint] DATA_BLOB                     application_key;
 149                 [range(1, 1024)] uint32                 num_channels;
 150                 smbXsrv_channel_global0                 channels[num_channels];
 151         } smbXsrv_session_global0;
 152
 153         typedef union {
 154                 [case(0)] smbXsrv_session_global0       *info0;
 155                 [default] hyper                         *dummy;
 156         } smbXsrv_session_globalU;
 157
 158         typedef [public] struct {
 159                 smbXsrv_version_values                  version;
 160                 uint32                                  seqnum;
 161                 [switch_is(version)] smbXsrv_session_globalU info;
 162         } smbXsrv_session_globalB;
 163
 164         void smbXsrv_session_global_decode(
 165                 [in] smbXsrv_session_globalB blob
 166                 );
 167
 168         /*
 169          * The main server code should just work with
 170          * 'struct smbXsrv_session' and never use
 171          * smbXsrv_session0, smbXsrv_sessionU
 172          * and smbXsrv_sessionB directly.
 173          *
 174          * If we need to change the smbXsrv_session,
 175          * we can just rename smbXsrv_session
 176          * to smbXsrv_session0 and add a new
 177          * smbXsrv_session for version 1
 178          * and could implement transparent mapping.
 179          */
 180
 181         typedef struct {
 182                 [ignore] smbXsrv_session_auth0          *prev;
 183                 smbXsrv_session_auth0                   *next;
 184                 [ignore] smbXsrv_session                *session;
 185                 [ignore] smbXsrv_connection             *connection;
 186                 [ignore] gensec_security                *gensec;
 187                 [ignore] smbXsrv_preauth                *preauth;
 188                 uint8                                   in_flags;
 189                 uint8                                   in_security_mode;
 190                 NTTIME                                  creation_time;
 191                 NTTIME                                  idle_time;
 192         } smbXsrv_session_auth0;
 193
 194         typedef struct {
 195                 [ignore] smbXsrv_session_table          *table;
 196                 [ignore] db_record                      *db_rec;
 197                 [ignore] smbXsrv_client                 *client;
 198                 uint32                                  local_id;
 199                 [ref] smbXsrv_session_global0           *global;
 200                 NTSTATUS                                status;
 201                 NTTIME                                  idle_time;
 202                 hyper                                   nonce_high_random;
 203                 hyper                                   nonce_high_max;
 204                 hyper                                   nonce_high;
 205                 hyper                                   nonce_low;
 206                 [ignore] user_struct                    *compat;
 207                 [ignore] smbXsrv_tcon_table             *tcon_table;
 208                 smbXsrv_session_auth0                   *pending_auth;
 209                 boolean8                                encryption_desired;
 210         } smbXsrv_session;
 211
 212         typedef union {
 213                 [case(0)] smbXsrv_session               *info0;
 214                 [default] hyper                         *dummy;
 215         } smbXsrv_sessionU;
 216
 217         typedef [public] struct {
 218                 smbXsrv_version_values                  version;
 219                 [value(0)] uint32                       reserved;
 220                 [switch_is(version)] smbXsrv_sessionU   info;
 221         } smbXsrv_sessionB;
 222
 223         void smbXsrv_session_decode(
 224                 [in] smbXsrv_sessionB blob
 225                 );
 226
 227         /*
 228          * smbXsrv_session_close is use in the MSG_SMBXSRV_SESSION_CLOSE
 229          * message
 230          */
 231         typedef struct {
 232                 uint32                                  old_session_global_id;
 233                 hyper                                   old_session_wire_id;
 234                 NTTIME                                  old_creation_time;
 235                 hyper                                   new_session_wire_id;
 236         } smbXsrv_session_close0;
 237
 238         typedef union {
 239                 [case(0)] smbXsrv_session_close0        *info0;
 240                 [default] hyper                         *dummy;
 241         } smbXsrv_session_closeU;
 242
 243         typedef [public] struct {
 244                 smbXsrv_version_values                  version;
 245                 [value(0)] uint32                       reserved;
 246                 [switch_is(version)] smbXsrv_session_closeU     info;
 247         } smbXsrv_session_closeB;
 248
 249         void smbXsrv_session_close_decode(
 250                 [in] smbXsrv_session_closeB blob
 251                 );
 252
 253         /* tree connects */
 254
 255         typedef struct {
 256                 [ignore] db_record                      *db_rec;
 257                 uint32                                  tcon_global_id;
 258                 uint32                                  tcon_wire_id;
 259                 server_id                               server_id;
 260                 NTTIME                                  creation_time;
 261                 [charset(UTF8),string] char             share_name[];
 262                 boolean8                                encryption_required;
 263                 /*
 264                  * for SMB1 this is the session that the tcon was opened on
 265                  */
 266                 uint32                                  session_global_id;
 267         } smbXsrv_tcon_global0;
 268
 269         typedef union {
 270                 [case(0)] smbXsrv_tcon_global0          *info0;
 271                 [default] hyper                         *dummy;
 272         } smbXsrv_tcon_globalU;
 273
 274         typedef [public] struct {
 275                 smbXsrv_version_values                  version;
 276                 uint32                                  seqnum;
 277                 [switch_is(version)] smbXsrv_tcon_globalU info;
 278         } smbXsrv_tcon_globalB;
 279
 280         void smbXsrv_tcon_global_decode(
 281                 [in] smbXsrv_tcon_globalB blob
 282                 );
 283
 284         /*
 285          * The main server code should just work with
 286          * 'struct smbXsrv_tcon' and never use
 287          * smbXsrv_tcon0, smbXsrv_tconU
 288          * and smbXsrv_tconB directly.
 289          *
 290          * If we need to change the smbXsrv_tcon,
 291          * we can just rename smbXsrv_tcon
 292          * to smbXsrv_tcon0 and add a new
 293          * smbXsrv_tcon for version 1
 294          * and could implement transparent mapping.
 295          */
 296         typedef struct {
 297                 [ignore] smbXsrv_tcon_table             *table;
 298                 [ignore] db_record                      *db_rec;
 299                 uint32                                  local_id;
 300                 [ref] smbXsrv_tcon_global0              *global;
 301                 NTSTATUS                                status;
 302                 NTTIME                                  idle_time;
 303                 [ignore] connection_struct              *compat;
 304                 boolean8                                encryption_desired;
 305         } smbXsrv_tcon;
 306
 307         typedef union {
 308                 [case(0)] smbXsrv_tcon                  *info0;
 309                 [default] hyper                         *dummy;
 310         } smbXsrv_tconU;
 311
 312         typedef [public] struct {
 313                 smbXsrv_version_values                  version;
 314                 [value(0)] uint32                       reserved;
 315                 [switch_is(version)] smbXsrv_tconU      info;
 316         } smbXsrv_tconB;
 317
 318         void smbXsrv_tcon_decode(
 319                 [in] smbXsrv_tconB blob
 320                 );
 321
 322         /* open files */
 323
 324         typedef struct {
 325                 [ignore] db_record                      *db_rec;
 326                 server_id                               server_id;
 327                 uint32                                  open_global_id;
 328                 hyper                                   open_persistent_id;
 329                 hyper                                   open_volatile_id;
 330                 dom_sid                                 open_owner;
 331                 NTTIME                                  open_time;
 332                 GUID                                    create_guid;
 333                 GUID                                    client_guid;
 334                 GUID                                    app_instance_id;
 335                 /*
 336                  * TODO: for durable/resilient/persistent handles we need more
 337                  *       things here. See [MS-SMB2] 3.3.1.10 Per Open
 338                  *
 339                  * NOTE: this is still version 0, which is not a stable format!
 340                  */
 341                 NTTIME                                  disconnect_time;
 342                 uint32                                  durable_timeout_msec;
 343                 boolean8                                durable;
 344                 DATA_BLOB                               backend_cookie;
 345         } smbXsrv_open_global0;
 346
 347         typedef union {
 348                 [case(0)] smbXsrv_open_global0          *info0;
 349                 [default] hyper                         *dummy;
 350         } smbXsrv_open_globalU;
 351
 352         typedef [public] struct {
 353
 354                 smbXsrv_version_values                  version;
 355                 uint32                                  seqnum;
 356                 [switch_is(version)] smbXsrv_open_globalU info;
 357         } smbXsrv_open_globalB;
 358
 359         void smbXsrv_open_global_decode(
 360                 [in] smbXsrv_open_globalB blob
 361                 );
 362
 363         /*
 364          * The main server code should just work with
 365          * 'struct smbXsrv_open' and never use
 366          * smbXsrv_open0, smbXsrv_openU
 367          * and smbXsrv_openB directly.
 368          *
 369          * If we need to change the smbXsrv_open,
 370          * we can just rename smbXsrv_open
 371          * to smbXsrv_open0 and add a new
 372          * smbXsrv_open for version 1
 373          * and could implement transparent mapping.
 374          */
 375         typedef struct {
 376                 [ignore] smbXsrv_open_table             *table;
 377                 [ignore] db_record                      *db_rec;
 378                 uint32                                  local_id;
 379                 [ref] smbXsrv_open_global0              *global;
 380                 NTSTATUS                                status;
 381                 NTTIME                                  idle_time;
 382                 [ignore] files_struct                   *compat;
 383         } smbXsrv_open;
 384
 385         typedef union {
 386                 [case(0)] smbXsrv_open                  *info0;
 387                 [default] hyper                         *dummy;
 388         } smbXsrv_openU;
 389
 390         typedef [public] struct {
 391                 smbXsrv_version_values                  version;
 392                 [value(0)] uint32                       reserved;
 393                 [switch_is(version)] smbXsrv_openU      info;
 394         } smbXsrv_openB;
 395
 396         void smbXsrv_open_decode(
 397                 [in] smbXsrv_openB blob
 398                 );
 399 }