Modifications extending functionality of newuser cmd and new net group set of commands for group related operations on ldb

Signed-off-by: Jelmer Vernooij <jelmer@samba.org>

source4/scripting/python/samba/netcmd/__init__.py

@@ -160,3 +160,5 @@ from samba.netcmd.vampire import cmd_vampire
 commands["vampire"] = cmd_vampire()
 from samba.netcmd.machinepw import cmd_machinepw
 commands["machinepw"] = cmd_machinepw()
+from samba.netcmd.group import cmd_group
+commands["group"] = cmd_group()

source4/scripting/python/samba/netcmd/group.py

@@ -0,0 +1,189 @@
+#!/usr/bin/python
+#
+# Adds a new user to a Samba4 server
+# Copyright Jelmer Vernooij 2008
+#
+# Based on the original in EJS:
+# Copyright Andrew Tridgell 2005
+#
+# 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 3 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, see <http://www.gnu.org/licenses/>.
+
+import samba.getopt as options
+from samba.netcmd import Command, SuperCommand, CommandError, Option
+import ldb
+
+from getpass import getpass
+from samba.auth import system_session
+from samba.samdb import SamDB
+from samba.dsdb import (
+    GTYPE_SECURITY_DOMAIN_LOCAL_GROUP,
+    GTYPE_SECURITY_GLOBAL_GROUP,
+    GTYPE_SECURITY_UNIVERSAL_GROUP,
+    GTYPE_DISTRIBUTION_DOMAIN_LOCAL_GROUP,
+    GTYPE_DISTRIBUTION_GLOBAL_GROUP,
+    GTYPE_DISTRIBUTION_UNIVERSAL_GROUP,
+)
+
+security_group = dict({"Domain": GTYPE_SECURITY_DOMAIN_LOCAL_GROUP, "Global": GTYPE_SECURITY_GLOBAL_GROUP, "Universal": GTYPE_SECURITY_UNIVERSAL_GROUP})
+distribution_group = dict({"Domain": GTYPE_DISTRIBUTION_DOMAIN_LOCAL_GROUP, "Global": GTYPE_DISTRIBUTION_GLOBAL_GROUP, "Universal": GTYPE_DISTRIBUTION_UNIVERSAL_GROUP})
+
+
+class cmd_group_add(Command):
+    """Creates a new group"""
+
+    synopsis = "%prog group add [options] <groupname>"
+
+    takes_optiongroups = {
+        "sambaopts": options.SambaOptions,
+        "versionopts": options.VersionOptions,
+        "credopts": options.CredentialsOptions,
+    }
+
+    takes_options = [
+        Option("-H", help="LDB URL for database or target server", type=str),
+        Option("--groupou",
+	   help="Alternative location (without domainDN counterpart) to default CN=Users in which new user object will be created",
+	   type=str),
+        Option("--group-scope", type="choice", choices=["Domain", "Global", "Universal"],
+            help="Group scope (Domain | Global | Universal)"),
+        Option("--group-type", type="choice", choices=["Security", "Distribution"],
+            help="Group type (Security | Distribution)"),
+        Option("--description", help="Group's description", type=str),
+        Option("--mail-address", help="Group's email address", type=str),
+        Option("--notes", help="Groups's notes", type=str),
+    ]
+
+    takes_args = ["groupname"]
+
+    def run(self, groupname, credopts=None, sambaopts=None,
+            versionopts=None, H=None, groupou=None, group_scope=None,
+            group_type=None, description=None, mail_address=None, notes=None):
+
+        if cmp((group_type or "Security"), "Security") == 0:
+              gtype = security_group.get(group_scope, GTYPE_SECURITY_GLOBAL_GROUP)
+        else:
+              gtype = distribution_group.get(group_scope, GTYPE_DISTRIBUTION_GLOBAL_GROUP)
+
+        lp = sambaopts.get_loadparm()
+        creds = credopts.get_credentials(lp)
+
+        try:
+            samdb = SamDB(url=H, session_info=system_session(),
+                          credentials=creds, lp=lp)
+            samdb.newgroup(groupname, groupou=groupou, grouptype = gtype,
+                          description=description, mailaddress=mail_address, notes=notes)
+        except ldb.LdbError, (num, msg):
+            raise CommandError('Failed to create group "%s" : %s' % (
+                groupname, msg))
+
+class cmd_group_delete(Command):
+    """Delete a group"""
+
+    synopsis = "%prog group delete <groupname>"
+
+    takes_optiongroups = {
+        "sambaopts": options.SambaOptions,
+        "versionopts": options.VersionOptions,
+        "credopts": options.CredentialsOptions,
+    }
+
+    takes_options = [
+        Option("-H", help="LDB URL for database or target server", type=str),
+    ]
+
+    takes_args = ["groupname"]
+
+    def run(self, groupname, credopts=None, sambaopts=None, versionopts=None, H=None):
+
+        lp = sambaopts.get_loadparm()
+        creds = credopts.get_credentials(lp)
+
+        try:
+            samdb = SamDB(url=H, session_info=system_session(),
+                          credentials=creds, lp=lp)
+            samdb.deletegroup(groupname)
+        except ldb.LdbError, (num, msg):
+            raise CommandError('Failed to remove group "%s": %s' % (
+                groupname , msg))
+
+class cmd_group_add_members(Command):
+    """Add (comma-separated list of) group members"""
+
+    synopsis = "%prog group addmembers <groupname> <listofmembers>"
+
+    takes_optiongroups = {
+        "sambaopts": options.SambaOptions,
+        "versionopts": options.VersionOptions,
+        "credopts": options.CredentialsOptions,
+    }
+
+    takes_options = [
+        Option("-H", help="LDB URL for database or target server", type=str),
+    ]
+
+    takes_args = ["groupname", "listofmembers"]
+
+    def run(self, groupname, listofmembers, credopts=None, sambaopts=None,
+            versionopts=None, H=None):
+
+        lp = sambaopts.get_loadparm()
+        creds = credopts.get_credentials(lp)
+
+        try:
+            samdb = SamDB(url=H, session_info=system_session(),
+                          credentials=creds, lp=lp)
+            samdb.add_remove_group_members(groupname, listofmembers, add_members_operation=True)
+        except ldb.LdbError, (num, msg):
+            raise CommandError('Failed to add members "%s" to group "%s": %s' % (
+                listofmembers, groupname , msg))
+
+class cmd_group_remove_members(Command):
+    """Remove (comma-separated list of) group members"""
+
+    synopsis = "%prog group removemembers <groupname> <listofmembers>"
+
+    takes_optiongroups = {
+        "sambaopts": options.SambaOptions,
+        "versionopts": options.VersionOptions,
+        "credopts": options.CredentialsOptions,
+    }
+
+    takes_options = [
+        Option("-H", help="LDB URL for database or target server", type=str),
+    ]
+
+    takes_args = ["groupname", "listofmembers"]
+
+    def run(self, groupname, listofmembers, credopts=None, sambaopts=None,
+            versionopts=None, H=None):
+
+        lp = sambaopts.get_loadparm()
+        creds = credopts.get_credentials(lp)
+
+        try:
+            samdb = SamDB(url=H, session_info=system_session(),
+                          credentials=creds, lp=lp)
+            samdb.add_remove_group_members(groupname, listofmembers, add_members_operation=False)
+        except ldb.LdbError, (num, msg):
+            raise CommandError('Failed to remove members "%s" from group "%s": %s' % (
+                listofmembers, groupname , msg))
+
+class cmd_group(SuperCommand):
+    """Group management"""
+
+    subcommands = {}
+    subcommands["add"] = cmd_group_add()
+    subcommands["delete"] = cmd_group_delete()
+    subcommands["addmembers"] = cmd_group_add_members()
+    subcommands["removemembers"] = cmd_group_remove_members()

