2001-11-25 03:18:11 +03:00
/*
Samba Unix / Linux SMB client library
net ads commands
Copyright ( C ) 2001 Andrew Tridgell ( tridge @ samba . org )
2001-12-20 06:54:52 +03:00
Copyright ( C ) 2001 Remus Koos ( remuskoos @ yahoo . com )
2002-02-02 05:06:03 +03:00
Copyright ( C ) 2002 Jim McDonough ( jmcd @ us . ibm . com )
2001-11-25 03:18:11 +03:00
This program is free software ; you can redistribute it and / or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation ; either version 2 of the License , or
( at your option ) any later version .
This program is distributed in the hope that it will be useful ,
but WITHOUT ANY WARRANTY ; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the
GNU General Public License for more details .
You should have received a copy of the GNU General Public License
along with this program ; if not , write to the Free Software
Foundation , Inc . , 675 Mass Ave , Cambridge , MA 0213 9 , USA .
*/
# include "includes.h"
2002-04-10 17:29:23 +04:00
# include "../utils/net.h"
2001-11-25 03:18:11 +03:00
# ifdef HAVE_ADS
2001-11-26 07:53:08 +03:00
int net_ads_usage ( int argc , const char * * argv )
2001-11-25 03:18:11 +03:00
{
d_printf (
2001-12-17 14:16:22 +03:00
" \n net ads join <org_unit> " \
2001-11-25 03:18:11 +03:00
" \n \t joins the local machine to a ADS realm \n " \
" \n net ads leave " \
2001-11-25 04:42:29 +03:00
" \n \t removes the local machine from a ADS realm \n " \
2002-08-17 18:45:04 +04:00
" \n net ads testjoin " \
" \n \t tests that an exiting join is OK \n " \
2001-11-25 04:42:29 +03:00
" \n net ads user " \
2002-07-15 14:35:28 +04:00
" \n \t list, add, or delete users in the realm \n " \
2001-11-25 04:42:29 +03:00
" \n net ads group " \
2002-07-15 14:35:28 +04:00
" \n \t list, add, or delete groups in the realm \n " \
2001-12-13 16:19:20 +03:00
" \n net ads info " \
" \n \t shows some info on the server \n " \
2001-11-25 04:42:29 +03:00
" \n net ads status " \
" \n \t dump the machine account details to stdout \n "
2003-01-15 21:57:41 +03:00
" \n net ads lookup " \
" \n \t perform a CLDAP search on the server \n "
2003-12-26 22:38:36 +03:00
" \n net ads password <username@realm> <password> -Uadmin_username@realm%%admin_pass " \
2002-07-15 14:35:28 +04:00
" \n \t change a user's password using an admin account " \
2003-12-26 22:38:36 +03:00
" \n \t (note: use realm in UPPERCASE, prompts if password is obmitted) \n " \
2003-04-15 02:27:09 +04:00
" \n net ads changetrustpw " \
2002-07-15 14:35:28 +04:00
" \n \t change the trust account password of this machine in the AD tree \n " \
" \n net ads printer [info | publish | remove] <printername> <servername> " \
" \n \t lookup, add, or remove directory entry for a printer \n " \
" \n net ads search " \
" \n \t perform a raw LDAP search and dump the results \n "
2003-03-18 01:33:34 +03:00
" \n net ads dn " \
" \n \t perform a raw LDAP search and dump attributes of a particular DN \n "
2004-06-23 01:58:35 +04:00
" \n net ads keytab " \
" \n \t creates and updates the kerberos system keytab file \n "
2001-11-25 03:18:11 +03:00
) ;
return - 1 ;
}
2001-12-13 16:19:20 +03:00
2002-09-25 19:19:00 +04:00
/*
this implements the CLDAP based netlogon lookup requests
for finding the domain controller of a ADS domain
*/
static int net_ads_lookup ( int argc , const char * * argv )
{
ADS_STRUCT * ads ;
2003-07-27 07:42:10 +04:00
ads = ads_init ( NULL , opt_target_workgroup , opt_host ) ;
2002-09-25 19:19:00 +04:00
if ( ads ) {
ads - > auth . flags | = ADS_AUTH_NO_BIND ;
}
ads_connect ( ads ) ;
if ( ! ads | | ! ads - > config . realm ) {
d_printf ( " Didn't find the cldap server! \n " ) ;
return - 1 ;
}
return ads_cldap_netlogon ( ads ) ;
}
2001-12-13 16:19:20 +03:00
static int net_ads_info ( int argc , const char * * argv )
{
ADS_STRUCT * ads ;
2003-07-27 07:42:10 +04:00
ads = ads_init ( NULL , opt_target_workgroup , opt_host ) ;
2002-08-17 18:45:04 +04:00
if ( ads ) {
2002-09-25 19:19:00 +04:00
ads - > auth . flags | = ADS_AUTH_NO_BIND ;
2002-08-17 18:45:04 +04:00
}
2001-12-13 16:19:20 +03:00
ads_connect ( ads ) ;
2002-08-17 18:45:04 +04:00
if ( ! ads | | ! ads - > config . realm ) {
2001-12-13 16:19:20 +03:00
d_printf ( " Didn't find the ldap server! \n " ) ;
return - 1 ;
}
2002-08-17 18:45:04 +04:00
d_printf ( " LDAP server: %s \n " , inet_ntoa ( ads - > ldap_ip ) ) ;
d_printf ( " LDAP server name: %s \n " , ads - > config . ldap_server_name ) ;
d_printf ( " Realm: %s \n " , ads - > config . realm ) ;
d_printf ( " Bind Path: %s \n " , ads - > config . bind_path ) ;
2001-12-13 16:19:20 +03:00
d_printf ( " LDAP port: %d \n " , ads - > ldap_port ) ;
2002-09-25 19:19:00 +04:00
d_printf ( " Server time: %s \n " , http_timestring ( ads - > config . current_time ) ) ;
2001-12-13 16:19:20 +03:00
2004-06-23 04:20:31 +04:00
d_printf ( " KDC server: %s \n " , ads - > auth . kdc_server ) ;
d_printf ( " Server time offset: %d \n " , ads - > auth . time_offset ) ;
2003-05-04 06:48:11 +04:00
2001-12-13 16:19:20 +03:00
return 0 ;
}
2003-02-24 06:06:45 +03:00
static void use_in_memory_ccache ( void ) {
/* Use in-memory credentials cache so we do not interfere with
* existing credentials */
setenv ( KRB5_ENV_CCNAME , " MEMORY:net_ads " , 1 ) ;
}
2001-12-13 16:19:20 +03:00
2001-11-25 04:31:07 +03:00
static ADS_STRUCT * ads_startup ( void )
2001-11-25 03:18:11 +03:00
{
ADS_STRUCT * ads ;
2001-12-19 15:21:12 +03:00
ADS_STATUS status ;
2002-01-26 01:07:46 +03:00
BOOL need_password = False ;
BOOL second_time = False ;
2003-09-04 23:45:04 +04:00
char * cp ;
2002-03-21 07:48:24 +03:00
2003-09-04 23:45:04 +04:00
/* lp_realm() should be handled by a command line param,
However , the join requires that realm be set in smb . conf
and compares our realm with the remote server ' s so this is
ok until someone needs more flexibility */
ads = ads_init ( lp_realm ( ) , opt_target_workgroup , opt_host ) ;
2001-11-25 04:06:56 +03:00
2001-12-08 14:18:56 +03:00
if ( ! opt_user_name ) {
opt_user_name = " administrator " ;
}
2003-02-24 06:06:45 +03:00
if ( opt_user_specified ) {
2002-01-26 01:07:46 +03:00
need_password = True ;
2003-02-24 06:06:45 +03:00
}
2002-01-26 01:07:46 +03:00
retry :
2003-10-23 18:33:19 +04:00
if ( ! opt_password & & need_password & & ! opt_machine_pass ) {
2001-12-08 14:18:56 +03:00
char * prompt ;
2004-03-14 06:47:03 +03:00
asprintf ( & prompt , " %s's password: " , opt_user_name ) ;
2001-12-08 14:18:56 +03:00
opt_password = getpass ( prompt ) ;
free ( prompt ) ;
}
2002-01-26 01:07:46 +03:00
2003-03-18 01:33:34 +03:00
if ( opt_password ) {
use_in_memory_ccache ( ) ;
2003-05-04 06:48:11 +04:00
ads - > auth . password = smb_xstrdup ( opt_password ) ;
2003-03-18 01:33:34 +03:00
}
2002-02-17 01:11:49 +03:00
2003-05-04 06:48:11 +04:00
ads - > auth . user_name = smb_xstrdup ( opt_user_name ) ;
/*
* If the username is of the form " name@realm " ,
* extract the realm and convert to upper case .
* This is only used to establish the connection .
*/
2003-05-13 01:27:54 +04:00
if ( ( cp = strchr ( ads - > auth . user_name , ' @ ' ) ) ! = 0 ) {
2003-05-04 06:48:11 +04:00
* cp + + = ' \0 ' ;
ads - > auth . realm = smb_xstrdup ( cp ) ;
2003-07-03 23:11:31 +04:00
strupper_m ( ads - > auth . realm ) ;
2003-05-04 06:48:11 +04:00
}
2001-12-08 14:18:56 +03:00
2001-12-19 15:21:12 +03:00
status = ads_connect ( ads ) ;
2003-05-04 06:48:11 +04:00
2001-12-19 15:21:12 +03:00
if ( ! ADS_ERR_OK ( status ) ) {
2002-01-26 01:07:46 +03:00
if ( ! need_password & & ! second_time ) {
need_password = True ;
second_time = True ;
goto retry ;
} else {
2002-04-04 20:47:24 +04:00
DEBUG ( 1 , ( " ads_connect: %s \n " , ads_errstr ( status ) ) ) ;
2002-01-26 01:07:46 +03:00
return NULL ;
}
2001-11-25 04:31:07 +03:00
}
return ads ;
}
2002-04-04 20:47:24 +04:00
/*
Check to see if connection can be made via ads .
ads_startup ( ) stores the password in opt_password if it needs to so
that rpc or rap can use it without re - prompting .
*/
int net_ads_check ( void )
{
ADS_STRUCT * ads ;
ads = ads_startup ( ) ;
if ( ! ads )
return - 1 ;
ads_destroy ( & ads ) ;
return 0 ;
}
2002-08-17 18:45:04 +04:00
/*
determine the netbios workgroup name for a domain
*/
static int net_ads_workgroup ( int argc , const char * * argv )
{
ADS_STRUCT * ads ;
TALLOC_CTX * ctx ;
2003-11-26 12:58:41 +03:00
const char * workgroup ;
2002-08-17 18:45:04 +04:00
if ( ! ( ads = ads_startup ( ) ) ) return - 1 ;
2002-12-20 23:21:31 +03:00
if ( ! ( ctx = talloc_init ( " net_ads_workgroup " ) ) ) {
2004-06-23 04:20:31 +04:00
ads_destroy ( & ads ) ;
2002-08-17 18:45:04 +04:00
return - 1 ;
}
if ( ! ADS_ERR_OK ( ads_workgroup_name ( ads , ctx , & workgroup ) ) ) {
d_printf ( " Failed to find workgroup for realm '%s' \n " ,
ads - > config . realm ) ;
talloc_destroy ( ctx ) ;
2004-06-23 04:20:31 +04:00
ads_destroy ( & ads ) ;
2002-08-17 18:45:04 +04:00
return - 1 ;
}
2002-04-04 20:47:24 +04:00
2002-08-17 18:45:04 +04:00
d_printf ( " Workgroup: %s \n " , workgroup ) ;
talloc_destroy ( ctx ) ;
2004-06-23 04:20:31 +04:00
ads_destroy ( & ads ) ;
2002-08-17 18:45:04 +04:00
return 0 ;
}
2002-09-25 19:19:00 +04:00
static BOOL usergrp_display ( char * field , void * * values , void * data_area )
2002-03-30 00:09:44 +03:00
{
char * * disp_fields = ( char * * ) data_area ;
if ( ! field ) { /* must be end of record */
2002-04-05 23:28:02 +04:00
if ( ! strchr_m ( disp_fields [ 0 ] , ' $ ' ) ) {
if ( disp_fields [ 1 ] )
2003-04-29 19:15:31 +04:00
d_printf ( " %-21.21s %s \n " ,
2002-04-05 23:28:02 +04:00
disp_fields [ 0 ] , disp_fields [ 1 ] ) ;
else
2002-07-15 14:35:28 +04:00
d_printf ( " %s \n " , disp_fields [ 0 ] ) ;
2002-04-05 23:28:02 +04:00
}
2002-03-30 00:09:44 +03:00
SAFE_FREE ( disp_fields [ 0 ] ) ;
SAFE_FREE ( disp_fields [ 1 ] ) ;
2002-09-25 19:19:00 +04:00
return True ;
2002-03-30 00:09:44 +03:00
}
2002-07-15 14:35:28 +04:00
if ( ! values ) /* must be new field, indicate string field */
2002-09-25 19:19:00 +04:00
return True ;
2002-03-30 00:09:44 +03:00
if ( StrCaseCmp ( field , " sAMAccountName " ) = = 0 ) {
2002-07-15 14:35:28 +04:00
disp_fields [ 0 ] = strdup ( ( char * ) values [ 0 ] ) ;
2002-03-30 00:09:44 +03:00
}
if ( StrCaseCmp ( field , " description " ) = = 0 )
2002-07-15 14:35:28 +04:00
disp_fields [ 1 ] = strdup ( ( char * ) values [ 0 ] ) ;
2002-09-25 19:19:00 +04:00
return True ;
2002-03-30 00:09:44 +03:00
}
2002-04-04 06:53:42 +04:00
static int net_ads_user_usage ( int argc , const char * * argv )
{
2002-04-05 05:36:28 +04:00
return net_help_user ( argc , argv ) ;
2002-04-04 06:53:42 +04:00
}
static int ads_user_add ( int argc , const char * * argv )
{
ADS_STRUCT * ads ;
ADS_STATUS status ;
2002-07-15 14:35:28 +04:00
char * upn , * userdn ;
2002-04-04 06:53:42 +04:00
void * res = NULL ;
int rc = - 1 ;
if ( argc < 1 ) return net_ads_user_usage ( argc , argv ) ;
2004-06-23 04:20:31 +04:00
if ( ! ( ads = ads_startup ( ) ) ) {
return - 1 ;
}
2002-04-04 06:53:42 +04:00
status = ads_find_user_acct ( ads , & res , argv [ 0 ] ) ;
if ( ! ADS_ERR_OK ( status ) ) {
2002-04-04 07:06:22 +04:00
d_printf ( " ads_user_add: %s \n " , ads_errstr ( status ) ) ;
2002-04-04 06:53:42 +04:00
goto done ;
}
if ( ads_count_replies ( ads , res ) ) {
d_printf ( " ads_user_add: User %s already exists \n " , argv [ 0 ] ) ;
goto done ;
}
2003-01-15 19:10:57 +03:00
status = ads_add_user_acct ( ads , argv [ 0 ] , opt_container , opt_comment ) ;
2002-04-04 06:53:42 +04:00
2002-07-15 14:35:28 +04:00
if ( ! ADS_ERR_OK ( status ) ) {
d_printf ( " Could not add user %s: %s \n " , argv [ 0 ] ,
ads_errstr ( status ) ) ;
goto done ;
}
/* if no password is to be set, we're done */
if ( argc = = 1 ) {
d_printf ( " User %s added \n " , argv [ 0 ] ) ;
rc = 0 ;
goto done ;
}
/* try setting the password */
2002-08-17 18:45:04 +04:00
asprintf ( & upn , " %s@%s " , argv [ 0 ] , ads - > config . realm ) ;
2003-05-30 23:51:09 +04:00
status = ads_krb5_set_password ( ads - > auth . kdc_server , upn , argv [ 1 ] ,
ads - > auth . time_offset ) ;
2002-07-15 14:35:28 +04:00
safe_free ( upn ) ;
2002-04-04 06:53:42 +04:00
if ( ADS_ERR_OK ( status ) ) {
d_printf ( " User %s added \n " , argv [ 0 ] ) ;
rc = 0 ;
2002-07-15 14:35:28 +04:00
goto done ;
}
/* password didn't set, delete account */
d_printf ( " Could not add user %s. Error setting password %s \n " ,
argv [ 0 ] , ads_errstr ( status ) ) ;
ads_msgfree ( ads , res ) ;
status = ads_find_user_acct ( ads , & res , argv [ 0 ] ) ;
if ( ADS_ERR_OK ( status ) ) {
userdn = ads_get_dn ( ads , res ) ;
ads_del_dn ( ads , userdn ) ;
ads_memfree ( ads , userdn ) ;
2002-04-04 06:53:42 +04:00
}
done :
if ( res )
ads_msgfree ( ads , res ) ;
ads_destroy ( & ads ) ;
return rc ;
}
static int ads_user_info ( int argc , const char * * argv )
2001-11-25 04:31:07 +03:00
{
ADS_STRUCT * ads ;
2001-12-19 15:21:12 +03:00
ADS_STATUS rc ;
2001-11-25 04:31:07 +03:00
void * res ;
2002-04-04 06:53:42 +04:00
const char * attrs [ ] = { " memberOf " , NULL } ;
char * searchstring = NULL ;
char * * grouplist ;
2003-02-01 10:59:29 +03:00
char * escaped_user = escape_ldap_string_alloc ( argv [ 0 ] ) ;
2002-04-04 06:53:42 +04:00
2004-06-23 04:20:31 +04:00
if ( argc < 1 ) {
return net_ads_user_usage ( argc , argv ) ;
}
2002-03-14 20:56:33 +03:00
2004-06-23 04:20:31 +04:00
if ( ! ( ads = ads_startup ( ) ) ) {
return - 1 ;
}
2001-11-25 04:31:07 +03:00
2003-02-01 10:59:29 +03:00
if ( ! escaped_user ) {
d_printf ( " ads_user_info: failed to escape user %s \n " , argv [ 0 ] ) ;
2004-06-23 04:20:31 +04:00
ads_destroy ( & ads ) ;
return - 1 ;
2003-02-01 10:59:29 +03:00
}
asprintf ( & searchstring , " (sAMAccountName=%s) " , escaped_user ) ;
2002-04-04 06:53:42 +04:00
rc = ads_search ( ads , & res , searchstring , attrs ) ;
safe_free ( searchstring ) ;
2001-11-25 04:31:07 +03:00
2002-03-20 01:16:19 +03:00
if ( ! ADS_ERR_OK ( rc ) ) {
d_printf ( " ads_search: %s \n " , ads_errstr ( rc ) ) ;
2004-06-23 04:20:31 +04:00
ads_destroy ( & ads ) ;
2002-03-20 01:16:19 +03:00
return - 1 ;
}
2002-03-30 00:09:44 +03:00
2002-04-04 06:53:42 +04:00
grouplist = ldap_get_values ( ads - > ld , res , " memberOf " ) ;
if ( grouplist ) {
int i ;
char * * groupname ;
for ( i = 0 ; grouplist [ i ] ; i + + ) {
groupname = ldap_explode_dn ( grouplist [ i ] , 1 ) ;
2002-07-15 14:35:28 +04:00
d_printf ( " %s \n " , groupname [ 0 ] ) ;
2002-04-04 06:53:42 +04:00
ldap_value_free ( groupname ) ;
}
ldap_value_free ( grouplist ) ;
}
2002-03-30 00:09:44 +03:00
ads_msgfree ( ads , res ) ;
2001-11-29 09:21:56 +03:00
ads_destroy ( & ads ) ;
2001-11-25 04:31:07 +03:00
return 0 ;
}
2002-04-04 06:53:42 +04:00
static int ads_user_delete ( int argc , const char * * argv )
{
ADS_STRUCT * ads ;
ADS_STATUS rc ;
void * res ;
char * userdn ;
2004-06-23 04:20:31 +04:00
if ( argc < 1 ) {
return net_ads_user_usage ( argc , argv ) ;
}
2002-04-04 06:53:42 +04:00
2004-06-23 04:20:31 +04:00
if ( ! ( ads = ads_startup ( ) ) ) {
return - 1 ;
}
2002-04-04 06:53:42 +04:00
rc = ads_find_user_acct ( ads , & res , argv [ 0 ] ) ;
if ( ! ADS_ERR_OK ( rc ) ) {
DEBUG ( 0 , ( " User %s does not exist \n " , argv [ 0 ] ) ) ;
2004-06-23 04:20:31 +04:00
ads_destroy ( & ads ) ;
2002-04-04 06:53:42 +04:00
return - 1 ;
}
userdn = ads_get_dn ( ads , res ) ;
ads_msgfree ( ads , res ) ;
rc = ads_del_dn ( ads , userdn ) ;
ads_memfree ( ads , userdn ) ;
if ( ! ADS_ERR_OK ( rc ) ) {
d_printf ( " User %s deleted \n " , argv [ 0 ] ) ;
2004-06-23 04:20:31 +04:00
ads_destroy ( & ads ) ;
2002-04-04 06:53:42 +04:00
return 0 ;
}
d_printf ( " Error deleting user %s: %s \n " , argv [ 0 ] ,
2002-04-04 07:06:22 +04:00
ads_errstr ( rc ) ) ;
2004-06-23 04:20:31 +04:00
ads_destroy ( & ads ) ;
2002-04-04 06:53:42 +04:00
return - 1 ;
}
2002-04-04 20:47:24 +04:00
int net_ads_user ( int argc , const char * * argv )
2002-04-04 06:53:42 +04:00
{
struct functable func [ ] = {
{ " ADD " , ads_user_add } ,
{ " INFO " , ads_user_info } ,
{ " DELETE " , ads_user_delete } ,
{ NULL , NULL }
} ;
ADS_STRUCT * ads ;
ADS_STATUS rc ;
const char * shortattrs [ ] = { " sAMAccountName " , NULL } ;
const char * longattrs [ ] = { " sAMAccountName " , " description " , NULL } ;
char * disp_fields [ 2 ] = { NULL , NULL } ;
if ( argc = = 0 ) {
2004-06-23 04:20:31 +04:00
if ( ! ( ads = ads_startup ( ) ) ) {
return - 1 ;
}
2002-04-04 06:53:42 +04:00
if ( opt_long_list_entries )
d_printf ( " \n User name Comment " \
" \n ----------------------------- \n " ) ;
2002-08-17 18:45:04 +04:00
rc = ads_do_search_all_fn ( ads , ads - > config . bind_path ,
2002-04-10 17:29:23 +04:00
LDAP_SCOPE_SUBTREE ,
" (objectclass=user) " ,
opt_long_list_entries ? longattrs :
shortattrs , usergrp_display ,
disp_fields ) ;
2002-04-04 06:53:42 +04:00
ads_destroy ( & ads ) ;
return 0 ;
}
return net_run_function ( argc , argv , func , net_ads_user_usage ) ;
}
2002-07-15 14:35:28 +04:00
static int net_ads_group_usage ( int argc , const char * * argv )
{
return net_help_group ( argc , argv ) ;
}
static int ads_group_add ( int argc , const char * * argv )
{
ADS_STRUCT * ads ;
ADS_STATUS status ;
void * res = NULL ;
int rc = - 1 ;
2004-06-23 04:20:31 +04:00
if ( argc < 1 ) {
return net_ads_group_usage ( argc , argv ) ;
}
2002-07-15 14:35:28 +04:00
2004-06-23 04:20:31 +04:00
if ( ! ( ads = ads_startup ( ) ) ) {
return - 1 ;
}
2002-07-15 14:35:28 +04:00
status = ads_find_user_acct ( ads , & res , argv [ 0 ] ) ;
if ( ! ADS_ERR_OK ( status ) ) {
d_printf ( " ads_group_add: %s \n " , ads_errstr ( status ) ) ;
goto done ;
}
if ( ads_count_replies ( ads , res ) ) {
d_printf ( " ads_group_add: Group %s already exists \n " , argv [ 0 ] ) ;
ads_msgfree ( ads , res ) ;
goto done ;
}
2003-01-15 19:10:57 +03:00
status = ads_add_group_acct ( ads , argv [ 0 ] , opt_container , opt_comment ) ;
2002-07-15 14:35:28 +04:00
if ( ADS_ERR_OK ( status ) ) {
d_printf ( " Group %s added \n " , argv [ 0 ] ) ;
rc = 0 ;
} else {
d_printf ( " Could not add group %s: %s \n " , argv [ 0 ] ,
ads_errstr ( status ) ) ;
}
done :
if ( res )
ads_msgfree ( ads , res ) ;
ads_destroy ( & ads ) ;
return rc ;
}
static int ads_group_delete ( int argc , const char * * argv )
{
ADS_STRUCT * ads ;
ADS_STATUS rc ;
void * res ;
char * groupdn ;
2004-06-23 04:20:31 +04:00
if ( argc < 1 ) {
return net_ads_group_usage ( argc , argv ) ;
}
2002-07-15 14:35:28 +04:00
2004-06-23 04:20:31 +04:00
if ( ! ( ads = ads_startup ( ) ) ) {
return - 1 ;
}
2002-07-15 14:35:28 +04:00
rc = ads_find_user_acct ( ads , & res , argv [ 0 ] ) ;
if ( ! ADS_ERR_OK ( rc ) ) {
DEBUG ( 0 , ( " Group %s does not exist \n " , argv [ 0 ] ) ) ;
2004-06-23 04:20:31 +04:00
ads_destroy ( & ads ) ;
2002-07-15 14:35:28 +04:00
return - 1 ;
}
groupdn = ads_get_dn ( ads , res ) ;
ads_msgfree ( ads , res ) ;
rc = ads_del_dn ( ads , groupdn ) ;
ads_memfree ( ads , groupdn ) ;
if ( ! ADS_ERR_OK ( rc ) ) {
d_printf ( " Group %s deleted \n " , argv [ 0 ] ) ;
2004-06-23 04:20:31 +04:00
ads_destroy ( & ads ) ;
2002-07-15 14:35:28 +04:00
return 0 ;
}
d_printf ( " Error deleting group %s: %s \n " , argv [ 0 ] ,
ads_errstr ( rc ) ) ;
2004-06-23 04:20:31 +04:00
ads_destroy ( & ads ) ;
2002-07-15 14:35:28 +04:00
return - 1 ;
}
int net_ads_group ( int argc , const char * * argv )
2001-11-25 04:31:07 +03:00
{
2002-07-15 14:35:28 +04:00
struct functable func [ ] = {
{ " ADD " , ads_group_add } ,
{ " DELETE " , ads_group_delete } ,
{ NULL , NULL }
} ;
2001-11-25 04:31:07 +03:00
ADS_STRUCT * ads ;
2001-12-19 15:21:12 +03:00
ADS_STATUS rc ;
2002-03-30 00:09:44 +03:00
const char * shortattrs [ ] = { " sAMAccountName " , NULL } ;
const char * longattrs [ ] = { " sAMAccountName " , " description " , NULL } ;
char * disp_fields [ 2 ] = { NULL , NULL } ;
2001-11-25 04:31:07 +03:00
2002-07-15 14:35:28 +04:00
if ( argc = = 0 ) {
2004-06-23 04:20:31 +04:00
if ( ! ( ads = ads_startup ( ) ) ) {
return - 1 ;
}
2001-11-25 04:31:07 +03:00
2002-07-15 14:35:28 +04:00
if ( opt_long_list_entries )
d_printf ( " \n Group name Comment " \
" \n ----------------------------- \n " ) ;
2002-08-17 18:45:04 +04:00
rc = ads_do_search_all_fn ( ads , ads - > config . bind_path ,
2002-07-15 14:35:28 +04:00
LDAP_SCOPE_SUBTREE ,
" (objectclass=group) " ,
opt_long_list_entries ? longattrs :
shortattrs , usergrp_display ,
disp_fields ) ;
2002-03-30 00:09:44 +03:00
2002-07-15 14:35:28 +04:00
ads_destroy ( & ads ) ;
return 0 ;
}
return net_run_function ( argc , argv , func , net_ads_group_usage ) ;
2001-11-25 04:31:07 +03:00
}
static int net_ads_status ( int argc , const char * * argv )
{
ADS_STRUCT * ads ;
2001-12-19 15:21:12 +03:00
ADS_STATUS rc ;
2001-11-25 04:31:07 +03:00
void * res ;
2004-06-23 04:20:31 +04:00
if ( ! ( ads = ads_startup ( ) ) ) {
return - 1 ;
}
2001-11-25 04:31:07 +03:00
2002-11-13 02:20:50 +03:00
rc = ads_find_machine_acct ( ads , & res , global_myname ( ) ) ;
2001-12-19 15:21:12 +03:00
if ( ! ADS_ERR_OK ( rc ) ) {
2001-11-25 04:06:56 +03:00
d_printf ( " ads_find_machine_acct: %s \n " , ads_errstr ( rc ) ) ;
2004-06-23 04:20:31 +04:00
ads_destroy ( & ads ) ;
2001-11-25 04:06:56 +03:00
return - 1 ;
}
if ( ads_count_replies ( ads , res ) = = 0 ) {
2002-11-13 02:20:50 +03:00
d_printf ( " No machine account for '%s' found \n " , global_myname ( ) ) ;
2004-06-23 04:20:31 +04:00
ads_destroy ( & ads ) ;
2001-11-25 04:06:56 +03:00
return - 1 ;
}
ads_dump ( ads , res ) ;
2004-06-23 04:20:31 +04:00
ads_destroy ( & ads ) ;
2001-11-25 04:06:56 +03:00
return 0 ;
}
static int net_ads_leave ( int argc , const char * * argv )
{
2001-12-17 14:16:22 +03:00
ADS_STRUCT * ads = NULL ;
2001-12-19 15:21:12 +03:00
ADS_STATUS rc ;
2001-11-25 03:18:11 +03:00
2002-03-10 04:52:09 +03:00
if ( ! secrets_init ( ) ) {
DEBUG ( 1 , ( " Failed to initialise secrets database \n " ) ) ;
2001-12-17 14:16:22 +03:00
return - 1 ;
}
2001-11-25 04:31:07 +03:00
2002-03-10 04:52:09 +03:00
if ( ! opt_password ) {
2003-08-20 02:47:10 +04:00
net_use_machine_password ( ) ;
2002-03-10 04:52:09 +03:00
}
if ( ! ( ads = ads_startup ( ) ) ) {
2001-11-25 03:18:11 +03:00
return - 1 ;
}
2002-11-13 02:20:50 +03:00
rc = ads_leave_realm ( ads , global_myname ( ) ) ;
2001-12-19 15:21:12 +03:00
if ( ! ADS_ERR_OK ( rc ) ) {
2004-06-23 04:20:31 +04:00
d_printf ( " Failed to delete host '%s' from the '%s' realm. \n " ,
global_myname ( ) , ads - > config . realm ) ;
ads_destroy ( & ads ) ;
return - 1 ;
2001-11-25 03:18:11 +03:00
}
2002-11-13 02:20:50 +03:00
d_printf ( " Removed '%s' from realm '%s' \n " , global_myname ( ) , ads - > config . realm ) ;
2004-06-23 04:20:31 +04:00
ads_destroy ( & ads ) ;
2002-08-17 18:45:04 +04:00
return 0 ;
}
static int net_ads_join_ok ( void )
{
ADS_STRUCT * ads = NULL ;
if ( ! secrets_init ( ) ) {
DEBUG ( 1 , ( " Failed to initialise secrets database \n " ) ) ;
return - 1 ;
}
2003-08-20 02:47:10 +04:00
net_use_machine_password ( ) ;
2001-11-25 03:18:11 +03:00
2002-08-17 18:45:04 +04:00
if ( ! ( ads = ads_startup ( ) ) ) {
return - 1 ;
}
ads_destroy ( & ads ) ;
2001-11-25 03:18:11 +03:00
return 0 ;
}
2002-08-17 18:45:04 +04:00
/*
check that an existing join is OK
*/
int net_ads_testjoin ( int argc , const char * * argv )
{
2003-02-24 06:06:45 +03:00
use_in_memory_ccache ( ) ;
2002-08-17 18:45:04 +04:00
/* Display success or failure */
if ( net_ads_join_ok ( ) ! = 0 ) {
fprintf ( stderr , " Join to domain is not valid \n " ) ;
return - 1 ;
}
printf ( " Join is OK \n " ) ;
return 0 ;
}
/*
join a domain using ADS
*/
2002-03-16 01:05:39 +03:00
int net_ads_join ( int argc , const char * * argv )
2001-11-25 03:18:11 +03:00
{
ADS_STRUCT * ads ;
2001-12-19 15:21:12 +03:00
ADS_STATUS rc ;
2001-11-25 03:18:11 +03:00
char * password ;
2003-08-20 02:47:10 +04:00
char * machine_account = NULL ;
2001-12-05 04:58:33 +03:00
char * tmp_password ;
2001-12-17 14:16:22 +03:00
const char * org_unit = " Computers " ;
char * dn ;
void * res ;
2001-12-21 02:35:53 +03:00
DOM_SID dom_sid ;
2002-01-16 05:22:30 +03:00
char * ou_str ;
2003-04-22 09:32:01 +04:00
uint32 sec_channel_type = SEC_CHAN_WKSTA ;
2003-04-21 18:09:03 +04:00
uint32 account_type = UF_WORKSTATION_TRUST_ACCOUNT ;
2003-11-26 12:58:41 +03:00
const char * short_domain_name = NULL ;
2003-09-05 21:57:45 +04:00
TALLOC_CTX * ctx = NULL ;
2001-12-17 14:16:22 +03:00
2004-06-23 04:20:31 +04:00
if ( argc > 0 ) {
org_unit = argv [ 0 ] ;
}
2001-11-25 03:18:11 +03:00
if ( ! secrets_init ( ) ) {
DEBUG ( 1 , ( " Failed to initialise secrets database \n " ) ) ;
return - 1 ;
}
2001-12-17 14:16:22 +03:00
2001-12-05 14:00:26 +03:00
tmp_password = generate_random_str ( DEFAULT_TRUST_ACCOUNT_PASSWORD_LENGTH ) ;
2001-12-05 04:58:33 +03:00
password = strdup ( tmp_password ) ;
2001-11-25 03:18:11 +03:00
2004-06-23 04:20:31 +04:00
if ( ! ( ads = ads_startup ( ) ) ) {
return - 1 ;
}
2001-11-25 03:18:11 +03:00
2003-08-20 02:47:10 +04:00
if ( ! * lp_realm ( ) ) {
d_printf ( " realm must be set in in smb.conf for ADS join to succeed. \n " ) ;
2004-06-23 04:20:31 +04:00
ads_destroy ( & ads ) ;
2003-08-20 02:47:10 +04:00
return - 1 ;
}
if ( strcmp ( ads - > config . realm , lp_realm ( ) ) ! = 0 ) {
d_printf ( " realm of remote server (%s) and realm in smb.conf (%s) DO NOT match. Aborting join \n " , ads - > config . realm , lp_realm ( ) ) ;
2004-06-23 04:20:31 +04:00
ads_destroy ( & ads ) ;
2003-08-20 02:47:10 +04:00
return - 1 ;
}
2002-01-16 05:22:30 +03:00
ou_str = ads_ou_string ( org_unit ) ;
2002-08-17 18:45:04 +04:00
asprintf ( & dn , " %s,%s " , ou_str , ads - > config . bind_path ) ;
2002-01-16 05:22:30 +03:00
free ( ou_str ) ;
2001-12-17 14:16:22 +03:00
rc = ads_search_dn ( ads , & res , dn , NULL ) ;
ads_msgfree ( ads , res ) ;
2004-01-12 17:26:50 +03:00
if ( rc . error_type = = ENUM_ADS_ERROR_LDAP & & rc . err . rc = = LDAP_NO_SUCH_OBJECT ) {
2002-03-10 04:52:09 +03:00
d_printf ( " ads_join_realm: organizational unit %s does not exist (dn:%s) \n " ,
2002-01-16 05:22:30 +03:00
org_unit , dn ) ;
2004-06-23 04:20:31 +04:00
ads_destroy ( & ads ) ;
2001-12-19 15:21:12 +03:00
return - 1 ;
2001-12-17 14:16:22 +03:00
}
2002-01-16 05:22:30 +03:00
free ( dn ) ;
2001-12-17 14:16:22 +03:00
2001-12-19 15:21:12 +03:00
if ( ! ADS_ERR_OK ( rc ) ) {
2001-12-17 14:16:22 +03:00
d_printf ( " ads_join_realm: %s \n " , ads_errstr ( rc ) ) ;
2004-06-23 04:20:31 +04:00
ads_destroy ( & ads ) ;
2001-12-17 14:16:22 +03:00
return - 1 ;
}
2003-04-21 18:09:03 +04:00
rc = ads_join_realm ( ads , global_myname ( ) , account_type , org_unit ) ;
2001-12-19 15:21:12 +03:00
if ( ! ADS_ERR_OK ( rc ) ) {
2001-11-25 03:18:11 +03:00
d_printf ( " ads_join_realm: %s \n " , ads_errstr ( rc ) ) ;
2004-06-23 04:20:31 +04:00
ads_destroy ( & ads ) ;
2001-11-25 03:18:11 +03:00
return - 1 ;
}
2002-09-25 19:19:00 +04:00
rc = ads_domain_sid ( ads , & dom_sid ) ;
2001-12-19 15:21:12 +03:00
if ( ! ADS_ERR_OK ( rc ) ) {
2003-08-20 02:47:10 +04:00
d_printf ( " ads_domain_sid: %s \n " , ads_errstr ( rc ) ) ;
2004-06-23 04:20:31 +04:00
ads_destroy ( & ads ) ;
return - 1 ;
2003-08-20 02:47:10 +04:00
}
if ( asprintf ( & machine_account , " %s$ " , global_myname ( ) ) = = - 1 ) {
d_printf ( " asprintf failed \n " ) ;
2004-06-23 04:20:31 +04:00
ads_destroy ( & ads ) ;
2001-11-25 03:18:11 +03:00
return - 1 ;
}
2003-08-20 02:47:10 +04:00
rc = ads_set_machine_password ( ads , machine_account , password ) ;
2001-12-21 02:35:53 +03:00
if ( ! ADS_ERR_OK ( rc ) ) {
2002-09-25 19:19:00 +04:00
d_printf ( " ads_set_machine_password: %s \n " , ads_errstr ( rc ) ) ;
2004-06-23 04:20:31 +04:00
ads_destroy ( & ads ) ;
2001-12-21 02:35:53 +03:00
return - 1 ;
}
2003-09-05 21:57:45 +04:00
/* make sure we get the right workgroup */
if ( ! ( ctx = talloc_init ( " net ads join " ) ) ) {
d_printf ( " talloc_init() failed! \n " ) ;
2004-06-23 04:20:31 +04:00
ads_destroy ( & ads ) ;
2003-09-05 21:57:45 +04:00
return - 1 ;
}
rc = ads_workgroup_name ( ads , ctx , & short_domain_name ) ;
if ( ADS_ERR_OK ( rc ) ) {
if ( ! strequal ( lp_workgroup ( ) , short_domain_name ) ) {
d_printf ( " The workgroup in smb.conf does not match the short \n " ) ;
d_printf ( " domain name obtained from the server. \n " ) ;
d_printf ( " Using the name [%s] from the server. \n " , short_domain_name ) ;
d_printf ( " You should set \" workgroup = %s \" in smb.conf. \n " , short_domain_name ) ;
}
2004-06-23 01:58:35 +04:00
} else {
2003-09-05 21:57:45 +04:00
short_domain_name = lp_workgroup ( ) ;
2004-06-23 01:58:35 +04:00
}
2003-09-05 21:57:45 +04:00
d_printf ( " Using short domain name -- %s \n " , short_domain_name ) ;
/* HACK ALRET! Store the sid and password under bother the lp_workgroup()
value from smb . conf and the string returned from the server . The former is
neede to bootstrap winbindd ' s first connection to the DC to get the real
short domain name - - jerry */
2001-12-21 02:35:53 +03:00
if ( ! secrets_store_domain_sid ( lp_workgroup ( ) , & dom_sid ) ) {
DEBUG ( 1 , ( " Failed to save domain sid \n " ) ) ;
2004-06-23 04:20:31 +04:00
ads_destroy ( & ads ) ;
2001-12-21 02:35:53 +03:00
return - 1 ;
}
2003-04-21 18:09:03 +04:00
if ( ! secrets_store_machine_password ( password , lp_workgroup ( ) , sec_channel_type ) ) {
2001-11-25 03:18:11 +03:00
DEBUG ( 1 , ( " Failed to save machine password \n " ) ) ;
2004-06-23 04:20:31 +04:00
ads_destroy ( & ads ) ;
2001-11-25 03:18:11 +03:00
return - 1 ;
}
2003-09-05 21:57:45 +04:00
if ( ! secrets_store_domain_sid ( short_domain_name , & dom_sid ) ) {
DEBUG ( 1 , ( " Failed to save domain sid \n " ) ) ;
2004-06-23 04:20:31 +04:00
ads_destroy ( & ads ) ;
2003-09-05 21:57:45 +04:00
return - 1 ;
}
if ( ! secrets_store_machine_password ( password , short_domain_name , sec_channel_type ) ) {
DEBUG ( 1 , ( " Failed to save machine password \n " ) ) ;
2004-06-23 04:20:31 +04:00
ads_destroy ( & ads ) ;
2003-09-05 21:57:45 +04:00
return - 1 ;
}
2004-06-23 01:58:35 +04:00
/* Now build the keytab, using the same ADS connection */
if ( lp_use_kerberos_keytab ( ) & & ads_keytab_create_default ( ads ) ) {
DEBUG ( 1 , ( " Error creating host keytab! \n " ) ) ;
}
2002-11-13 02:20:50 +03:00
d_printf ( " Joined '%s' to realm '%s' \n " , global_myname ( ) , ads - > config . realm ) ;
2001-11-25 03:18:11 +03:00
2003-08-20 02:47:10 +04:00
SAFE_FREE ( password ) ;
SAFE_FREE ( machine_account ) ;
2004-06-23 01:58:35 +04:00
if ( ctx ) {
2003-09-05 21:57:45 +04:00
talloc_destroy ( ctx ) ;
2004-06-23 01:58:35 +04:00
}
2004-06-23 04:20:31 +04:00
ads_destroy ( & ads ) ;
2001-11-25 03:18:11 +03:00
return 0 ;
}
2002-02-02 05:06:03 +03:00
int net_ads_printer_usage ( int argc , const char * * argv )
{
d_printf (
2003-07-03 09:08:51 +04:00
" \n net ads printer search <printer> "
" \n \t search for a printer in the directory "
2002-02-02 05:06:03 +03:00
" \n net ads printer info <printer> <server> "
" \n \t lookup info in directory for printer on server "
" \n \t (note: printer defaults to \" * \" , server defaults to local) \n "
" \n net ads printer publish <printername> "
" \n \t publish printer in directory "
" \n \t (note: printer name is required) \n "
" \n net ads printer remove <printername> "
" \n \t remove printer from directory "
" \n \t (note: printer name is required) \n " ) ;
return - 1 ;
}
2003-07-03 09:08:51 +04:00
static int net_ads_printer_search ( int argc , const char * * argv )
{
ADS_STRUCT * ads ;
ADS_STATUS rc ;
void * res = NULL ;
2004-06-23 04:20:31 +04:00
if ( ! ( ads = ads_startup ( ) ) ) {
2003-07-03 09:08:51 +04:00
return - 1 ;
2004-06-23 04:20:31 +04:00
}
2003-07-03 09:08:51 +04:00
rc = ads_find_printers ( ads , & res ) ;
if ( ! ADS_ERR_OK ( rc ) ) {
d_printf ( " ads_find_printer: %s \n " , ads_errstr ( rc ) ) ;
ads_msgfree ( ads , res ) ;
2004-06-23 04:20:31 +04:00
ads_destroy ( & ads ) ;
return - 1 ;
2003-07-03 09:08:51 +04:00
}
if ( ads_count_replies ( ads , res ) = = 0 ) {
d_printf ( " No results found \n " ) ;
ads_msgfree ( ads , res ) ;
2004-06-23 04:20:31 +04:00
ads_destroy ( & ads ) ;
2003-07-03 09:08:51 +04:00
return - 1 ;
}
ads_dump ( ads , res ) ;
ads_msgfree ( ads , res ) ;
2004-06-23 04:20:31 +04:00
ads_destroy ( & ads ) ;
2003-07-03 09:08:51 +04:00
return 0 ;
}
2002-02-02 05:06:03 +03:00
static int net_ads_printer_info ( int argc , const char * * argv )
{
ADS_STRUCT * ads ;
ADS_STATUS rc ;
2002-07-15 14:35:28 +04:00
const char * servername , * printername ;
2002-02-02 05:06:03 +03:00
void * res = NULL ;
2004-06-23 04:20:31 +04:00
if ( ! ( ads = ads_startup ( ) ) ) {
return - 1 ;
}
2002-02-02 05:06:03 +03:00
2004-06-23 04:20:31 +04:00
if ( argc > 0 ) {
2002-02-02 05:06:03 +03:00
printername = argv [ 0 ] ;
2004-06-23 04:20:31 +04:00
} else {
2002-02-02 05:06:03 +03:00
printername = " * " ;
2004-06-23 04:20:31 +04:00
}
2002-02-02 05:06:03 +03:00
2004-06-23 04:20:31 +04:00
if ( argc > 1 ) {
2002-02-02 05:06:03 +03:00
servername = argv [ 1 ] ;
2004-06-23 04:20:31 +04:00
} else {
2002-11-13 02:20:50 +03:00
servername = global_myname ( ) ;
2004-06-23 04:20:31 +04:00
}
2002-02-02 05:06:03 +03:00
rc = ads_find_printer_on_server ( ads , & res , printername , servername ) ;
if ( ! ADS_ERR_OK ( rc ) ) {
d_printf ( " ads_find_printer_on_server: %s \n " , ads_errstr ( rc ) ) ;
ads_msgfree ( ads , res ) ;
2004-06-23 04:20:31 +04:00
ads_destroy ( & ads ) ;
2002-02-02 05:06:03 +03:00
return - 1 ;
}
if ( ads_count_replies ( ads , res ) = = 0 ) {
d_printf ( " Printer '%s' not found \n " , printername ) ;
ads_msgfree ( ads , res ) ;
2004-06-23 04:20:31 +04:00
ads_destroy ( & ads ) ;
2002-02-02 05:06:03 +03:00
return - 1 ;
}
ads_dump ( ads , res ) ;
2002-03-30 00:09:44 +03:00
ads_msgfree ( ads , res ) ;
2004-06-23 04:20:31 +04:00
ads_destroy ( & ads ) ;
2002-02-02 05:06:03 +03:00
return 0 ;
}
2002-07-15 14:35:28 +04:00
void do_drv_upgrade_printer ( int msg_type , pid_t src , void * buf , size_t len )
{
return ;
}
2002-02-02 05:06:03 +03:00
static int net_ads_printer_publish ( int argc , const char * * argv )
{
ADS_STRUCT * ads ;
ADS_STATUS rc ;
2003-07-03 09:58:55 +04:00
const char * servername , * printername ;
2002-11-18 23:23:05 +03:00
struct cli_state * cli ;
struct in_addr server_ip ;
NTSTATUS nt_status ;
2002-12-20 23:21:31 +03:00
TALLOC_CTX * mem_ctx = talloc_init ( " net_ads_printer_publish " ) ;
2002-11-18 23:23:05 +03:00
ADS_MODLIST mods = ads_init_mods ( mem_ctx ) ;
char * prt_dn , * srv_dn , * * srv_cn ;
void * res = NULL ;
2002-02-02 05:06:03 +03:00
2004-06-23 04:20:31 +04:00
if ( ! ( ads = ads_startup ( ) ) ) {
return - 1 ;
}
2002-02-02 05:06:03 +03:00
2004-06-23 04:20:31 +04:00
if ( argc < 1 ) {
2002-02-02 05:06:03 +03:00
return net_ads_printer_usage ( argc , argv ) ;
2004-06-23 04:20:31 +04:00
}
2002-11-18 23:23:05 +03:00
2003-07-03 09:58:55 +04:00
printername = argv [ 0 ] ;
2004-06-23 04:20:31 +04:00
if ( argc = = 2 ) {
2002-11-18 23:23:05 +03:00
servername = argv [ 1 ] ;
2004-06-23 04:20:31 +04:00
} else {
2002-11-18 23:23:05 +03:00
servername = global_myname ( ) ;
2004-06-23 04:20:31 +04:00
}
2002-11-18 23:23:05 +03:00
2003-07-03 09:58:55 +04:00
/* Get printer data from SPOOLSS */
2002-11-18 23:23:05 +03:00
resolve_name ( servername , & server_ip , 0x20 ) ;
nt_status = cli_full_connection ( & cli , global_myname ( ) , servername ,
& server_ip , 0 ,
" IPC$ " , " IPC " ,
opt_user_name , opt_workgroup ,
opt_password ? opt_password : " " ,
CLI_FULL_CONNECTION_USE_KERBEROS ,
2003-07-31 03:49:29 +04:00
Undefined , NULL ) ;
2002-11-18 23:23:05 +03:00
2003-07-03 09:58:55 +04:00
if ( NT_STATUS_IS_ERR ( nt_status ) ) {
d_printf ( " Unable to open a connnection to %s to obtain data "
" for %s \n " , servername , printername ) ;
2004-06-23 04:20:31 +04:00
ads_destroy ( & ads ) ;
2003-07-03 09:58:55 +04:00
return - 1 ;
}
/* Publish on AD server */
ads_find_machine_acct ( ads , & res , servername ) ;
if ( ads_count_replies ( ads , res ) = = 0 ) {
d_printf ( " Could not find machine account for server %s \n " ,
servername ) ;
2004-06-23 04:20:31 +04:00
ads_destroy ( & ads ) ;
2003-07-03 09:58:55 +04:00
return - 1 ;
}
srv_dn = ldap_get_dn ( ads - > ld , res ) ;
srv_cn = ldap_explode_dn ( srv_dn , 1 ) ;
asprintf ( & prt_dn , " cn=%s-%s,%s " , srv_cn [ 0 ] , printername , srv_dn ) ;
2002-11-18 23:23:05 +03:00
cli_nt_session_open ( cli , PI_SPOOLSS ) ;
2003-07-03 09:58:55 +04:00
get_remote_printer_publishing_data ( cli , mem_ctx , & mods , printername ) ;
2002-11-18 23:23:05 +03:00
rc = ads_add_printer_entry ( ads , prt_dn , mem_ctx , & mods ) ;
2002-02-02 05:06:03 +03:00
if ( ! ADS_ERR_OK ( rc ) ) {
d_printf ( " ads_publish_printer: %s \n " , ads_errstr ( rc ) ) ;
2004-06-23 04:20:31 +04:00
ads_destroy ( & ads ) ;
2002-02-02 05:06:03 +03:00
return - 1 ;
}
d_printf ( " published printer \n " ) ;
2004-06-23 04:20:31 +04:00
ads_destroy ( & ads ) ;
2002-02-02 05:06:03 +03:00
return 0 ;
}
static int net_ads_printer_remove ( int argc , const char * * argv )
{
ADS_STRUCT * ads ;
ADS_STATUS rc ;
2002-11-13 02:20:50 +03:00
const char * servername ;
char * prt_dn ;
2002-02-02 05:06:03 +03:00
void * res = NULL ;
2004-06-23 04:20:31 +04:00
if ( ! ( ads = ads_startup ( ) ) ) {
return - 1 ;
}
2002-02-02 05:06:03 +03:00
2004-06-23 04:20:31 +04:00
if ( argc < 1 ) {
2002-02-02 05:06:03 +03:00
return net_ads_printer_usage ( argc , argv ) ;
2004-06-23 04:20:31 +04:00
}
2002-02-02 05:06:03 +03:00
2004-06-23 04:20:31 +04:00
if ( argc > 1 ) {
2002-02-02 05:06:03 +03:00
servername = argv [ 1 ] ;
2004-06-23 04:20:31 +04:00
} else {
2002-11-13 02:20:50 +03:00
servername = global_myname ( ) ;
2004-06-23 04:20:31 +04:00
}
2002-02-02 05:06:03 +03:00
rc = ads_find_printer_on_server ( ads , & res , argv [ 0 ] , servername ) ;
if ( ! ADS_ERR_OK ( rc ) ) {
d_printf ( " ads_find_printer_on_server: %s \n " , ads_errstr ( rc ) ) ;
ads_msgfree ( ads , res ) ;
2004-06-23 04:20:31 +04:00
ads_destroy ( & ads ) ;
2002-02-02 05:06:03 +03:00
return - 1 ;
}
if ( ads_count_replies ( ads , res ) = = 0 ) {
d_printf ( " Printer '%s' not found \n " , argv [ 1 ] ) ;
ads_msgfree ( ads , res ) ;
2004-06-23 04:20:31 +04:00
ads_destroy ( & ads ) ;
2002-02-02 05:06:03 +03:00
return - 1 ;
}
prt_dn = ads_get_dn ( ads , res ) ;
ads_msgfree ( ads , res ) ;
rc = ads_del_dn ( ads , prt_dn ) ;
ads_memfree ( ads , prt_dn ) ;
if ( ! ADS_ERR_OK ( rc ) ) {
d_printf ( " ads_del_dn: %s \n " , ads_errstr ( rc ) ) ;
2004-06-23 04:20:31 +04:00
ads_destroy ( & ads ) ;
2002-02-02 05:06:03 +03:00
return - 1 ;
}
2004-06-23 04:20:31 +04:00
ads_destroy ( & ads ) ;
2002-02-02 05:06:03 +03:00
return 0 ;
}
static int net_ads_printer ( int argc , const char * * argv )
{
struct functable func [ ] = {
2003-07-03 09:08:51 +04:00
{ " SEARCH " , net_ads_printer_search } ,
2002-02-02 05:06:03 +03:00
{ " INFO " , net_ads_printer_info } ,
{ " PUBLISH " , net_ads_printer_publish } ,
{ " REMOVE " , net_ads_printer_remove } ,
{ NULL , NULL }
} ;
return net_run_function ( argc , argv , func , net_ads_printer_usage ) ;
}
2001-12-20 06:54:52 +03:00
static int net_ads_password ( int argc , const char * * argv )
{
2004-06-23 01:58:35 +04:00
ADS_STRUCT * ads ;
const char * auth_principal = opt_user_name ;
const char * auth_password = opt_password ;
char * realm = NULL ;
char * new_password = NULL ;
char * c , * prompt ;
const char * user ;
ADS_STATUS ret ;
if ( opt_user_name = = NULL | | opt_password = = NULL ) {
d_printf ( " You must supply an administrator username/password \n " ) ;
return - 1 ;
}
2003-06-10 08:15:55 +04:00
2004-06-23 01:58:35 +04:00
if ( argc < 1 ) {
d_printf ( " ERROR: You must say which username to change password for \n " ) ;
return - 1 ;
}
user = argv [ 0 ] ;
if ( ! strchr_m ( user , ' @ ' ) ) {
asprintf ( & c , " %s@%s " , argv [ 0 ] , lp_realm ( ) ) ;
user = c ;
}
use_in_memory_ccache ( ) ;
c = strchr ( auth_principal , ' @ ' ) ;
if ( c ) {
realm = + + c ;
} else {
realm = lp_realm ( ) ;
}
/* use the realm so we can eventually change passwords for users
in realms other than default */
if ( ! ( ads = ads_init ( realm , NULL , NULL ) ) ) {
return - 1 ;
}
/* we don't actually need a full connect, but it's the easy way to
fill in the KDC ' s addresss */
ads_connect ( ads ) ;
2001-12-20 06:54:52 +03:00
2004-06-23 01:58:35 +04:00
if ( ! ads | | ! ads - > config . realm ) {
d_printf ( " Didn't find the kerberos server! \n " ) ;
return - 1 ;
}
2003-03-18 01:58:24 +03:00
2004-06-23 01:58:35 +04:00
if ( argv [ 1 ] ) {
new_password = ( char * ) argv [ 1 ] ;
} else {
asprintf ( & prompt , " Enter new password for %s: " , user ) ;
new_password = getpass ( prompt ) ;
free ( prompt ) ;
}
2001-12-20 06:54:52 +03:00
2004-06-23 01:58:35 +04:00
ret = kerberos_set_password ( ads - > auth . kdc_server , auth_principal ,
2003-06-10 08:15:55 +04:00
auth_password , user , new_password , ads - > auth . time_offset ) ;
2004-06-23 01:58:35 +04:00
if ( ! ADS_ERR_OK ( ret ) ) {
d_printf ( " Password change failed :-( ... \n " ) ;
ads_destroy ( & ads ) ;
return - 1 ;
}
2001-12-20 06:54:52 +03:00
2004-06-23 01:58:35 +04:00
d_printf ( " Password change for %s completed. \n " , user ) ;
ads_destroy ( & ads ) ;
2001-12-20 06:54:52 +03:00
2004-06-23 01:58:35 +04:00
return 0 ;
2001-12-20 06:54:52 +03:00
}
2003-04-15 02:27:09 +04:00
int net_ads_changetrustpw ( int argc , const char * * argv )
2001-12-20 06:54:52 +03:00
{
2004-06-23 01:58:35 +04:00
ADS_STRUCT * ads ;
char * host_principal ;
fstring my_fqdn ;
ADS_STATUS ret ;
2001-12-20 06:54:52 +03:00
2004-06-23 01:58:35 +04:00
if ( ! secrets_init ( ) ) {
DEBUG ( 1 , ( " Failed to initialise secrets database \n " ) ) ;
return - 1 ;
}
2002-08-17 18:45:04 +04:00
2004-06-23 01:58:35 +04:00
net_use_machine_password ( ) ;
2002-08-17 18:45:04 +04:00
2004-06-23 01:58:35 +04:00
use_in_memory_ccache ( ) ;
2003-02-24 06:06:45 +03:00
2004-06-23 01:58:35 +04:00
if ( ! ( ads = ads_startup ( ) ) ) {
return - 1 ;
}
name_to_fqdn ( my_fqdn , global_myname ( ) ) ;
strlower_m ( my_fqdn ) ;
asprintf ( & host_principal , " %s@%s " , my_fqdn , ads - > config . realm ) ;
d_printf ( " Changing password for principal: HOST/%s \n " , host_principal ) ;
ret = ads_change_trust_account_password ( ads , host_principal ) ;
2001-12-20 06:54:52 +03:00
2004-06-23 01:58:35 +04:00
if ( ! ADS_ERR_OK ( ret ) ) {
d_printf ( " Password change failed :-( ... \n " ) ;
ads_destroy ( & ads ) ;
SAFE_FREE ( host_principal ) ;
return - 1 ;
}
2001-12-20 06:54:52 +03:00
2004-06-23 01:58:35 +04:00
d_printf ( " Password change for principal HOST/%s succeeded. \n " , host_principal ) ;
if ( lp_use_kerberos_keytab ( ) ) {
d_printf ( " Attempting to update system keytab with new password. \n " ) ;
if ( ads_keytab_create_default ( ads ) ) {
d_printf ( " Failed to update system keytab. \n " ) ;
}
}
2001-12-20 06:54:52 +03:00
ads_destroy ( & ads ) ;
SAFE_FREE ( host_principal ) ;
2004-06-23 01:58:35 +04:00
return 0 ;
2001-12-20 06:54:52 +03:00
}
2002-07-15 14:35:28 +04:00
/*
help for net ads search
*/
static int net_ads_search_usage ( int argc , const char * * argv )
{
d_printf (
" \n net ads search <expression> <attributes...> \n " \
" \n perform a raw LDAP search on a ADS server and dump the results \n " \
" The expression is a standard LDAP search expression, and the \n " \
" attributes are a list of LDAP fields to show in the results \n \n " \
" Example: net ads search '(objectCategory=group)' sAMAccountName \n \n "
) ;
net_common_flags_usage ( argc , argv ) ;
return - 1 ;
}
/*
general ADS search function . Useful in diagnosing problems in ADS
*/
static int net_ads_search ( int argc , const char * * argv )
{
ADS_STRUCT * ads ;
ADS_STATUS rc ;
2003-06-30 09:45:27 +04:00
const char * ldap_exp ;
2002-07-15 14:35:28 +04:00
const char * * attrs ;
void * res = NULL ;
if ( argc < 1 ) {
return net_ads_search_usage ( argc , argv ) ;
}
if ( ! ( ads = ads_startup ( ) ) ) {
return - 1 ;
}
2003-06-30 09:45:27 +04:00
ldap_exp = argv [ 0 ] ;
2002-07-15 14:35:28 +04:00
attrs = ( argv + 1 ) ;
2003-03-18 01:33:34 +03:00
rc = ads_do_search_all ( ads , ads - > config . bind_path ,
2002-07-15 14:35:28 +04:00
LDAP_SCOPE_SUBTREE ,
2003-06-30 09:45:27 +04:00
ldap_exp , attrs , & res ) ;
2002-07-15 14:35:28 +04:00
if ( ! ADS_ERR_OK ( rc ) ) {
d_printf ( " search failed: %s \n " , ads_errstr ( rc ) ) ;
2004-06-23 04:20:31 +04:00
ads_destroy ( & ads ) ;
2002-07-15 14:35:28 +04:00
return - 1 ;
}
d_printf ( " Got %d replies \n \n " , ads_count_replies ( ads , res ) ) ;
/* dump the results */
ads_dump ( ads , res ) ;
ads_msgfree ( ads , res ) ;
ads_destroy ( & ads ) ;
return 0 ;
}
2003-03-18 01:33:34 +03:00
/*
help for net ads search
*/
static int net_ads_dn_usage ( int argc , const char * * argv )
{
d_printf (
" \n net ads dn <dn> <attributes...> \n " \
" \n perform a raw LDAP search on a ADS server and dump the results \n " \
" The DN standard LDAP DN, and the attributes are a list of LDAP fields \n " \
" to show in the results \n \n " \
" Example: net ads dn 'CN=administrator,CN=Users,DC=my,DC=domain' sAMAccountName \n \n "
) ;
net_common_flags_usage ( argc , argv ) ;
return - 1 ;
}
/*
general ADS search function . Useful in diagnosing problems in ADS
*/
static int net_ads_dn ( int argc , const char * * argv )
{
ADS_STRUCT * ads ;
ADS_STATUS rc ;
const char * dn ;
const char * * attrs ;
void * res = NULL ;
if ( argc < 1 ) {
return net_ads_dn_usage ( argc , argv ) ;
}
if ( ! ( ads = ads_startup ( ) ) ) {
return - 1 ;
}
dn = argv [ 0 ] ;
attrs = ( argv + 1 ) ;
rc = ads_do_search_all ( ads , dn ,
LDAP_SCOPE_BASE ,
" (objectclass=*) " , attrs , & res ) ;
if ( ! ADS_ERR_OK ( rc ) ) {
d_printf ( " search failed: %s \n " , ads_errstr ( rc ) ) ;
2004-06-23 04:20:31 +04:00
ads_destroy ( & ads ) ;
2003-03-18 01:33:34 +03:00
return - 1 ;
}
d_printf ( " Got %d replies \n \n " , ads_count_replies ( ads , res ) ) ;
/* dump the results */
ads_dump ( ads , res ) ;
ads_msgfree ( ads , res ) ;
ads_destroy ( & ads ) ;
return 0 ;
}
2004-06-23 01:58:35 +04:00
static int net_ads_keytab_usage ( int argc , const char * * argv )
{
d_printf (
" net ads keytab <COMMAND> \n " \
" <COMMAND> can be either: \n " \
" CREATE Creates a fresh keytab \n " \
" ADD Adds new service principal \n " \
" FLUSH Flushes out all keytab entries \n " \
" HELP Prints this help message \n " \
" The ADD command will take arguments, the other commands \n " \
" will not take any arguments. The arguments given to ADD \n " \
" should be a list of principals to add. For example, \n " \
" net ads keytab add srv1 srv2 \n " \
" will add principals for the services srv1 and srv2 to the \n " \
" system's keytab. \n " \
" \n "
) ;
return - 1 ;
}
static int net_ads_keytab_flush ( int argc , const char * * argv )
{
int ret ;
ADS_STRUCT * ads ;
if ( ! ( ads = ads_startup ( ) ) ) {
return - 1 ;
}
ret = ads_keytab_flush ( ads ) ;
ads_destroy ( & ads ) ;
return ret ;
}
static int net_ads_keytab_add ( int argc , const char * * argv )
{
int i ;
int ret = 0 ;
ADS_STRUCT * ads ;
d_printf ( " Processing principals to add... \n " ) ;
if ( ! ( ads = ads_startup ( ) ) ) {
return - 1 ;
}
for ( i = 0 ; i < argc ; i + + ) {
ret | = ads_keytab_add_entry ( ads , argv [ i ] ) ;
}
ads_destroy ( & ads ) ;
return ret ;
}
static int net_ads_keytab_create ( int argc , const char * * argv )
{
ADS_STRUCT * ads ;
int ret ;
if ( ! ( ads = ads_startup ( ) ) ) {
return - 1 ;
}
ret = ads_keytab_create_default ( ads ) ;
ads_destroy ( & ads ) ;
return ret ;
}
int net_ads_keytab ( int argc , const char * * argv )
{
struct functable func [ ] = {
{ " CREATE " , net_ads_keytab_create } ,
{ " ADD " , net_ads_keytab_add } ,
{ " FLUSH " , net_ads_keytab_flush } ,
{ " HELP " , net_ads_keytab_usage } ,
{ NULL , NULL }
} ;
if ( ! lp_use_kerberos_keytab ( ) ) {
d_printf ( " \n Warning: \" use kerberos keytab \" must be set to \" true \" in order to \
use keytab functions . \ n " );
}
return net_run_function ( argc , argv , func , net_ads_keytab_usage ) ;
}
2003-03-18 01:33:34 +03:00
2002-04-04 06:53:42 +04:00
int net_ads_help ( int argc , const char * * argv )
{
struct functable func [ ] = {
{ " USER " , net_ads_user_usage } ,
2002-07-15 14:35:28 +04:00
{ " GROUP " , net_ads_group_usage } ,
{ " PRINTER " , net_ads_printer_usage } ,
{ " SEARCH " , net_ads_search_usage } ,
2002-04-04 06:53:42 +04:00
#if 0
{ " INFO " , net_ads_info } ,
{ " JOIN " , net_ads_join } ,
{ " LEAVE " , net_ads_leave } ,
{ " STATUS " , net_ads_status } ,
{ " PASSWORD " , net_ads_password } ,
2003-04-15 02:27:09 +04:00
{ " CHANGETRUSTPW " , net_ads_changetrustpw } ,
2002-04-04 06:53:42 +04:00
# endif
{ NULL , NULL }
} ;
return net_run_function ( argc , argv , func , net_ads_usage ) ;
}
2001-12-20 06:54:52 +03:00
2001-11-25 03:18:11 +03:00
int net_ads ( int argc , const char * * argv )
{
struct functable func [ ] = {
2001-12-13 16:19:20 +03:00
{ " INFO " , net_ads_info } ,
2001-11-25 03:18:11 +03:00
{ " JOIN " , net_ads_join } ,
2002-08-17 18:45:04 +04:00
{ " TESTJOIN " , net_ads_testjoin } ,
2001-11-25 03:18:11 +03:00
{ " LEAVE " , net_ads_leave } ,
2001-11-25 04:06:56 +03:00
{ " STATUS " , net_ads_status } ,
2001-11-25 04:31:07 +03:00
{ " USER " , net_ads_user } ,
{ " GROUP " , net_ads_group } ,
2001-12-20 06:54:52 +03:00
{ " PASSWORD " , net_ads_password } ,
2003-04-15 02:27:09 +04:00
{ " CHANGETRUSTPW " , net_ads_changetrustpw } ,
2002-02-02 05:06:03 +03:00
{ " PRINTER " , net_ads_printer } ,
2002-07-15 14:35:28 +04:00
{ " SEARCH " , net_ads_search } ,
2003-03-18 01:33:34 +03:00
{ " DN " , net_ads_dn } ,
2002-08-17 18:45:04 +04:00
{ " WORKGROUP " , net_ads_workgroup } ,
2002-09-25 19:19:00 +04:00
{ " LOOKUP " , net_ads_lookup } ,
2004-06-23 01:58:35 +04:00
{ " KEYTAB " , net_ads_keytab } ,
2002-04-04 06:53:42 +04:00
{ " HELP " , net_ads_help } ,
2001-11-25 03:18:11 +03:00
{ NULL , NULL }
} ;
return net_run_function ( argc , argv , func , net_ads_usage ) ;
}
# else
2004-06-24 23:25:20 +04:00
static int net_ads_noads ( void )
2001-11-25 03:18:11 +03:00
{
d_printf ( " ADS support not compiled in \n " ) ;
return - 1 ;
}
2004-06-23 01:58:35 +04:00
int net_ads_keytab ( int argc , const char * * argv )
{
return net_ads_noads ( ) ;
}
2002-04-04 20:47:24 +04:00
int net_ads_usage ( int argc , const char * * argv )
{
return net_ads_noads ( ) ;
}
2002-04-04 07:14:25 +04:00
int net_ads_help ( int argc , const char * * argv )
{
2002-04-04 20:47:24 +04:00
return net_ads_noads ( ) ;
2002-04-04 07:14:25 +04:00
}
2003-04-15 02:27:09 +04:00
int net_ads_changetrustpw ( int argc , const char * * argv )
{
return net_ads_noads ( ) ;
}
2002-03-16 04:30:09 +03:00
int net_ads_join ( int argc , const char * * argv )
2002-04-04 20:47:24 +04:00
{
return net_ads_noads ( ) ;
}
int net_ads_user ( int argc , const char * * argv )
{
return net_ads_noads ( ) ;
}
2002-07-15 14:35:28 +04:00
int net_ads_group ( int argc , const char * * argv )
{
return net_ads_noads ( ) ;
}
2002-04-04 20:47:24 +04:00
/* this one shouldn't display a message */
int net_ads_check ( void )
2002-03-16 04:30:09 +03:00
{
return - 1 ;
}
2001-11-25 03:18:11 +03:00
int net_ads ( int argc , const char * * argv )
{
2001-11-26 07:53:08 +03:00
return net_ads_usage ( argc , argv ) ;
2001-11-25 03:18:11 +03:00
}
# endif