source4/libcli/netlogon.c

   1 /* parser auto-generated by pidl, then hand-modified by abartlet */
   2
   3 #include "includes.h"
   4 #include "libcli/netlogon.h"
   5
   6 _PUBLIC_ enum ndr_err_code ndr_push_NETLOGON_SAM_LOGON_RESPONSE_EX_with_flags(struct ndr_push *ndr, int ndr_flags, const struct NETLOGON_SAM_LOGON_RESPONSE_EX *r)
   7 {
   8         {
   9                 uint32_t _flags_save_STRUCT = ndr->flags;
  10                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
  11                 if (ndr_flags & NDR_SCALARS) {
  12                         NDR_CHECK(ndr_push_align(ndr, 4));
  13                         NDR_CHECK(ndr_push_netlogon_command(ndr, NDR_SCALARS, r->command));
  14                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->sbz));
  15                         NDR_CHECK(ndr_push_nbt_server_type(ndr, NDR_SCALARS, r->server_type));
  16                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->domain_uuid));
  17                         NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->forest));
  18                         NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->dns_domain));
  19                         NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->pdc_dns_name));
  20                         NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->domain));
  21                         NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->pdc_name));
  22                         NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->user_name));
  23                         NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->server_site));
  24                         NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->client_site));
  25                         if (r->nt_version & NETLOGON_NT_VERSION_5EX_WITH_IP) {
  26                                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, ndr_size_nbt_sockaddr(&r->sockaddr, ndr->flags)));
  27                                 {
  28                                         struct ndr_push *_ndr_sockaddr;
  29                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_sockaddr, 0, ndr_size_nbt_sockaddr(&r->sockaddr, ndr->flags)));
  30                                         NDR_CHECK(ndr_push_nbt_sockaddr(_ndr_sockaddr, NDR_SCALARS|NDR_BUFFERS, &r->sockaddr));
  31                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_sockaddr, 0, ndr_size_nbt_sockaddr(&r->sockaddr, ndr->flags)));
  32                                 }
  33                         }
  34                         if (r->nt_version & NETLOGON_NT_VERSION_WITH_CLOSEST_SITE) {
  35                                 NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->next_closest_site));
  36                         }
  37                         NDR_CHECK(ndr_push_netlogon_nt_version_flags(ndr, NDR_SCALARS, r->nt_version));
  38                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lmnt_token));
  39                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lm20_token));
  40                 }
  41                 if (ndr_flags & NDR_BUFFERS) {
  42                         NDR_CHECK(ndr_push_GUID(ndr, NDR_BUFFERS, &r->domain_uuid));
  43                 }
  44                 ndr->flags = _flags_save_STRUCT;
  45         }
  46         return NDR_ERR_SUCCESS;
  47 }
  48
  49 static enum ndr_err_code ndr_pull_NETLOGON_SAM_LOGON_RESPONSE_EX_with_flags(struct ndr_pull *ndr, int ndr_flags, struct NETLOGON_SAM_LOGON_RESPONSE_EX *r,
  50                                                                             uint32_t nt_version_flags)
  51 {
  52         {
  53                 uint32_t _flags_save_STRUCT = ndr->flags;
  54                 ZERO_STRUCTP(r);
  55                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
  56                 if (ndr_flags & NDR_SCALARS) {
  57                         NDR_CHECK(ndr_pull_align(ndr, 4));
  58                         NDR_CHECK(ndr_pull_netlogon_command(ndr, NDR_SCALARS, &r->command));
  59                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->sbz));
  60                         NDR_CHECK(ndr_pull_nbt_server_type(ndr, NDR_SCALARS, &r->server_type));
  61                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->domain_uuid));
  62                         NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->forest));
  63                         NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->dns_domain));
  64                         NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->pdc_dns_name));
  65                         NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->domain));
  66                         NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->pdc_name));
  67                         NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->user_name));
  68                         NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->server_site));
  69                         NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->client_site));
  70                         if (nt_version_flags & NETLOGON_NT_VERSION_5EX_WITH_IP) {
  71                                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->sockaddr_size));
  72                                 {
  73                                         struct ndr_pull *_ndr_sockaddr;
  74                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_sockaddr, 0, r->sockaddr_size));
  75                                         NDR_CHECK(ndr_pull_nbt_sockaddr(_ndr_sockaddr, NDR_SCALARS|NDR_BUFFERS, &r->sockaddr));
  76                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_sockaddr, 0, r->sockaddr_size));
  77                                 }
  78                         }
  79                         if (nt_version_flags & NETLOGON_NT_VERSION_WITH_CLOSEST_SITE) {
  80                                 NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->next_closest_site));
  81                         }
  82                         NDR_CHECK(ndr_pull_netlogon_nt_version_flags(ndr, NDR_SCALARS, &r->nt_version));
  83                         if (r->nt_version != nt_version_flags) {
  84                                 return NDR_ERR_VALIDATE;
  85                         }
  86                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lmnt_token));
  87                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lm20_token));
  88                 }
  89                 if (ndr_flags & NDR_BUFFERS) {
  90                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_BUFFERS, &r->domain_uuid));
  91                 }
  92                 ndr->flags = _flags_save_STRUCT;
  93         }
  94         return NDR_ERR_SUCCESS;
  95 }
  96
  97 NTSTATUS push_netlogon_samlogon_response(DATA_BLOB *data, TALLOC_CTX *mem_ctx,
  98                                          struct smb_iconv_convenience *iconv_convenience,
  99                                          struct netlogon_samlogon_response *response)
 100 {
 101         enum ndr_err_code ndr_err;
 102         if (response->ntver == NETLOGON_NT_VERSION_1) {
 103                 ndr_err = ndr_push_struct_blob(data, mem_ctx,
 104                                                iconv_convenience,
 105                                                &response->nt4,
 106                                                (ndr_push_flags_fn_t)ndr_push_NETLOGON_SAM_LOGON_RESPONSE_NT40);
 107         } else if (response->ntver & NETLOGON_NT_VERSION_5EX) {
 108                 ndr_err = ndr_push_struct_blob(data, mem_ctx,
 109                                                iconv_convenience,
 110                                                &response->nt5_ex,
 111                                                (ndr_push_flags_fn_t)ndr_push_NETLOGON_SAM_LOGON_RESPONSE_EX_with_flags);
 112         } else if (response->ntver & NETLOGON_NT_VERSION_5) {
 113                 ndr_err = ndr_push_struct_blob(data, mem_ctx,
 114                                                iconv_convenience,
 115                                                &response->nt5,
 116                                                (ndr_push_flags_fn_t)ndr_push_NETLOGON_SAM_LOGON_RESPONSE);
 117         } else {
 118                 DEBUG(0, ("Asked to push unknown netlogon response type 0x%02x\n", response->ntver));
 119                 return NT_STATUS_INVALID_PARAMETER;
 120         }
 121         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 122                 DEBUG(2,("failed to push netlogon response of type 0x%02x\n",
 123                          response->ntver));
 124                 return ndr_map_error2ntstatus(ndr_err);
 125         }
 126         return NT_STATUS_OK;
 127 }
 128
 129 NTSTATUS pull_netlogon_samlogon_response(DATA_BLOB *data, TALLOC_CTX *mem_ctx,
 130                                          struct smb_iconv_convenience *iconv_convenience,
 131                                          struct netlogon_samlogon_response *response)
 132 {
 133         uint32_t ntver;
 134         enum ndr_err_code ndr_err;
 135
 136         if (data->length < 8) {
 137                 return NT_STATUS_BUFFER_TOO_SMALL;
 138         }
 139
 140         /* lmnttoken */
 141         if (SVAL(data->data, data->length - 4) != 0xffff) {
 142                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
 143         }
 144         /* lm20token */
 145         if (SVAL(data->data, data->length - 2) != 0xffff) {
 146                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
 147         }
 148
 149         ntver = IVAL(data->data, data->length - 8);
 150
 151         if (ntver == NETLOGON_NT_VERSION_1) {
 152                 ndr_err = ndr_pull_struct_blob_all(data, mem_ctx,
 153                                                    iconv_convenience,
 154                                                    &response->nt4,
 155                                                    (ndr_pull_flags_fn_t)ndr_pull_NETLOGON_SAM_LOGON_RESPONSE_NT40);
 156                 response->ntver = NETLOGON_NT_VERSION_1;
 157         } else if (ntver & NETLOGON_NT_VERSION_5EX) {
 158                 struct ndr_pull *ndr;
 159                 ndr = ndr_pull_init_blob(data, mem_ctx, iconv_convenience);
 160                 if (!ndr) {
 161                         return NT_STATUS_NO_MEMORY;
 162                 }
 163                 ndr_err = ndr_pull_NETLOGON_SAM_LOGON_RESPONSE_EX_with_flags(ndr, NDR_SCALARS|NDR_BUFFERS, &response->nt5_ex, ntver);
 164                 if (ndr->offset < ndr->data_size) {
 165                         ndr_err = ndr_pull_error(ndr, NDR_ERR_UNREAD_BYTES,
 166                                                  "not all bytes consumed ofs[%u] size[%u]",
 167                                                  ndr->offset, ndr->data_size);
 168                 }
 169                 response->ntver = NETLOGON_NT_VERSION_5EX;
 170
 171         } else if (ntver & NETLOGON_NT_VERSION_5) {
 172                 ndr_err = ndr_pull_struct_blob_all(data, mem_ctx,
 173                                                    iconv_convenience,
 174                                                    &response->nt5,
 175                                                    (ndr_pull_flags_fn_t)ndr_pull_NETLOGON_SAM_LOGON_RESPONSE);
 176                 response->ntver = NETLOGON_NT_VERSION_5;
 177         } else {
 178                 DEBUG(2,("failed to parse netlogon response of type 0x%02x - unknown response type\n",
 179                          ntver));
 180                 dump_data(10, data->data, data->length);
 181                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
 182         }
 183
 184         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 185                 DEBUG(2,("failed to parse netlogon response of type 0x%02x\n",
 186                          ntver));
 187                 dump_data(10, data->data, data->length);
 188                 return ndr_map_error2ntstatus(ndr_err);
 189         }
 190         return NT_STATUS_OK;
 191 }
 192
 193 void map_netlogon_samlogon_response(struct netlogon_samlogon_response *response)
 194 {
 195         struct NETLOGON_SAM_LOGON_RESPONSE_EX response_5_ex;
 196         switch (response->ntver) {
 197         case NETLOGON_NT_VERSION_5EX:
 198                 break;
 199         case NETLOGON_NT_VERSION_5:
 200                 ZERO_STRUCT(response_5_ex);
 201                 response_5_ex.command = response->nt5.command;
 202                 response_5_ex.pdc_name = response->nt5.pdc_name;
 203                 response_5_ex.user_name = response->nt5.user_name;
 204                 response_5_ex.domain = response->nt5.domain_name;
 205                 response_5_ex.domain_uuid = response->nt5.domain_uuid;
 206                 response_5_ex.forest = response->nt5.forest;
 207                 response_5_ex.dns_domain = response->nt5.dns_domain;
 208                 response_5_ex.pdc_dns_name = response->nt5.pdc_dns_name;
 209                 response_5_ex.sockaddr.pdc_ip = response->nt5.pdc_ip;
 210                 response_5_ex.server_type = response->nt5.server_type;
 211                 response_5_ex.nt_version = response->nt5.nt_version;
 212                 response_5_ex.lmnt_token = response->nt5.lmnt_token;
 213                 response_5_ex.lm20_token = response->nt5.lm20_token;
 214                 response->ntver = NETLOGON_NT_VERSION_5EX;
 215                 response->nt5_ex = response_5_ex;
 216                 break;
 217
 218         case NETLOGON_NT_VERSION_1:
 219                 ZERO_STRUCT(response_5_ex);
 220                 response_5_ex.command = response->nt4.command;
 221                 response_5_ex.pdc_name = response->nt4.server;
 222                 response_5_ex.user_name = response->nt4.user_name;
 223                 response_5_ex.domain = response->nt4.domain;
 224                 response_5_ex.nt_version = response->nt4.nt_version;
 225                 response_5_ex.lmnt_token = response->nt4.lmnt_token;
 226                 response_5_ex.lm20_token = response->nt4.lm20_token;
 227                 response->ntver = NETLOGON_NT_VERSION_5EX;
 228                 response->nt5_ex = response_5_ex;
 229                 break;
 230         }
 231         return;
 232 }
 233
 234 NTSTATUS push_nbt_netlogon_response(DATA_BLOB *data, TALLOC_CTX *mem_ctx,
 235                                     struct smb_iconv_convenience *iconv_convenience,
 236                                     struct nbt_netlogon_response *response)
 237 {
 238         NTSTATUS status = NT_STATUS_INVALID_NETWORK_RESPONSE;
 239         enum ndr_err_code ndr_err;
 240         switch (response->response_type) {
 241         case NETLOGON_GET_PDC:
 242                 ndr_err = ndr_push_struct_blob(data, mem_ctx, iconv_convenience, &response->get_pdc,
 243                                                (ndr_push_flags_fn_t)ndr_push_nbt_netlogon_response_from_pdc);
 244                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 245                         status = ndr_map_error2ntstatus(ndr_err);
 246                         DEBUG(0,("Failed to parse netlogon packet of length %d: %s\n",
 247                                  (int)data->length, nt_errstr(status)));
 248                         if (DEBUGLVL(10)) {
 249                                 file_save("netlogon.dat", data->data, data->length);
 250                         }
 251                         return status;
 252                 }
 253                 status = NT_STATUS_OK;
 254                 break;
 255         case NETLOGON_SAMLOGON:
 256                 status = push_netlogon_samlogon_response(data, mem_ctx, iconv_convenience, &response->samlogon);
 257                 break;
 258         }
 259         return status;
 260 }
 261
 262
 263 NTSTATUS pull_nbt_netlogon_response(DATA_BLOB *data, TALLOC_CTX *mem_ctx,
 264                                          struct smb_iconv_convenience *iconv_convenience,
 265                                          struct nbt_netlogon_response *response)
 266 {
 267         NTSTATUS status = NT_STATUS_INVALID_NETWORK_RESPONSE;
 268         enum netlogon_command command;
 269         enum ndr_err_code ndr_err;
 270         if (data->length < 4) {
 271                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
 272         }
 273
 274         command = SVAL(data->data, 0);
 275
 276         switch (command) {
 277         case NETLOGON_RESPONSE_FROM_PDC:
 278                 ndr_err = ndr_pull_struct_blob_all(data, mem_ctx, iconv_convenience, &response->get_pdc,
 279                                                    (ndr_pull_flags_fn_t)ndr_pull_nbt_netlogon_response_from_pdc);
 280                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 281                         status = ndr_map_error2ntstatus(ndr_err);
 282                         DEBUG(0,("Failed to parse netlogon packet of length %d: %s\n",
 283                                  (int)data->length, nt_errstr(status)));
 284                         if (DEBUGLVL(10)) {
 285                                 file_save("netlogon.dat", data->data, data->length);
 286                         }
 287                         return status;
 288                 }
 289                 status = NT_STATUS_OK;
 290                 response->response_type = NETLOGON_GET_PDC;
 291                 break;
 292         case LOGON_SAM_LOGON_RESPONSE:
 293         case LOGON_SAM_LOGON_PAUSE_RESPONSE:
 294         case LOGON_SAM_LOGON_USER_UNKNOWN:
 295         case LOGON_SAM_LOGON_RESPONSE_EX:
 296         case LOGON_SAM_LOGON_PAUSE_RESPONSE_EX:
 297         case LOGON_SAM_LOGON_USER_UNKNOWN_EX:
 298                 status = pull_netlogon_samlogon_response(data, mem_ctx, iconv_convenience, &response->samlogon);
 299                 response->response_type = NETLOGON_SAMLOGON;
 300                 break;
 301
 302         /* These levels are queries, not responses */
 303         case LOGON_PRIMARY_QUERY:
 304         case NETLOGON_ANNOUNCE_UAS:
 305         case LOGON_SAM_LOGON_REQUEST:
 306                 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
 307         }
 308
 309         return status;
 310
 311 }