source4/torture/nbt/dgram.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    NBT dgram testing
   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 "includes.h"
  24 #include "libcli/nbt/libnbt.h"
  25 #include "libcli/dgram/libdgram.h"
  26 #include "librpc/gen_ndr/ndr_nbt.h"
  27 #include "librpc/gen_ndr/ndr_samr.h"
  28 #include "lib/socket/socket.h"
  29 #include "lib/events/events.h"
  30
  31 #define TEST_NAME "TORTURE_TEST"
  32
  33 /*
  34   reply handler for netlogon request
  35 */
  36 static void netlogon_handler(struct dgram_mailslot_handler *dgmslot,
  37                              struct nbt_dgram_packet *packet,
  38                              const char *src_address, int src_port)
  39 {
  40         NTSTATUS status;
  41         struct nbt_netlogon_packet netlogon;
  42         int *replies = dgmslot->private;
  43
  44         printf("netlogon reply from %s:%d\n", src_address, src_port);
  45
  46         status = dgram_mailslot_netlogon_parse(dgmslot, dgmslot, packet, &netlogon);
  47         if (!NT_STATUS_IS_OK(status)) {
  48                 printf("Failed to parse netlogon packet from %s:%d\n",
  49                        src_address, src_port);
  50                 return;
  51         }
  52
  53         NDR_PRINT_DEBUG(nbt_netlogon_packet, &netlogon);
  54
  55         (*replies)++;
  56 }
  57
  58
  59 /* test UDP/138 netlogon requests */
  60 static BOOL nbt_test_netlogon(TALLOC_CTX *mem_ctx,
  61                               struct nbt_name name, const char *address)
  62 {
  63         struct dgram_mailslot_handler *dgmslot;
  64         struct nbt_dgram_socket *dgmsock = nbt_dgram_socket_init(mem_ctx, NULL);
  65         const char *myaddress = talloc_strdup(dgmsock, iface_best_ip(address));
  66         struct nbt_netlogon_packet logon;
  67         struct nbt_name myname;
  68         NTSTATUS status;
  69         struct timeval tv = timeval_current();
  70         int replies = 0;
  71
  72         /* try receiving replies on port 138 first, which will only
  73            work if we are root and smbd/nmbd are not running - fall
  74            back to listening on any port, which means replies from
  75            some windows versions won't be seen */
  76         status = socket_listen(dgmsock->sock, myaddress, lp_dgram_port(), 0, 0);
  77         if (!NT_STATUS_IS_OK(status)) {
  78                 socket_listen(dgmsock->sock, myaddress, 0, 0, 0);
  79         }
  80
  81         /* setup a temporary mailslot listener for replies */
  82         dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
  83                                       netlogon_handler, &replies);
  84
  85
  86         ZERO_STRUCT(logon);
  87         logon.command = NETLOGON_QUERY_FOR_PDC;
  88         logon.req.pdc.computer_name = TEST_NAME;
  89         logon.req.pdc.mailslot_name = dgmslot->mailslot_name;
  90         logon.req.pdc.unicode_name  = TEST_NAME;
  91         logon.req.pdc.nt_version    = 1;
  92         logon.req.pdc.lmnt_token    = 0xFFFF;
  93         logon.req.pdc.lm20_token    = 0xFFFF;
  94
  95         myname.name = TEST_NAME;
  96         myname.type = NBT_NAME_CLIENT;
  97         myname.scope = NULL;
  98
  99         status = dgram_mailslot_netlogon_send(dgmsock, &name, address,
 100                                               0, &myname, &logon);
 101         if (!NT_STATUS_IS_OK(status)) {
 102                 printf("Failed to send netlogon request - %s\n", nt_errstr(status));
 103                 goto failed;
 104         }
 105
 106
 107         while (timeval_elapsed(&tv) < 5 && replies == 0) {
 108                 event_loop_once(dgmsock->event_ctx);
 109         }
 110
 111         talloc_free(dgmsock);
 112         return True;
 113
 114 failed:
 115         talloc_free(dgmsock);
 116         return False;
 117 }
 118
 119
 120 /* test UDP/138 netlogon requests */
 121 static BOOL nbt_test_netlogon2(TALLOC_CTX *mem_ctx,
 122                               struct nbt_name name, const char *address)
 123 {
 124         struct dgram_mailslot_handler *dgmslot;
 125         struct nbt_dgram_socket *dgmsock = nbt_dgram_socket_init(mem_ctx, NULL);
 126         const char *myaddress = talloc_strdup(dgmsock, iface_best_ip(address));
 127         struct nbt_netlogon_packet logon;
 128         struct nbt_name myname;
 129         NTSTATUS status;
 130         struct timeval tv = timeval_current();
 131         int replies = 0;
 132
 133         /* try receiving replies on port 138 first, which will only
 134            work if we are root and smbd/nmbd are not running - fall
 135            back to listening on any port, which means replies from
 136            some windows versions won't be seen */
 137         status = socket_listen(dgmsock->sock, myaddress, lp_dgram_port(), 0, 0);
 138         if (!NT_STATUS_IS_OK(status)) {
 139                 socket_listen(dgmsock->sock, myaddress, 0, 0, 0);
 140         }
 141
 142         /* setup a temporary mailslot listener for replies */
 143         dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
 144                                       netlogon_handler, &replies);
 145
 146
 147         ZERO_STRUCT(logon);
 148         logon.command = NETLOGON_QUERY_FOR_PDC2;
 149         logon.req.pdc2.request_count = 0;
 150         logon.req.pdc2.computer_name = TEST_NAME;
 151         logon.req.pdc2.user_name     = "";
 152         logon.req.pdc2.mailslot_name = dgmslot->mailslot_name;
 153         logon.req.pdc2.nt_version    = 11;
 154         logon.req.pdc2.lmnt_token    = 0xFFFF;
 155         logon.req.pdc2.lm20_token    = 0xFFFF;
 156
 157         myname.name = TEST_NAME;
 158         myname.type = NBT_NAME_CLIENT;
 159         myname.scope = NULL;
 160
 161         status = dgram_mailslot_netlogon_send(dgmsock, &name, address,
 162                                               0, &myname, &logon);
 163         if (!NT_STATUS_IS_OK(status)) {
 164                 printf("Failed to send netlogon request - %s\n", nt_errstr(status));
 165                 goto failed;
 166         }
 167
 168
 169         while (timeval_elapsed(&tv) < 5 && replies == 0) {
 170                 event_loop_once(dgmsock->event_ctx);
 171         }
 172
 173         talloc_free(dgmsock);
 174         return True;
 175
 176 failed:
 177         talloc_free(dgmsock);
 178         return False;
 179 }
 180
 181
 182 /*
 183   reply handler for ntlogon request
 184 */
 185 static void ntlogon_handler(struct dgram_mailslot_handler *dgmslot,
 186                              struct nbt_dgram_packet *packet,
 187                              const char *src_address, int src_port)
 188 {
 189         NTSTATUS status;
 190         struct nbt_ntlogon_packet ntlogon;
 191         int *replies = dgmslot->private;
 192
 193         printf("ntlogon reply from %s:%d\n", src_address, src_port);
 194
 195         status = dgram_mailslot_ntlogon_parse(dgmslot, dgmslot, packet, &ntlogon);
 196         if (!NT_STATUS_IS_OK(status)) {
 197                 printf("Failed to parse ntlogon packet from %s:%d\n",
 198                        src_address, src_port);
 199                 return;
 200         }
 201
 202         NDR_PRINT_DEBUG(nbt_ntlogon_packet, &ntlogon);
 203
 204         (*replies)++;
 205 }
 206
 207
 208 /* test UDP/138 ntlogon requests */
 209 static BOOL nbt_test_ntlogon(TALLOC_CTX *mem_ctx,
 210                              struct nbt_name name, const char *address)
 211 {
 212         struct dgram_mailslot_handler *dgmslot;
 213         struct nbt_dgram_socket *dgmsock = nbt_dgram_socket_init(mem_ctx, NULL);
 214         const char *myaddress = talloc_strdup(dgmsock, iface_best_ip(address));
 215         struct nbt_ntlogon_packet logon;
 216         struct nbt_name myname;
 217         NTSTATUS status;
 218         struct timeval tv = timeval_current();
 219         int replies = 0;
 220         struct test_join *join_ctx;
 221         const char *password;
 222         const char *dom_sid;
 223
 224         join_ctx = torture_join_domain(TEST_NAME, lp_workgroup(),
 225                                        ACB_WSTRUST, &password);
 226         if (join_ctx == NULL) {
 227                 printf("Failed to join domain %s as %s\n", lp_workgroup(), TEST_NAME);
 228                 talloc_free(dgmsock);
 229                 return False;
 230         }
 231
 232         dom_sid = torture_join_sid(join_ctx);
 233
 234         /* try receiving replies on port 138 first, which will only
 235            work if we are root and smbd/nmbd are not running - fall
 236            back to listening on any port, which means replies from
 237            some windows versions won't be seen */
 238         status = socket_listen(dgmsock->sock, myaddress, lp_dgram_port(), 0, 0);
 239         if (!NT_STATUS_IS_OK(status)) {
 240                 socket_listen(dgmsock->sock, myaddress, 0, 0, 0);
 241         }
 242
 243         /* setup a temporary mailslot listener for replies */
 244         dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
 245                                       ntlogon_handler, &replies);
 246
 247
 248         ZERO_STRUCT(logon);
 249         logon.command = NTLOGON_SAM_LOGON;
 250         logon.req.logon.request_count = 0;
 251         logon.req.logon.computer_name = TEST_NAME;
 252         logon.req.logon.user_name     = TEST_NAME"$";
 253         logon.req.logon.mailslot_name = dgmslot->mailslot_name;
 254         logon.req.logon.acct_control  = ACB_WSTRUST;
 255         logon.req.logon.sid           = *dom_sid_parse_talloc(dgmslot, dom_sid);
 256         logon.req.logon.nt_version    = 1;
 257         logon.req.logon.lmnt_token    = 0xFFFF;
 258         logon.req.logon.lm20_token    = 0xFFFF;
 259
 260
 261         myname.name = TEST_NAME;
 262         myname.type = NBT_NAME_CLIENT;
 263         myname.scope = NULL;
 264
 265         status = dgram_mailslot_ntlogon_send(dgmsock, &name, address,
 266                                               0, &myname, &logon);
 267         if (!NT_STATUS_IS_OK(status)) {
 268                 printf("Failed to send ntlogon request - %s\n", nt_errstr(status));
 269                 goto failed;
 270         }
 271
 272
 273         while (timeval_elapsed(&tv) < 5 && replies == 0) {
 274                 event_loop_once(dgmsock->event_ctx);
 275         }
 276
 277         torture_leave_domain(join_ctx);
 278         talloc_free(dgmsock);
 279         return True;
 280
 281 failed:
 282         torture_leave_domain(join_ctx);
 283         talloc_free(dgmsock);
 284         return False;
 285 }
 286
 287
 288 /*
 289   test nbt dgram operations
 290 */
 291 BOOL torture_nbt_dgram(void)
 292 {
 293         const char *address;
 294         struct nbt_name name;
 295         TALLOC_CTX *mem_ctx = talloc_new(NULL);
 296         NTSTATUS status;
 297         BOOL ret = True;
 298
 299         name.name = lp_workgroup();
 300         name.type = NBT_NAME_LOGON;
 301         name.scope = NULL;
 302
 303         /* do an initial name resolution to find its IP */
 304         status = resolve_name(&name, mem_ctx, &address);
 305         if (!NT_STATUS_IS_OK(status)) {
 306                 printf("Failed to resolve %s - %s\n",
 307                        name.name, nt_errstr(status));
 308                 talloc_free(mem_ctx);
 309                 return False;
 310         }
 311
 312         ret &= nbt_test_netlogon(mem_ctx, name, address);
 313         ret &= nbt_test_netlogon2(mem_ctx, name, address);
 314         ret &= nbt_test_ntlogon(mem_ctx, name, address);
 315
 316         talloc_free(mem_ctx);
 317
 318         return ret;
 319 }