rpcclient/cmd_netlogon.c

説明を見る。
00001 /* 
00002    Unix SMB/CIFS implementation.
00003    RPC pipe client
00004 
00005    Copyright (C) Tim Potter 2000
00006 
00007    This program is free software; you can redistribute it and/or modify
00008    it under the terms of the GNU General Public License as published by
00009    the Free Software Foundation; either version 2 of the License, or
00010    (at your option) any later version.
00011    
00012    This program is distributed in the hope that it will be useful,
00013    but WITHOUT ANY WARRANTY; without even the implied warranty of
00014    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00015    GNU General Public License for more details.
00016    
00017    You should have received a copy of the GNU General Public License
00018    along with this program; if not, write to the Free Software
00019    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
00020 */
00021 
00022 #include "includes.h"
00023 #include "rpcclient.h"
00024 
00025 static NTSTATUS cmd_netlogon_logon_ctrl2(struct rpc_pipe_client *cli, 
00026                                          TALLOC_CTX *mem_ctx, int argc, 
00027                                          const char **argv)
00028 {
00029         uint32 query_level = 1;
00030         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
00031 
00032         if (argc > 1) {
00033                 fprintf(stderr, "Usage: %s\n", argv[0]);
00034                 return NT_STATUS_OK;
00035         }
00036 
00037         result = rpccli_netlogon_logon_ctrl2(cli, mem_ctx, query_level);
00038 
00039         if (!NT_STATUS_IS_OK(result))
00040                 goto done;
00041 
00042         /* Display results */
00043 
00044  done:
00045         return result;
00046 }
00047 
00048 static WERROR cmd_netlogon_getanydcname(struct rpc_pipe_client *cli, 
00049                                         TALLOC_CTX *mem_ctx, int argc, 
00050                                         const char **argv)
00051 {
00052         fstring dcname;
00053         WERROR result = WERR_GENERAL_FAILURE;
00054 
00055         if (argc != 2) {
00056                 fprintf(stderr, "Usage: %s domainname\n", argv[0]);
00057                 return WERR_OK;
00058         }
00059 
00060         result = rpccli_netlogon_getanydcname(cli, mem_ctx, cli->cli->desthost, argv[1], dcname);
00061 
00062         if (!W_ERROR_IS_OK(result))
00063                 goto done;
00064 
00065         /* Display results */
00066 
00067         printf("%s\n", dcname);
00068 
00069  done:
00070         return result;
00071 }
00072 
00073 static void display_ds_domain_controller_info(TALLOC_CTX *mem_ctx, const struct DS_DOMAIN_CONTROLLER_INFO *info)
00074 {
00075         d_printf("domain_controller_name: %s\n", info->domain_controller_name);
00076         d_printf("domain_controller_address: %s\n", info->domain_controller_address);
00077         d_printf("domain_controller_address_type: %d\n", info->domain_controller_address_type);
00078         d_printf("domain_guid: %s\n", GUID_string(mem_ctx, info->domain_guid));
00079         d_printf("domain_name: %s\n", info->domain_name);
00080         d_printf("dns_forest_name: %s\n", info->dns_forest_name);
00081         d_printf("flags: 0x%08x\n"
00082                  "\tIs a PDC:                                   %s\n"
00083                  "\tIs a GC of the forest:                      %s\n"
00084                  "\tIs an LDAP server:                          %s\n"
00085                  "\tSupports DS:                                %s\n"
00086                  "\tIs running a KDC:                           %s\n"
00087                  "\tIs running time services:                   %s\n"
00088                  "\tIs the closest DC:                          %s\n"
00089                  "\tIs writable:                                %s\n"
00090                  "\tHas a hardware clock:                       %s\n"
00091                  "\tIs a non-domain NC serviced by LDAP server: %s\n"
00092                  "\tDomainControllerName is a DNS name:         %s\n"
00093                  "\tDomainName is a DNS name:                   %s\n"
00094                  "\tDnsForestName is a DNS name:                %s\n",
00095                  info->flags,
00096                  (info->flags & ADS_PDC) ? "yes" : "no",
00097                  (info->flags & ADS_GC) ? "yes" : "no",
00098                  (info->flags & ADS_LDAP) ? "yes" : "no",
00099                  (info->flags & ADS_DS) ? "yes" : "no",
00100                  (info->flags & ADS_KDC) ? "yes" : "no",
00101                  (info->flags & ADS_TIMESERV) ? "yes" : "no",
00102                  (info->flags & ADS_CLOSEST) ? "yes" : "no",
00103                  (info->flags & ADS_WRITABLE) ? "yes" : "no",
00104                  (info->flags & ADS_GOOD_TIMESERV) ? "yes" : "no",
00105                  (info->flags & ADS_NDNC) ? "yes" : "no",
00106                  (info->flags & ADS_DNS_CONTROLLER) ? "yes":"no",
00107                  (info->flags & ADS_DNS_DOMAIN) ? "yes":"no",
00108                  (info->flags & ADS_DNS_FOREST) ? "yes":"no");
00109 
00110         d_printf("dc_site_name: %s\n", info->dc_site_name);
00111         d_printf("client_site_name: %s\n", info->client_site_name);
00112 }
00113 
00114 static WERROR cmd_netlogon_dsr_getdcname(struct rpc_pipe_client *cli,
00115                                          TALLOC_CTX *mem_ctx, int argc,
00116                                          const char **argv)
00117 {
00118         WERROR result;
00119         uint32 flags = DS_RETURN_DNS_NAME;
00120         const char *server_name = cli->cli->desthost;
00121         const char *domain_name;
00122         struct GUID domain_guid = GUID_zero();
00123         struct GUID site_guid = GUID_zero();
00124         struct DS_DOMAIN_CONTROLLER_INFO *info = NULL;
00125 
00126         if (argc < 2) {
00127                 fprintf(stderr, "Usage: %s [domainname] [domain_name] [domain_guid] [site_guid] [flags]\n", argv[0]);
00128                 return WERR_OK;
00129         }
00130 
00131         if (argc >= 2)
00132                 domain_name = argv[1];
00133 
00134         if (argc >= 3) {
00135                 if (!NT_STATUS_IS_OK(GUID_from_string(argv[2], &domain_guid))) {
00136                         return WERR_NOMEM;
00137                 }
00138         }
00139 
00140         if (argc >= 4) {
00141                 if (!NT_STATUS_IS_OK(GUID_from_string(argv[3], &site_guid))) {
00142                         return WERR_NOMEM;
00143                 }
00144         }
00145 
00146         if (argc >= 5)
00147                 sscanf(argv[4], "%x", &flags);
00148         
00149         result = rpccli_netlogon_dsr_getdcname(cli, mem_ctx, server_name, domain_name, 
00150                                                &domain_guid, &site_guid, flags,
00151                                                &info);
00152 
00153         if (W_ERROR_IS_OK(result)) {
00154                 d_printf("DsGetDcName gave\n");
00155                 display_ds_domain_controller_info(mem_ctx, info);
00156                 return WERR_OK;
00157         }
00158 
00159         printf("rpccli_netlogon_dsr_getdcname returned %s\n",
00160                dos_errstr(result));
00161 
00162         return result;
00163 }
00164 
00165 static WERROR cmd_netlogon_dsr_getdcnameex(struct rpc_pipe_client *cli,
00166                                            TALLOC_CTX *mem_ctx, int argc,
00167                                            const char **argv)
00168 {
00169         WERROR result;
00170         uint32 flags = DS_RETURN_DNS_NAME;
00171         const char *server_name = cli->cli->desthost;
00172         const char *domain_name;
00173         const char *site_name = NULL;
00174         struct GUID domain_guid = GUID_zero();
00175         struct DS_DOMAIN_CONTROLLER_INFO *info = NULL;
00176 
00177         if (argc < 2) {
00178                 fprintf(stderr, "Usage: %s [domainname] [domain_name] [domain_guid] [site_name] [flags]\n", argv[0]);
00179                 return WERR_OK;
00180         }
00181 
00182         if (argc >= 2)
00183                 domain_name = argv[1];
00184 
00185         if (argc >= 3) {
00186                 if (!NT_STATUS_IS_OK(GUID_from_string(argv[2], &domain_guid))) {
00187                         return WERR_NOMEM;
00188                 }
00189         }
00190 
00191         if (argc >= 4)
00192                 site_name = argv[3];
00193 
00194         if (argc >= 5)
00195                 sscanf(argv[4], "%x", &flags);
00196 
00197         result = rpccli_netlogon_dsr_getdcnameex(cli, mem_ctx, server_name, domain_name, 
00198                                                  &domain_guid, site_name, flags,
00199                                                  &info);
00200 
00201         if (W_ERROR_IS_OK(result)) {
00202                 d_printf("DsGetDcNameEx gave\n");
00203                 display_ds_domain_controller_info(mem_ctx, info);
00204                 return WERR_OK;
00205         }
00206 
00207         printf("rpccli_netlogon_dsr_getdcnameex returned %s\n",
00208                dos_errstr(result));
00209 
00210         return result;
00211 }
00212 
00213 static WERROR cmd_netlogon_dsr_getdcnameex2(struct rpc_pipe_client *cli,
00214                                             TALLOC_CTX *mem_ctx, int argc,
00215                                             const char **argv)
00216 {
00217         WERROR result;
00218         uint32 flags = DS_RETURN_DNS_NAME;
00219         const char *server_name = cli->cli->desthost;
00220         const char *domain_name = NULL;
00221         const char *client_account = NULL;
00222         uint32 mask = 0;
00223         const char *site_name = NULL;
00224         struct GUID domain_guid = GUID_zero();
00225         struct DS_DOMAIN_CONTROLLER_INFO *info = NULL;
00226 
00227         if (argc < 2) {
00228                 fprintf(stderr, "Usage: %s [domainname] [client_account] [acb_mask] [domain_name] [domain_guid] [site_name] [flags]\n", argv[0]);
00229                 return WERR_OK;
00230         }
00231 
00232         if (argc >= 2)
00233                 client_account = argv[1];
00234 
00235         if (argc >= 3)
00236                 mask = atoi(argv[2]);
00237         
00238         if (argc >= 4)
00239                 domain_name = argv[3];
00240 
00241         if (argc >= 5) {
00242                 if (!NT_STATUS_IS_OK(GUID_from_string(argv[4], &domain_guid))) {
00243                         return WERR_NOMEM;
00244                 }
00245         }
00246 
00247         if (argc >= 6)
00248                 site_name = argv[5];
00249 
00250         if (argc >= 7)
00251                 sscanf(argv[6], "%x", &flags);
00252 
00253         result = rpccli_netlogon_dsr_getdcnameex2(cli, mem_ctx, server_name, 
00254                                                   client_account, mask,
00255                                                   domain_name, &domain_guid,
00256                                                   site_name, flags,
00257                                                   &info);
00258 
00259         if (W_ERROR_IS_OK(result)) {
00260                 d_printf("DsGetDcNameEx2 gave\n");
00261                 display_ds_domain_controller_info(mem_ctx, info);
00262                 return WERR_OK;
00263         }
00264 
00265         printf("rpccli_netlogon_dsr_getdcnameex2 returned %s\n",
00266                dos_errstr(result));
00267 
00268         return result;
00269 }
00270 
00271 
00272 static WERROR cmd_netlogon_dsr_getsitename(struct rpc_pipe_client *cli,
00273                                            TALLOC_CTX *mem_ctx, int argc,
00274                                            const char **argv)
00275 {
00276         WERROR result;
00277         char *sitename;
00278 
00279         if (argc != 2) {
00280                 fprintf(stderr, "Usage: %s computername\n", argv[0]);
00281                 return WERR_OK;
00282         }
00283 
00284         result = rpccli_netlogon_dsr_getsitename(cli, mem_ctx, argv[1], &sitename);
00285 
00286         if (!W_ERROR_IS_OK(result)) {
00287                 printf("rpccli_netlogon_dsr_gesitename returned %s\n",
00288                        nt_errstr(werror_to_ntstatus(result)));
00289                 return result;
00290         }
00291 
00292         printf("Computer %s is on Site: %s\n", argv[1], sitename);
00293 
00294         return WERR_OK;
00295 }
00296 
00297 static NTSTATUS cmd_netlogon_logon_ctrl(struct rpc_pipe_client *cli, 
00298                                         TALLOC_CTX *mem_ctx, int argc, 
00299                                         const char **argv)
00300 {
00301 #if 0
00302         uint32 query_level = 1;
00303 #endif
00304         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
00305 
00306         if (argc > 1) {
00307                 fprintf(stderr, "Usage: %s\n", argv[0]);
00308                 return NT_STATUS_OK;
00309         }
00310 
00311 #if 0
00312         result = cli_netlogon_logon_ctrl(cli, mem_ctx, query_level);
00313         if (!NT_STATUS_IS_OK(result)) {
00314                 goto done;
00315         }
00316 #endif
00317 
00318         /* Display results */
00319 
00320         return result;
00321 }
00322 
00323 /* Display sam synchronisation information */
00324 
00325 static void display_sam_sync(uint32 num_deltas, SAM_DELTA_HDR *hdr_deltas,
00326                              SAM_DELTA_CTR *deltas)
00327 {
00328         fstring name;
00329         uint32 i, j;
00330 
00331         for (i = 0; i < num_deltas; i++) {
00332                 switch (hdr_deltas[i].type) {
00333                 case SAM_DELTA_DOMAIN_INFO:
00334                         unistr2_to_ascii(name,
00335                                          &deltas[i].domain_info.uni_dom_name,
00336                                          sizeof(name) - 1);
00337                         printf("Domain: %s\n", name);
00338                         break;
00339                 case SAM_DELTA_GROUP_INFO:
00340                         unistr2_to_ascii(name,
00341                                          &deltas[i].group_info.uni_grp_name,
00342                                          sizeof(name) - 1);
00343                         printf("Group: %s\n", name);
00344                         break;
00345                 case SAM_DELTA_ACCOUNT_INFO:
00346                         unistr2_to_ascii(name, 
00347                                          &deltas[i].account_info.uni_acct_name,
00348                                          sizeof(name) - 1);
00349                         printf("Account: %s\n", name);
00350                         break;
00351                 case SAM_DELTA_ALIAS_INFO:
00352                         unistr2_to_ascii(name, 
00353                                          &deltas[i].alias_info.uni_als_name,
00354                                          sizeof(name) - 1);
00355                         printf("Alias: %s\n", name);
00356                         break;
00357                 case SAM_DELTA_ALIAS_MEM: {
00358                         SAM_ALIAS_MEM_INFO *alias = &deltas[i].als_mem_info;
00359 
00360                         for (j = 0; j < alias->num_members; j++) {
00361                                 fstring sid_str;
00362 
00363                                 sid_to_string(sid_str, &alias->sids[j].sid);
00364 
00365                                 printf("%s\n", sid_str);
00366                         }
00367                         break;
00368                 }
00369                 case SAM_DELTA_GROUP_MEM: {
00370                         SAM_GROUP_MEM_INFO *group = &deltas[i].grp_mem_info;
00371 
00372                         for (j = 0; j < group->num_members; j++)
00373                                 printf("rid 0x%x, attrib 0x%08x\n", 
00374                                           group->rids[j], group->attribs[j]);
00375                         break;
00376                 }
00377                 case SAM_DELTA_MODIFIED_COUNT: {
00378                         SAM_DELTA_MOD_COUNT *mc = &deltas[i].mod_count;
00379 
00380                         printf("sam sequence update: 0x%04x\n", mc->seqnum);
00381                         break;
00382                 }                                  
00383                 default:
00384                         printf("unknown delta type 0x%02x\n", 
00385                                   hdr_deltas[i].type);
00386                         break;
00387                 }
00388         }
00389 }
00390 
00391 /* Perform sam synchronisation */
00392 
00393 static NTSTATUS cmd_netlogon_sam_sync(struct rpc_pipe_client *cli, 
00394                                       TALLOC_CTX *mem_ctx, int argc,
00395                                       const char **argv)
00396 {
00397         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
00398         uint32 database_id = 0, num_deltas;
00399         SAM_DELTA_HDR *hdr_deltas;
00400         SAM_DELTA_CTR *deltas;
00401 
00402         if (argc > 2) {
00403                 fprintf(stderr, "Usage: %s [database_id]\n", argv[0]);
00404                 return NT_STATUS_OK;
00405         }
00406 
00407         if (argc == 2)
00408                 database_id = atoi(argv[1]);
00409 
00410         /* Synchronise sam database */
00411 
00412         result = rpccli_netlogon_sam_sync(cli, mem_ctx, database_id,
00413                                        0, &num_deltas, &hdr_deltas, &deltas);
00414 
00415         if (!NT_STATUS_IS_OK(result))
00416                 goto done;
00417 
00418         /* Display results */
00419 
00420         display_sam_sync(num_deltas, hdr_deltas, deltas);
00421 
00422  done:
00423         return result;
00424 }
00425 
00426 /* Perform sam delta synchronisation */
00427 
00428 static NTSTATUS cmd_netlogon_sam_deltas(struct rpc_pipe_client *cli, 
00429                                         TALLOC_CTX *mem_ctx, int argc,
00430                                         const char **argv)
00431 {
00432         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
00433         uint32 database_id, num_deltas, tmp;
00434         SAM_DELTA_HDR *hdr_deltas;
00435         SAM_DELTA_CTR *deltas;
00436         uint64 seqnum;
00437 
00438         if (argc != 3) {
00439                 fprintf(stderr, "Usage: %s database_id seqnum\n", argv[0]);
00440                 return NT_STATUS_OK;
00441         }
00442 
00443         database_id = atoi(argv[1]);
00444         tmp = atoi(argv[2]);
00445 
00446         seqnum = tmp & 0xffff;
00447 
00448         result = rpccli_netlogon_sam_deltas(cli, mem_ctx, database_id,
00449                                          seqnum, &num_deltas, 
00450                                          &hdr_deltas, &deltas);
00451 
00452         if (!NT_STATUS_IS_OK(result))
00453                 goto done;
00454 
00455         /* Display results */
00456 
00457         display_sam_sync(num_deltas, hdr_deltas, deltas);
00458         
00459  done:
00460         return result;
00461 }
00462 
00463 /* Log on a domain user */
00464 
00465 static NTSTATUS cmd_netlogon_sam_logon(struct rpc_pipe_client *cli, 
00466                                        TALLOC_CTX *mem_ctx, int argc,
00467                                        const char **argv)
00468 {
00469         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
00470         int logon_type = NET_LOGON_TYPE;
00471         const char *username, *password;
00472         int auth_level = 2;
00473         uint32 logon_param = 0;
00474         const char *workstation = NULL;
00475 
00476         /* Check arguments */
00477 
00478         if (argc < 3 || argc > 7) {
00479                 fprintf(stderr, "Usage: samlogon <username> <password> [workstation]"
00480                         "[logon_type (1 or 2)] [auth level (2 or 3)] [logon_parameter]\n");
00481                 return NT_STATUS_OK;
00482         }
00483 
00484         username = argv[1];
00485         password = argv[2];
00486 
00487         if (argc >= 4) 
00488                 workstation = argv[3];
00489 
00490         if (argc >= 5)
00491                 sscanf(argv[4], "%i", &logon_type);
00492 
00493         if (argc >= 6)
00494                 sscanf(argv[5], "%i", &auth_level);
00495 
00496         if (argc == 7)
00497                 sscanf(argv[6], "%x", &logon_param);
00498 
00499         /* Perform the sam logon */
00500 
00501         result = rpccli_netlogon_sam_logon(cli, mem_ctx, logon_param, lp_workgroup(), username, password, workstation, logon_type);
00502 
00503         if (!NT_STATUS_IS_OK(result))
00504                 goto done;
00505 
00506  done:
00507         return result;
00508 }
00509 
00510 /* Change the trust account password */
00511 
00512 static NTSTATUS cmd_netlogon_change_trust_pw(struct rpc_pipe_client *cli, 
00513                                              TALLOC_CTX *mem_ctx, int argc,
00514                                              const char **argv)
00515 {
00516         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
00517 
00518         /* Check arguments */
00519 
00520         if (argc > 1) {
00521                 fprintf(stderr, "Usage: change_trust_pw");
00522                 return NT_STATUS_OK;
00523         }
00524 
00525         /* Perform the sam logon */
00526 
00527         result = trust_pw_find_change_and_store_it(cli, mem_ctx,
00528                                                    lp_workgroup());
00529 
00530         if (!NT_STATUS_IS_OK(result))
00531                 goto done;
00532 
00533  done:
00534         return result;
00535 }
00536 
00537 
00538 /* List of commands exported by this module */
00539 
00540 struct cmd_set netlogon_commands[] = {
00541 
00542         { "NETLOGON" },
00543 
00544         { "logonctrl2", RPC_RTYPE_NTSTATUS, cmd_netlogon_logon_ctrl2, NULL, PI_NETLOGON, NULL, "Logon Control 2",     "" },
00545         { "getanydcname", RPC_RTYPE_WERROR, NULL, cmd_netlogon_getanydcname, PI_NETLOGON, NULL, "Get trusted DC name",     "" },
00546         { "dsr_getdcname", RPC_RTYPE_WERROR, NULL, cmd_netlogon_dsr_getdcname, PI_NETLOGON, NULL, "Get trusted DC name",     "" },
00547         { "dsr_getdcnameex", RPC_RTYPE_WERROR, NULL, cmd_netlogon_dsr_getdcnameex, PI_NETLOGON, NULL, "Get trusted DC name",     "" },
00548         { "dsr_getdcnameex2", RPC_RTYPE_WERROR, NULL, cmd_netlogon_dsr_getdcnameex2, PI_NETLOGON, NULL, "Get trusted DC name",     "" },
00549         { "dsr_getsitename", RPC_RTYPE_WERROR, NULL, cmd_netlogon_dsr_getsitename, PI_NETLOGON, NULL, "Get sitename",     "" },
00550         { "logonctrl",  RPC_RTYPE_NTSTATUS, cmd_netlogon_logon_ctrl,  NULL, PI_NETLOGON, NULL, "Logon Control",       "" },
00551         { "samsync",    RPC_RTYPE_NTSTATUS, cmd_netlogon_sam_sync,    NULL, PI_NETLOGON, NULL, "Sam Synchronisation", "" },
00552         { "samdeltas",  RPC_RTYPE_NTSTATUS, cmd_netlogon_sam_deltas,  NULL, PI_NETLOGON, NULL, "Query Sam Deltas",    "" },
00553         { "samlogon",   RPC_RTYPE_NTSTATUS, cmd_netlogon_sam_logon,   NULL, PI_NETLOGON, NULL, "Sam Logon",           "" },
00554         { "change_trust_pw",   RPC_RTYPE_NTSTATUS, cmd_netlogon_change_trust_pw,   NULL, PI_NETLOGON, NULL, "Change Trust Account Password",           "" },
00555 
00556         { NULL }
00557 };

Sambaに対してSat Aug 29 21:23:22 2009に生成されました。  doxygen 1.4.7