source4/scripting/python/samba/netcmd/newuser.py

@@ -43,12 +43,38 @@ class cmd_newuser(Command):
         Option("--must-change-at-next-login",
             help="Force password to be changed on next login",
             action="store_true"),
+        Option("--use-username-as-cn",
+            help="Force use of username as user's CN",
+            action="store_true"),
+	Option("--userou",
+	   help="Alternative location (without domainDN counterpart) to default CN=Users in which new user object will be created",
+	   type=str),
+        Option("--surname", help="User's surname", type=str),
+        Option("--given-name", help="User's given name", type=str),
+        Option("--initials", help="User's initials", type=str),
+        Option("--profile-path", help="User's profile path", type=str),
+        Option("--script-path", help="User's logon script path", type=str),
+        Option("--home-drive", help="User's home drive letter", type=str),
+        Option("--home-directory", help="User's home directory path", type=str),
+        Option("--job-title", help="User's job title", type=str),
+        Option("--department", help="User's department", type=str),
+        Option("--company", help="User's company", type=str),
+        Option("--description", help="User's description", type=str),
+        Option("--mail-address", help="User's email address", type=str),
+        Option("--internet-address", help="User's home page", type=str),
+        Option("--telephone-number", help="User's phone number", type=str),
+        Option("--physical-delivery-office", help="User's office location", type=str),
     ]
 
     takes_args = ["username", "password?"]
 
     def run(self, username, password=None, credopts=None, sambaopts=None,
-            versionopts=None, H=None, must_change_at_next_login=None):
+            versionopts=None, H=None, must_change_at_next_login=None,
+            use_username_as_cn=None, userou=None, surname=None, given_name=None, initials=None,
+            profile_path=None, script_path=None, home_drive=None, home_directory=None,
+            job_title=None, department=None, company=None, description=None,
+            mail_address=None, internet_address=None, telephone_number=None, physical_delivery_office=None):
+
         if password is None:
             password = getpass("New Password: ")
 
@@ -59,7 +85,12 @@ class cmd_newuser(Command):
             samdb = SamDB(url=H, session_info=system_session(),
                           credentials=creds, lp=lp)
             samdb.newuser(username, password,
-                          force_password_change_at_next_login_req=must_change_at_next_login)
+                          force_password_change_at_next_login_req=must_change_at_next_login,
+                          useusernameascn=use_username_as_cn, userou=userou, surname=surname, givenname=given_name, initials=initials,
+                          profilepath=profile_path, homedrive=home_drive, scriptpath=script_path, homedirectory=home_directory,
+                          jobtitle=job_title, department=department, company=company, description=description,
+                          mailaddress=mail_address, internetaddress=internet_address,
+                          telephonenumber=telephone_number, physicaldeliveryoffice=physical_delivery_office)
         except ldb.LdbError, (num, msg):
             raise CommandError('Failed to create user "%s" : %s' % (
                 username, msg))

source4/scripting/python/samba/samdb.py

@@ -112,23 +112,232 @@ pwdLastSet: 0
 """ % (user_dn)
         self.modify_ldif(mod)
 
+    def newgroup(self, groupname, groupou=None, grouptype=None,
+                 description=None, mailaddress=None, notes=None):
+        """Adds a new group with additional parameters
+
+        :param groupname: Name of the new group
+        :param grouptype: Type of the new group
+        :param description: Description of the new group
+        :param mailaddress: Email address of the new group
+        :param notes: Notes of the new group
+        """
+
+        self.transaction_start()
+        try:
+            group_dn = "CN=%s,%s,%s" % (groupname, (groupou or "CN=Users"), self.domain_dn())
+
+            # The new user record. Note the reliance on the SAMLDB module which
+            # fills in the default informations
+	    ldbmessage = {"dn": group_dn,
+                "sAMAccountName": groupname,
+                "objectClass": "group"}
+
+	    if grouptype is not None:
+                ldbmessage["groupType"] = "%d" % ((grouptype)-2**32)
+
+            if description is not None:
+                ldbmessage["description"] = description
+
+            if mailaddress is not None:
+                ldbmessage["mail"] = mailaddress
+
+            if notes is not None:
+                ldbmessage["info"] = notes
+
+            self.add(ldbmessage)
+
+        except:
+            self.transaction_cancel()
+            raise
+        else:
+            self.transaction_commit()
+
+    def deletegroup (self, groupname):
+        """Deletes a group
+
+        :param groupname: Name of the target group
+        """
+
+        groupfilter = "(&(sAMAccountName=%s)(objectCategory=%s,%s))" % (groupname, "CN=Group,CN=Schema,CN=Configuration", self.domain_dn())
+        self.transaction_start()
+        try:
+            targetgroup = self.search(base=self.domain_dn(), scope=ldb.SCOPE_SUBTREE,
+                               expression=groupfilter, attrs=[])
+            if len(targetgroup) == 0:
+                print('Unable to find group "%s"' % (groupname or expression))
+                raise
+            assert(len(targetgroup) == 1)
+
+            self.delete (targetgroup[0].dn);
+
+        except:
+            self.transaction_cancel()
+            raise
+        else:
+            self.transaction_commit()
+
+    def add_remove_group_members (self, groupname, listofmembers,
+                                  add_members_operation=True):
+        """Adds or removes group members
+
+        :param groupname: Name of the target group
+        :param listofmembers: Comma-separated list of group members
+        :param add_members_operation: Defines if its an add or remove operation
+        """
+
+        groupfilter = "(&(sAMAccountName=%s)(objectCategory=%s,%s))" % (groupname, "CN=Group,CN=Schema,CN=Configuration", self.domain_dn())
+        groupmembers = listofmembers.split(',')
+
+        self.transaction_start()
+        try:
+            targetgroup = self.search(base=self.domain_dn(), scope=ldb.SCOPE_SUBTREE,
+                               expression=groupfilter, attrs=['member'])
+            if len(targetgroup) == 0:
+                print('Unable to find group "%s"' % (groupname or expression))
+                raise
+            assert(len(targetgroup) == 1)
+
+            modified = False
+
+            addtargettogroup = """
+dn: %s
+changetype: modify
+""" % (str(targetgroup[0].dn))
+
+            for member in groupmembers:
+                targetmember = self.search(base=self.domain_dn(), scope=ldb.SCOPE_SUBTREE,
+                                    expression="(sAMAccountName=%s)" % member, attrs=[])
+
+                if len(targetmember) != 1:
+                   continue
+
+                if add_members_operation is True and (targetgroup[0].get('member') is None or str(targetmember[0].dn) not in targetgroup[0]['member']):
+                   modified = True
+                   addtargettogroup += """add: member
+member: %s
+""" % (str(targetmember[0].dn))
+
+                elif add_members_operation is False and (targetgroup[0].get('member') is not None and str(targetmember[0].dn) in targetgroup[0]['member']):
+                   modified = True
+                   addtargettogroup += """delete: member
+member: %s
+""" % (str(targetmember[0].dn))
+
+            if modified is True:
+               self.modify_ldif(addtargettogroup)
+
+        except:
+            self.transaction_cancel()
+            raise
+        else:
+            self.transaction_commit()
+
     def newuser(self, username, password,
-                force_password_change_at_next_login_req=False):
-        """Adds a new user
+                force_password_change_at_next_login_req=False,
+		useusernameascn=False, userou=None, surname=None, givenname=None, initials=None,
+		profilepath=None, scriptpath=None, homedrive=None, homedirectory=None,
+		jobtitle=None, department=None, company=None, description=None,
+		mailaddress=None, internetaddress=None, telephonenumber=None,
+		physicaldeliveryoffice=None):
+        """Adds a new user with additional parameters
 
         :param username: Name of the new user
         :param password: Password for the new user
         :param force_password_change_at_next_login_req: Force password change
-        """
+        :param useusernameascn: Use username as cn rather that firstname + initials + lastname
+        :param userou: Object container (without domainDN postfix) for new user
+        :param surname: Surname of the new user
+        :param givenname: First name of the new user
+        :param initials: Initials of the new user
+        :param profilepath: Profile path of the new user
+        :param scriptpath: Logon script path of the new user
+        :param homedrive: Home drive of the new user
+        :param homedirectory: Home directory of the new user
+        :param jobtitle: Job title of the new user
+        :param department: Department of the new user
+        :param company: Company of the new user
+        :param description: of the new user
+        :param mailaddress: Email address of the new user
+        :param internetaddress: Home page of the new user
+        :param telephonenumber: Phone number of the new user
+        :param physicaldeliveryoffice: Office location of the new user
+	"""
+
+        displayname = "";
+        if givenname is not None:
+            displayname += givenname
+
+        if initials is not None:
+            displayname += ' %s.' % initials
+
+        if surname is not None:
+            displayname += ' %s' % surname
+
+	cn = username
+        if useusernameascn is None and displayname is not "":
+            cn = displayname
+
         self.transaction_start()
         try:
-            user_dn = "CN=%s,CN=Users,%s" % (username, self.domain_dn())
+            user_dn = "CN=%s,%s,%s" % (cn, (userou or "CN=Users"), self.domain_dn())
 
             # The new user record. Note the reliance on the SAMLDB module which
             # fills in the default informations
-            self.add({"dn": user_dn, 
+	    ldbmessage = {"dn": user_dn,
                 "sAMAccountName": username,
-                "objectClass": "user"})
+                "objectClass": "user"}
+
+	    if surname is not None:
+                ldbmessage["sn"] = surname
+
+	    if givenname is not None:
+                ldbmessage["givenName"] = givenname
+
+	    if displayname is not "":
+                ldbmessage["displayName"] = displayname
+                ldbmessage["name"] = displayname
+
+	    if initials is not None:
+                ldbmessage["initials"] = '%s.' % initials
+
+	    if profilepath is not None:
+                ldbmessage["profilePath"] = profilepath
+
+            if scriptpath is not None:
+                ldbmessage["scriptPath"] = scriptpath
+
+            if homedrive is not None:
+                ldbmessage["homeDrive"] = homedrive
+
+            if homedirectory is not None:
+                ldbmessage["homeDirectory"] = homedirectory
+
+            if jobtitle is not None:
+                ldbmessage["title"] = jobtitle
+
+            if department is not None:
+                ldbmessage["department"] = department
+
+            if company is not None:
+                ldbmessage["company"] = company
+
+            if description is not None:
+                ldbmessage["description"] = description
+
+            if mailaddress is not None:
+                ldbmessage["mail"] = mailaddress
+
+            if internetaddress is not None:
+                ldbmessage["wWWHomePage"] = internetaddress
+
+            if telephonenumber is not None:
+                ldbmessage["telephoneNumber"] = telephonenumber
+
+            if physicaldeliveryoffice is not None:
+                ldbmessage["physicalDeliveryOfficeName"] = physicaldeliveryoffice
+
+            self.add(ldbmessage)
 
             # Sets the password for it
             self.setpassword("(dn=" + user_dn + ")", password,