This commit was manufactured by cvs2svn to create branch 'SAMBA_3_0'.(This used to...
authorcvs2svn Import User <samba-bugs@samba.org>
Fri, 12 Apr 2002 03:54:14 +0000 (03:54 +0000)
committercvs2svn Import User <samba-bugs@samba.org>
Fri, 12 Apr 2002 03:54:14 +0000 (03:54 +0000)
27 files changed:
source3/Makefile.in
source3/include/rpc_client_proto.h [deleted file]
source3/lib/domain_namemap.c [deleted file]
source3/passdb/passdb.c
source3/python/.cvsignore [deleted file]
source3/python/py_common.c [deleted file]
source3/python/py_common.h [deleted file]
source3/python/py_conv.c [deleted file]
source3/python/py_conv.h [deleted file]
source3/python/py_lsa.c [deleted file]
source3/python/py_spoolss.c [deleted file]
source3/python/py_spoolss.h [deleted file]
source3/python/py_spoolss_drivers.c [deleted file]
source3/python/py_spoolss_drivers_conv.c [deleted file]
source3/python/py_spoolss_forms.c [deleted file]
source3/python/py_spoolss_forms_conv.c [deleted file]
source3/python/py_spoolss_ports.c [deleted file]
source3/python/py_spoolss_printers.c [deleted file]
source3/python/py_spoolss_printers_conv.c [deleted file]
source3/python/py_spoolss_proto.h [deleted file]
source3/python/py_winbind.c [deleted file]
source3/python/samba-head.patch [deleted file]
source3/python/setup.py.in [deleted file]
source3/rpc_server/srv_samr_nt.c
source3/smbd/mangle_hash2.c
source3/smbd/uid.c
source3/torture/torture.c

index 476997512fa4671f63a36b195fec2beb9838127c..54e3238fba2639ecf4bc845387ac010314c48788 100644 (file)
@@ -364,7 +364,7 @@ NMBLOOKUP_OBJ = utils/nmblookup.o $(PARAM_OBJ) $(UBIQX_OBJ) \
                 $(LIBSMB_OBJ) $(LIB_OBJ)
 
 SMBTORTURE_OBJ = torture/torture.o torture/nbio.o torture/scanner.o torture/utable.o \
-               torture/denytest.o torture/mangle_test.o \
+               torture/denytest.o \
        $(LIBSMB_OBJ) $(PARAM_OBJ) $(UBIQX_OBJ) $(LIB_OBJ)
 
 MASKTEST_OBJ = torture/masktest.o $(LIBSMB_OBJ) $(PARAM_OBJ) \
diff --git a/source3/include/rpc_client_proto.h b/source3/include/rpc_client_proto.h
deleted file mode 100644 (file)
index 0ecb195..0000000
+++ /dev/null
@@ -1,231 +0,0 @@
-#ifndef _RPC_CLIENT_PROTO_H_
-#define _RPC_CLIENT_PROTO_H_
-/* This file is automatically generated with "make proto". DO NOT EDIT */
-
-
-/*The following definitions come from  lib/util_list.c  */
-
-BOOL copy_policy_hnd (POLICY_HND *dest, const POLICY_HND *src);
-BOOL compare_rpc_hnd_node(const RPC_HND_NODE *x, 
-                         const RPC_HND_NODE *y);
-BOOL RpcHndList_set_connection(const POLICY_HND *hnd, 
-                              struct cli_connection *con);
-BOOL RpcHndList_del_connection(const POLICY_HND *hnd);
-struct cli_connection* RpcHndList_get_connection(const POLICY_HND *hnd);
-
-/*The following definitions come from  rpc_client/cli_connect.c  */
-
-void init_connections(void);
-void free_connections(void);
-void cli_connection_free(struct cli_connection *con);
-void cli_connection_unlink(struct cli_connection *con);
-BOOL cli_connection_init(const char *srv_name, char *pipe_name,
-                         struct cli_connection **con);
-BOOL cli_connection_init_auth(const char *srv_name, char *pipe_name,
-                              struct cli_connection **con,
-                              cli_auth_fns * auth, void *auth_creds);
-struct _cli_auth_fns *cli_conn_get_authfns(struct cli_connection *con);
-void *cli_conn_get_auth_creds(struct cli_connection *con);
-BOOL rpc_hnd_pipe_req(const POLICY_HND * hnd, uint8 op_num,
-                      prs_struct * data, prs_struct * rdata);
-BOOL rpc_con_pipe_req(struct cli_connection *con, uint8 op_num,
-                      prs_struct * data, prs_struct * rdata);
-BOOL rpc_con_ok(struct cli_connection *con);
-
-/*The following definitions come from  rpc_client/cli_login.c  */
-
-BOOL cli_nt_setup_creds(struct cli_state *cli, unsigned char mach_pwd[16]);
-BOOL cli_nt_srv_pwset(struct cli_state *cli, unsigned char *new_hashof_mach_pwd);
-BOOL cli_nt_login_interactive(struct cli_state *cli, char *domain, char *username, 
-                              uint32 smb_userid_low, char *password,
-                              NET_ID_INFO_CTR *ctr, NET_USER_INFO_3 *user_info3);
-BOOL cli_nt_login_network(struct cli_state *cli, char *domain, char *username, 
-                          uint32 smb_userid_low, char lm_chal[8], 
-                         char *lm_chal_resp, char *nt_chal_resp,
-                          NET_ID_INFO_CTR *ctr, NET_USER_INFO_3 *user_info3);
-BOOL cli_nt_logoff(struct cli_state *cli, NET_ID_INFO_CTR *ctr);
-
-/*The following definitions come from  rpc_client/cli_lsarpc.c  */
-
-BOOL do_lsa_open_policy(struct cli_state *cli,
-                       char *system_name, POLICY_HND *hnd,
-                       BOOL sec_qos);
-BOOL do_lsa_query_info_pol(struct cli_state *cli,
-                       POLICY_HND *hnd, uint16 info_class,
-                       fstring domain_name, DOM_SID *domain_sid);
-BOOL do_lsa_close(struct cli_state *cli, POLICY_HND *hnd);
-BOOL cli_lsa_get_domain_sid(struct cli_state *cli, char *server);
-uint32 lsa_open_policy(const char *system_name, POLICY_HND *hnd,
-                      BOOL sec_qos, uint32 des_access);
-uint32 lsa_lookup_sids(POLICY_HND *hnd, int num_sids, DOM_SID *sids,
-                      char ***names, uint32 **types, int *num_names);
-uint32 lsa_lookup_names(POLICY_HND *hnd, int num_names, char **names,
-                       DOM_SID **sids, uint32 **types, int *num_sids);
-
-/*The following definitions come from  rpc_client/cli_netlogon.c  */
-
-BOOL cli_net_logon_ctrl2(struct cli_state *cli, uint32 status_level);
-BOOL cli_net_auth2(struct cli_state *cli, uint16 sec_chan, 
-                   uint32 neg_flags, DOM_CHAL *srv_chal);
-BOOL cli_net_req_chal(struct cli_state *cli, DOM_CHAL *clnt_chal, DOM_CHAL *srv_chal);
-BOOL cli_net_srv_pwset(struct cli_state *cli, uint8 hashed_mach_pwd[16]);
-BOOL cli_net_sam_logon(struct cli_state *cli, NET_ID_INFO_CTR *ctr, NET_USER_INFO_3 *user_info3);
-BOOL cli_net_sam_logoff(struct cli_state *cli, NET_ID_INFO_CTR *ctr);
-BOOL change_trust_account_password( char *domain, char *remote_machine_list);
-
-/*The following definitions come from  rpc_client/cli_pipe.c  */
-
-BOOL rpc_api_pipe_req(struct cli_state *cli, uint8 op_num,
-                      prs_struct *data, prs_struct *rdata);
-BOOL rpc_pipe_bind(struct cli_state *cli, char *pipe_name, char *my_name);
-void cli_nt_set_ntlmssp_flgs(struct cli_state *cli, uint32 ntlmssp_flgs);
-BOOL cli_nt_session_open(struct cli_state *cli, char *pipe_name);
-void cli_nt_session_close(struct cli_state *cli);
-
-/*The following definitions come from  rpc_client/cli_reg.c  */
-
-BOOL do_reg_connect(struct cli_state *cli, char *full_keyname, char *key_name,
-                               POLICY_HND *reg_hnd);
-BOOL do_reg_open_hklm(struct cli_state *cli, uint16 unknown_0, uint32 level,
-                               POLICY_HND *hnd);
-BOOL do_reg_open_hku(struct cli_state *cli, uint16 unknown_0, uint32 level,
-                               POLICY_HND *hnd);
-BOOL do_reg_flush_key(struct cli_state *cli, POLICY_HND *hnd);
-BOOL do_reg_query_key(struct cli_state *cli, POLICY_HND *hnd,
-                               char *class, uint32 *class_len,
-                               uint32 *num_subkeys, uint32 *max_subkeylen,
-                               uint32 *max_subkeysize, uint32 *num_values,
-                               uint32 *max_valnamelen, uint32 *max_valbufsize,
-                               uint32 *sec_desc, NTTIME *mod_time);
-BOOL do_reg_unknown_1a(struct cli_state *cli, POLICY_HND *hnd, uint32 *unk);
-BOOL do_reg_query_info(struct cli_state *cli, POLICY_HND *hnd,
-                               char *key_value, uint32* key_type);
-BOOL do_reg_set_key_sec(struct cli_state *cli, POLICY_HND *hnd, SEC_DESC_BUF *sec_desc_buf);
-BOOL do_reg_get_key_sec(struct cli_state *cli, POLICY_HND *hnd, uint32 *sec_buf_size, SEC_DESC_BUF **ppsec_desc_buf);
-BOOL do_reg_delete_val(struct cli_state *cli, POLICY_HND *hnd, char *val_name);
-BOOL do_reg_delete_key(struct cli_state *cli, POLICY_HND *hnd, char *key_name);
-BOOL do_reg_create_key(struct cli_state *cli, POLICY_HND *hnd,
-                               char *key_name, char *key_class,
-                               SEC_ACCESS *sam_access,
-                               POLICY_HND *key);
-BOOL do_reg_enum_key(struct cli_state *cli, POLICY_HND *hnd,
-                               int key_index, char *key_name,
-                               uint32 *unk_1, uint32 *unk_2,
-                               time_t *mod_time);
-BOOL do_reg_create_val(struct cli_state *cli, POLICY_HND *hnd,
-                               char *val_name, uint32 type, BUFFER3 *data);
-BOOL do_reg_enum_val(struct cli_state *cli, POLICY_HND *hnd,
-                               int val_index, int max_valnamelen, int max_valbufsize,
-                               fstring val_name,
-                               uint32 *val_type, BUFFER2 *value);
-BOOL do_reg_open_entry(struct cli_state *cli, POLICY_HND *hnd,
-                               char *key_name, uint32 unk_0,
-                               POLICY_HND *key_hnd);
-BOOL do_reg_close(struct cli_state *cli, POLICY_HND *hnd);
-
-/*The following definitions come from  rpc_client/cli_samr.c  */
-
-BOOL get_samr_query_usergroups(struct cli_state *cli, 
-                               POLICY_HND *pol_open_domain, uint32 user_rid,
-                               uint32 *num_groups, DOM_GID *gid);
-BOOL get_samr_query_userinfo(struct cli_state *cli, 
-                               POLICY_HND *pol_open_domain,
-                               uint32 info_level,
-                               uint32 user_rid, SAM_USER_INFO_21 *usr);
-BOOL do_samr_chgpasswd_user(struct cli_state *cli,
-               char *srv_name, char *user_name,
-               char nt_newpass[516], uchar nt_oldhash[16],
-               char lm_newpass[516], uchar lm_oldhash[16]);
-BOOL do_samr_unknown_38(struct cli_state *cli, char *srv_name);
-BOOL do_samr_query_dom_info(struct cli_state *cli, 
-                               POLICY_HND *domain_pol, uint16 switch_value);
-BOOL do_samr_enum_dom_users(struct cli_state *cli, 
-                               POLICY_HND *pol, uint16 num_entries, uint16 unk_0,
-                               uint16 acb_mask, uint16 unk_1, uint32 size,
-                               struct acct_info **sam,
-                               int *num_sam_users);
-BOOL do_samr_connect(struct cli_state *cli, 
-                               char *srv_name, uint32 unknown_0,
-                               POLICY_HND *connect_pol);
-BOOL do_samr_open_user(struct cli_state *cli, 
-                               POLICY_HND *pol, uint32 unk_0, uint32 rid, 
-                               POLICY_HND *user_pol);
-BOOL do_samr_open_domain(struct cli_state *cli, 
-                               POLICY_HND *connect_pol, uint32 rid, DOM_SID *sid,
-                               POLICY_HND *domain_pol);
-BOOL do_samr_query_unknown_12(struct cli_state *cli, 
-                               POLICY_HND *pol, uint32 rid, uint32 num_gids, uint32 *gids,
-                               uint32 *num_aliases,
-                               fstring als_names    [MAX_LOOKUP_SIDS],
-                               uint32  num_als_users[MAX_LOOKUP_SIDS]);
-BOOL do_samr_query_usergroups(struct cli_state *cli, 
-                               POLICY_HND *pol, uint32 *num_groups, DOM_GID *gid);
-BOOL do_samr_query_userinfo(struct cli_state *cli, 
-                               POLICY_HND *pol, uint16 switch_value, void* usr);
-BOOL do_samr_close(struct cli_state *cli, POLICY_HND *hnd);
-
-/*The following definitions come from  rpc_client/cli_spoolss_notify.c  */
-
-BOOL spoolss_disconnect_from_client( struct cli_state *cli);
-BOOL spoolss_connect_to_client( struct cli_state *cli, char *remote_machine);
-BOOL cli_spoolss_reply_open_printer(struct cli_state *cli, char *printer, uint32 localprinter, uint32 type, uint32 *status, POLICY_HND *handle);
-BOOL cli_spoolss_reply_rrpcn(struct cli_state *cli, POLICY_HND *handle, 
-                            uint32 change_low, uint32 change_high, uint32 *status);
-BOOL cli_spoolss_reply_close_printer(struct cli_state *cli, POLICY_HND *handle, uint32 *status);
-
-/*The following definitions come from  rpc_client/cli_srvsvc.c  */
-
-BOOL do_srv_net_srv_conn_enum(struct cli_state *cli,
-                       char *server_name, char *qual_name,
-                       uint32 switch_value, SRV_CONN_INFO_CTR *ctr,
-                       uint32 preferred_len,
-                       ENUM_HND *hnd);
-BOOL do_srv_net_srv_sess_enum(struct cli_state *cli,
-                       char *server_name, char *qual_name,
-                       uint32 switch_value, SRV_SESS_INFO_CTR *ctr,
-                       uint32 preferred_len,
-                       ENUM_HND *hnd);
-BOOL do_srv_net_srv_share_enum(struct cli_state *cli,
-                       char *server_name, 
-                       uint32 switch_value, SRV_R_NET_SHARE_ENUM *r_o,
-                       uint32 preferred_len, ENUM_HND *hnd);
-BOOL do_srv_net_srv_file_enum(struct cli_state *cli,
-                       char *server_name, char *qual_name,
-                       uint32 switch_value, SRV_FILE_INFO_CTR *ctr,
-                       uint32 preferred_len,
-                       ENUM_HND *hnd);
-BOOL do_srv_net_srv_get_info(struct cli_state *cli,
-                       char *server_name, uint32 switch_value, SRV_INFO_CTR *ctr);
-
-/*The following definitions come from  rpc_client/cli_use.c  */
-
-void init_cli_use(void);
-void free_cli_use(void);
-struct cli_state *cli_net_use_add(const char *srv_name,
-                                 const struct ntuser_creds *usr_creds,
-                                 BOOL reuse, BOOL *is_new);
-BOOL cli_net_use_del(const char *srv_name,
-                    const struct ntuser_creds *usr_creds,
-                    BOOL force_close, BOOL *connection_closed);
-void cli_net_use_enum(uint32 *num_cons, struct use_info ***use);
-void cli_use_wait_keyboard(void);
-
-/*The following definitions come from  rpc_client/cli_wkssvc.c  */
-
-BOOL do_wks_query_info(struct cli_state *cli, 
-                       char *server_name, uint32 switch_value,
-                       WKS_INFO_100 *wks100);
-
-/*The following definitions come from  rpc_client/ncacn_np_use.c  */
-
-BOOL ncacn_np_use_del(const char *srv_name, const char *pipe_name,
-                      const vuser_key * key,
-                      BOOL force_close, BOOL *connection_closed);
-struct ncacn_np *ncacn_np_initialise(struct ncacn_np *msrpc,
-                                     const vuser_key * key);
-struct ncacn_np *ncacn_np_use_add(const char *pipe_name,
-                                  const vuser_key * key,
-                                  const char *srv_name,
-                                  const struct ntuser_creds *ntc,
-                                  BOOL reuse, BOOL *is_new_connection);
-#endif /* _PROTO_H_ */
diff --git a/source3/lib/domain_namemap.c b/source3/lib/domain_namemap.c
deleted file mode 100644 (file)
index 988f5e5..0000000
+++ /dev/null
@@ -1,1317 +0,0 @@
-/* 
-   Unix SMB/Netbios implementation.
-   Version 1.9.
-   Groupname handling
-   Copyright (C) Jeremy Allison 1998.
-   
-   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 02139, USA.
-*/
-
-/* 
- * UNIX gid and Local or Domain SID resolution.  This module resolves
- * only those entries in the map files, it is *NOT* responsible for
- * resolving UNIX groups not listed: that is an entirely different
- * matter, altogether...
- */
-
-/*
- *
- *
-
- format of the file is:
-
- unixname      NT Group name
- unixname      Domain Admins (well-known Domain Group)
- unixname      DOMAIN_NAME\NT Group name
- unixname      OTHER_DOMAIN_NAME\NT Group name
- unixname      DOMAIN_NAME\Domain Admins (well-known Domain Group)
- ....
-
- if the DOMAIN_NAME\ component is left off, then your own domain is assumed.
-
- *
- *
- */
-
-
-#include "includes.h"
-extern int DEBUGLEVEL;
-
-extern fstring global_myworkgroup;
-extern DOM_SID global_member_sid;
-extern fstring global_sam_name;
-extern DOM_SID global_sam_sid;
-extern DOM_SID global_sid_S_1_5_20;
-
-/*******************************************************************
- converts UNIX uid to an NT User RID. NOTE: IS SOMETHING SPECIFIC TO SAMBA
- ********************************************************************/
-static uid_t pwdb_user_rid_to_uid(uint32 user_rid)
-{
-       return ((user_rid & (~RID_TYPE_USER))- 1000)/RID_MULTIPLIER;
-}
-
-/*******************************************************************
- converts NT Group RID to a UNIX uid. NOTE: IS SOMETHING SPECIFIC TO SAMBA
- ********************************************************************/
-static uint32 pwdb_group_rid_to_gid(uint32 group_rid)
-{
-       return ((group_rid & (~RID_TYPE_GROUP))- 1000)/RID_MULTIPLIER;
-}
-
-/*******************************************************************
- converts NT Alias RID to a UNIX uid. NOTE: IS SOMETHING SPECIFIC TO SAMBA
- ********************************************************************/
-static uint32 pwdb_alias_rid_to_gid(uint32 alias_rid)
-{
-       return ((alias_rid & (~RID_TYPE_ALIAS))- 1000)/RID_MULTIPLIER;
-}
-
-/*******************************************************************
- converts NT Group RID to a UNIX uid. NOTE: IS SOMETHING SPECIFIC TO SAMBA
- ********************************************************************/
-static uint32 pwdb_gid_to_group_rid(uint32 gid)
-{
-       uint32 grp_rid = ((((gid)*RID_MULTIPLIER) + 1000) | RID_TYPE_GROUP);
-       return grp_rid;
-}
-
-/******************************************************************
- converts UNIX gid to an NT Alias RID. NOTE: IS SOMETHING SPECIFIC TO SAMBA
- ********************************************************************/
-static uint32 pwdb_gid_to_alias_rid(uint32 gid)
-{
-       uint32 alias_rid = ((((gid)*RID_MULTIPLIER) + 1000) | RID_TYPE_ALIAS);
-       return alias_rid;
-}
-
-/*******************************************************************
- converts UNIX uid to an NT User RID. NOTE: IS SOMETHING SPECIFIC TO SAMBA
- ********************************************************************/
-static uint32 pwdb_uid_to_user_rid(uint32 uid)
-{
-       uint32 user_rid = ((((uid)*RID_MULTIPLIER) + 1000) | RID_TYPE_USER);
-       return user_rid;
-}
-
-/******************************************************************
- converts SID + SID_NAME_USE type to a UNIX id.  the Domain SID is,
- and can only be, our own SID.
- ********************************************************************/
-static BOOL pwdb_sam_sid_to_unixid(DOM_SID *sid, uint8 type, uint32 *id)
-{
-       DOM_SID tmp_sid;
-       uint32 rid;
-
-       sid_copy(&tmp_sid, sid);
-       sid_split_rid(&tmp_sid, &rid);
-       if (!sid_equal(&global_sam_sid, &tmp_sid))
-       {
-               return False;
-       }
-
-       switch (type)
-       {
-               case SID_NAME_USER:
-               {
-                       *id = pwdb_user_rid_to_uid(rid);
-                       return True;
-               }
-               case SID_NAME_ALIAS:
-               {
-                       *id = pwdb_alias_rid_to_gid(rid);
-                       return True;
-               }
-               case SID_NAME_DOM_GRP:
-               case SID_NAME_WKN_GRP:
-               {
-                       *id = pwdb_group_rid_to_gid(rid);
-                       return True;
-               }
-       }
-       return False;
-}
-
-/******************************************************************
- converts UNIX gid + SID_NAME_USE type to a SID.  the Domain SID is,
- and can only be, our own SID.
- ********************************************************************/
-static BOOL pwdb_unixid_to_sam_sid(uint32 id, uint8 type, DOM_SID *sid)
-{
-       sid_copy(sid, &global_sam_sid);
-       switch (type)
-       {
-               case SID_NAME_USER:
-               {
-                       sid_append_rid(sid, pwdb_uid_to_user_rid(id));
-                       return True;
-               }
-               case SID_NAME_ALIAS:
-               {
-                       sid_append_rid(sid, pwdb_gid_to_alias_rid(id));
-                       return True;
-               }
-               case SID_NAME_DOM_GRP:
-               case SID_NAME_WKN_GRP:
-               {
-                       sid_append_rid(sid, pwdb_gid_to_group_rid(id));
-                       return True;
-               }
-       }
-       return False;
-}
-
-/*******************************************************************
- Decides if a RID is a well known RID.
- ********************************************************************/
-static BOOL pwdb_rid_is_well_known(uint32 rid)
-{
-       return (rid < 1000);
-}
-
-/*******************************************************************
- determines a rid's type.  NOTE: THIS IS SOMETHING SPECIFIC TO SAMBA
- ********************************************************************/
-static uint32 pwdb_rid_type(uint32 rid)
-{
-       /* lkcl i understand that NT attaches an enumeration to a RID
-        * such that it can be identified as either a user, group etc
-        * type: SID_ENUM_TYPE.
-        */
-       if (pwdb_rid_is_well_known(rid))
-       {
-               /*
-                * The only well known user RIDs are DOMAIN_USER_RID_ADMIN
-                * and DOMAIN_USER_RID_GUEST.
-                */
-               if (rid == DOMAIN_USER_RID_ADMIN || rid == DOMAIN_USER_RID_GUEST)
-               {
-                       return RID_TYPE_USER;
-               }
-               if (DOMAIN_GROUP_RID_ADMINS <= rid && rid <= DOMAIN_GROUP_RID_GUESTS)
-               {
-                       return RID_TYPE_GROUP;
-               }
-               if (BUILTIN_ALIAS_RID_ADMINS <= rid && rid <= BUILTIN_ALIAS_RID_REPLICATOR)
-               {
-                       return RID_TYPE_ALIAS;
-               }
-       }
-       return (rid & RID_TYPE_MASK);
-}
-
-/*******************************************************************
- checks whether rid is a user rid.  NOTE: THIS IS SOMETHING SPECIFIC TO SAMBA
- ********************************************************************/
-BOOL pwdb_rid_is_user(uint32 rid)
-{
-       return pwdb_rid_type(rid) == RID_TYPE_USER;
-}
-
-/**************************************************************************
- Groupname map functionality. The code loads a groupname map file and
- (currently) loads it into a linked list. This is slow and memory
- hungry, but can be changed into a more efficient storage format
- if the demands on it become excessive.
-***************************************************************************/
-
-typedef struct name_map
-{
-       ubi_slNode next;
-       DOM_NAME_MAP grp;
-
-} name_map_entry;
-
-static ubi_slList groupname_map_list;
-static ubi_slList aliasname_map_list;
-static ubi_slList ntusrname_map_list;
-
-static void delete_name_entry(name_map_entry *gmep)
-{
-       if (gmep->grp.nt_name)
-       {
-               free(gmep->grp.nt_name);
-       }
-       if (gmep->grp.nt_domain)
-       {
-               free(gmep->grp.nt_domain);
-       }
-       if (gmep->grp.unix_name)
-       {
-               free(gmep->grp.unix_name);
-       }
-       free((char*)gmep);
-}
-
-/**************************************************************************
- Delete all the entries in the name map list.
-***************************************************************************/
-
-static void delete_map_list(ubi_slList *map_list)
-{
-       name_map_entry *gmep;
-
-       while ((gmep = (name_map_entry *)ubi_slRemHead(map_list )) != NULL)
-       {
-               delete_name_entry(gmep);
-       }
-}
-
-
-/**************************************************************************
- makes a group sid out of a domain sid and a _unix_ gid.
-***************************************************************************/
-static BOOL make_mydomain_sid(DOM_NAME_MAP *grp, DOM_MAP_TYPE type)
-{
-       int ret = False;
-       fstring sid_str;
-
-       if (!map_domain_name_to_sid(&grp->sid, &(grp->nt_domain)))
-       {
-               DEBUG(0,("make_mydomain_sid: unknown domain %s\n",
-                         grp->nt_domain));
-               return False;
-       }
-
-       if (sid_equal(&grp->sid, &global_sid_S_1_5_20))
-       {
-               /*
-                * only builtin aliases are recognised in S-1-5-20
-                */
-               DEBUG(10,("make_mydomain_sid: group %s in builtin domain\n",
-                          grp->nt_name));
-
-               if (lookup_builtin_alias_name(grp->nt_name, "BUILTIN", &grp->sid, &grp->type) != 0x0)
-               {
-                       DEBUG(0,("unix group %s mapped to an unrecognised BUILTIN domain name %s\n",
-                                 grp->unix_name, grp->nt_name));
-                       return False;
-               }
-               ret = True;
-       }
-       else if (lookup_wk_user_name(grp->nt_name, grp->nt_domain, &grp->sid, &grp->type) == 0x0)
-       {
-               if (type != DOM_MAP_USER)
-               {
-                       DEBUG(0,("well-known NT user %s\\%s listed in wrong map file\n",
-                                 grp->nt_domain, grp->nt_name));
-                       return False;
-               }
-               ret = True;
-       }
-       else if (lookup_wk_group_name(grp->nt_name, grp->nt_domain, &grp->sid, &grp->type) == 0x0)
-       {
-               if (type != DOM_MAP_DOMAIN)
-               {
-                       DEBUG(0,("well-known NT group %s\\%s listed in wrong map file\n",
-                                 grp->nt_domain, grp->nt_name));
-                       return False;
-               }
-               ret = True;
-       }
-       else
-       {
-               switch (type)
-               {
-                       case DOM_MAP_USER:
-                       {
-                               grp->type = SID_NAME_USER;
-                               break;
-                       }
-                       case DOM_MAP_DOMAIN:
-                       {
-                               grp->type = SID_NAME_DOM_GRP;
-                               break;
-                       }
-                       case DOM_MAP_LOCAL:
-                       {
-                               grp->type = SID_NAME_ALIAS;
-                               break;
-                       }
-               }
-
-               ret = pwdb_unixid_to_sam_sid(grp->unix_id, grp->type, &grp->sid);
-       }
-
-       sid_to_string(sid_str, &grp->sid);
-       DEBUG(10,("nt name %s\\%s gid %d mapped to %s\n",
-                  grp->nt_domain, grp->nt_name, grp->unix_id, sid_str));
-       return ret;
-}
-
-/**************************************************************************
- makes a group sid out of an nt domain, nt group name or a unix group name.
-***************************************************************************/
-static BOOL unix_name_to_nt_name_info(DOM_NAME_MAP *map, DOM_MAP_TYPE type)
-{
-       /*
-        * Attempt to get the unix gid_t for this name.
-        */
-
-       DEBUG(5,("unix_name_to_nt_name_info: unix_name:%s\n", map->unix_name));
-
-       if (type == DOM_MAP_USER)
-       {
-               const struct passwd *pwptr = Get_Pwnam(map->unix_name, False);
-               if (pwptr == NULL)
-               {
-                       DEBUG(0,("unix_name_to_nt_name_info: Get_Pwnam for user %s\
-failed. Error was %s.\n", map->unix_name, strerror(errno) ));
-                       return False;
-               }
-
-               map->unix_id = (uint32)pwptr->pw_uid;
-       }
-       else
-       {
-               struct group *gptr = getgrnam(map->unix_name);
-               if (gptr == NULL)
-               {
-                       DEBUG(0,("unix_name_to_nt_name_info: getgrnam for group %s\
-failed. Error was %s.\n", map->unix_name, strerror(errno) ));
-                       return False;
-               }
-
-               map->unix_id = (uint32)gptr->gr_gid;
-       }
-
-       DEBUG(5,("unix_name_to_nt_name_info: unix gid:%d\n", map->unix_id));
-
-       /*
-        * Now map the name to an NT SID+RID.
-        */
-
-       if (map->nt_domain != NULL && !strequal(map->nt_domain, global_sam_name))
-       {
-               /* Must add client-call lookup code here, to 
-                * resolve remote domain's sid and the group's rid,
-                * in that domain.
-                *
-                * NOTE: it is _incorrect_ to put code here that assumes
-                * we are responsible for lookups for foriegn domains' RIDs.
-                *
-                * for foriegn domains for which we are *NOT* the PDC, all
-                * we can be responsible for is the unix gid_t to which
-                * the foriegn SID+rid maps to, on this _local_ machine.  
-                * we *CANNOT* make any short-cuts or assumptions about
-                * RIDs in a foriegn domain.
-                */
-
-               if (!map_domain_name_to_sid(&map->sid, &(map->nt_domain)))
-               {
-                       DEBUG(0,("unix_name_to_nt_name_info: no known sid for %s\n",
-                                 map->nt_domain));
-                       return False;
-               }
-       }
-
-       return make_mydomain_sid(map, type);
-}
-
-static BOOL make_name_entry(name_map_entry **new_ep,
-               char *nt_domain, char *nt_group, char *unix_group,
-               DOM_MAP_TYPE type)
-{
-       /*
-        * Create the list entry and add it onto the list.
-        */
-
-       DEBUG(5,("make_name_entry:%s,%s,%s\n", nt_domain, nt_group, unix_group));
-
-       (*new_ep) = (name_map_entry *)malloc(sizeof(name_map_entry));
-       if ((*new_ep) == NULL)
-       {
-               DEBUG(0,("make_name_entry: malloc fail for name_map_entry.\n"));
-               return False;
-       } 
-
-       ZERO_STRUCTP(*new_ep);
-
-       (*new_ep)->grp.nt_name   = strdup(nt_group  );
-       (*new_ep)->grp.nt_domain = strdup(nt_domain );
-       (*new_ep)->grp.unix_name = strdup(unix_group);
-
-       if ((*new_ep)->grp.nt_name   == NULL ||
-           (*new_ep)->grp.unix_name == NULL)
-       {
-               DEBUG(0,("make_name_entry: malloc fail for names in name_map_entry.\n"));
-               delete_name_entry((*new_ep));
-               return False;
-       }
-
-       /*
-        * look up the group names, make the Group-SID and unix gid
-        */
-       if (!unix_name_to_nt_name_info(&(*new_ep)->grp, type))
-       {
-               delete_name_entry((*new_ep));
-               return False;
-       }
-
-       return True;
-}
-
-/**************************************************************************
- Load a name map file. Sets last accessed timestamp.
-***************************************************************************/
-static ubi_slList *load_name_map(DOM_MAP_TYPE type)
-{
-       static time_t groupmap_file_last_modified = (time_t)0;
-       static time_t aliasmap_file_last_modified = (time_t)0;
-       static time_t ntusrmap_file_last_modified  = (time_t)0;
-       static BOOL initialised_group = False;
-       static BOOL initialised_alias = False;
-       static BOOL initialised_ntusr  = False;
-       char *groupname_map_file = lp_groupname_map();
-       char *aliasname_map_file = lp_aliasname_map();
-       char *ntusrname_map_file = lp_ntusrname_map();
-
-       FILE *fp;
-       char *s;
-       pstring buf;
-       name_map_entry *new_ep;
-
-       time_t *file_last_modified = NULL;
-       int    *initialised = NULL;
-       char   *map_file = NULL;
-       ubi_slList *map_list = NULL;
-
-       switch (type)
-       {
-               case DOM_MAP_DOMAIN:
-               {
-                       file_last_modified = &groupmap_file_last_modified;
-                       initialised        = &initialised_group;
-                       map_file           = groupname_map_file;
-                       map_list           = &groupname_map_list;
-
-                       break;
-               }
-               case DOM_MAP_LOCAL:
-               {
-                       file_last_modified = &aliasmap_file_last_modified;
-                       initialised        = &initialised_alias;
-                       map_file           = aliasname_map_file;
-                       map_list           = &aliasname_map_list;
-
-                       break;
-               }
-               case DOM_MAP_USER:
-               {
-                       file_last_modified = &ntusrmap_file_last_modified;
-                       initialised        = &initialised_ntusr;
-                       map_file           = ntusrname_map_file;
-                       map_list           = &ntusrname_map_list;
-
-                       break;
-               }
-       }
-
-       if (!(*initialised))
-       {
-               DEBUG(10,("initialising map %s\n", map_file));
-               ubi_slInitList(map_list);
-               (*initialised) = True;
-       }
-
-       if (!*map_file)
-       {
-               return map_list;
-       }
-
-       /*
-        * Load the file.
-        */
-
-       fp = open_file_if_modified(map_file, "r", file_last_modified);
-       if (!fp)
-       {
-               return map_list;
-       }
-
-       /*
-        * Throw away any previous list.
-        */
-       delete_map_list(map_list);
-
-       DEBUG(4,("load_name_map: Scanning name map %s\n",map_file));
-
-       while ((s = fgets_slash(buf, sizeof(buf), fp)) != NULL)
-       {
-               pstring unixname;
-               pstring nt_name;
-               fstring nt_domain;
-               fstring ntname;
-               char *p;
-
-               DEBUG(10,("Read line |%s|\n", s));
-
-               memset(nt_name, 0, sizeof(nt_name));
-
-               if (!*s || strchr("#;",*s))
-                       continue;
-
-               if (!next_token(&s,unixname, "\t\n\r=", sizeof(unixname)))
-                       continue;
-
-               if (!next_token(&s,nt_name, "\t\n\r=", sizeof(nt_name)))
-                       continue;
-
-               trim_string(unixname, " ", " ");
-               trim_string(nt_name, " ", " ");
-
-               if (!*nt_name)
-                       continue;
-
-               if (!*unixname)
-                       continue;
-
-               p = strchr(nt_name, '\\');
-
-               if (p == NULL)
-               {
-                       memset(nt_domain, 0, sizeof(nt_domain));
-                       fstrcpy(ntname, nt_name);
-               }
-               else
-               {
-                       *p = 0;
-                       p++;
-                       fstrcpy(nt_domain, nt_name);
-                       fstrcpy(ntname , p);
-               }
-
-               if (make_name_entry(&new_ep, nt_domain, ntname, unixname, type))
-               {
-                       ubi_slAddTail(map_list, (ubi_slNode *)new_ep);
-                       DEBUG(5,("unixname = %s, ntname = %s\\%s type = %d\n",
-                                 new_ep->grp.unix_name,
-                                 new_ep->grp.nt_domain,
-                                 new_ep->grp.nt_name,
-                                 new_ep->grp.type));
-               }
-       }
-
-       DEBUG(10,("load_name_map: Added %ld entries to name map.\n",
-                  ubi_slCount(map_list)));
-
-       fclose(fp);
-
-       return map_list;
-}
-
-static void copy_grp_map_entry(DOM_NAME_MAP *grp, const DOM_NAME_MAP *from)
-{
-       sid_copy(&grp->sid, &from->sid);
-       grp->unix_id   = from->unix_id;
-       grp->nt_name   = from->nt_name;
-       grp->nt_domain = from->nt_domain;
-       grp->unix_name = from->unix_name;
-       grp->type      = from->type;
-}
-
-#if 0
-/***********************************************************
- Lookup unix name.
-************************************************************/
-static BOOL map_unixname(DOM_MAP_TYPE type,
-               char *unixname, DOM_NAME_MAP *grp_info)
-{
-       name_map_entry *gmep;
-       ubi_slList *map_list;
-
-       /*
-        * Initialise and load if not already loaded.
-        */
-       map_list = load_name_map(type);
-
-       for (gmep = (name_map_entry *)ubi_slFirst(map_list);
-            gmep != NULL;
-            gmep = (name_map_entry *)ubi_slNext(gmep ))
-       {
-               if (strequal(gmep->grp.unix_name, unixname))
-               {
-                       copy_grp_map_entry(grp_info, &gmep->grp);
-                       DEBUG(7,("map_unixname: Mapping unix name %s to nt group %s.\n",
-                              gmep->grp.unix_name, gmep->grp.nt_name ));
-                       return True;
-               }
-       }
-
-       return False;
-}
-
-#endif
-
-/***********************************************************
- Lookup nt name.
-************************************************************/
-static BOOL map_ntname(DOM_MAP_TYPE type, char *ntname, char *ntdomain,
-                               DOM_NAME_MAP *grp_info)
-{
-       name_map_entry *gmep;
-       ubi_slList *map_list;
-
-       /*
-        * Initialise and load if not already loaded.
-        */
-       map_list = load_name_map(type);
-
-       for (gmep = (name_map_entry *)ubi_slFirst(map_list);
-            gmep != NULL;
-            gmep = (name_map_entry *)ubi_slNext(gmep ))
-       {
-               if (strequal(gmep->grp.nt_name  , ntname) &&
-                   strequal(gmep->grp.nt_domain, ntdomain))
-               {
-                       copy_grp_map_entry(grp_info, &gmep->grp);
-                       DEBUG(7,("map_ntname: Mapping unix name %s to nt name %s.\n",
-                              gmep->grp.unix_name, gmep->grp.nt_name ));
-                       return True;
-               }
-       }
-
-       return False;
-}
-
-
-/***********************************************************
- Lookup by SID
-************************************************************/
-static BOOL map_sid(DOM_MAP_TYPE type,
-               DOM_SID *psid, DOM_NAME_MAP *grp_info)
-{
-       name_map_entry *gmep;
-       ubi_slList *map_list;
-
-       /*
-        * Initialise and load if not already loaded.
-        */
-       map_list = load_name_map(type);
-
-       for (gmep = (name_map_entry *)ubi_slFirst(map_list);
-            gmep != NULL;
-            gmep = (name_map_entry *)ubi_slNext(gmep ))
-       {
-               if (sid_equal(&gmep->grp.sid, psid))
-               {
-                       copy_grp_map_entry(grp_info, &gmep->grp);
-                       DEBUG(7,("map_sid: Mapping unix name %s to nt name %s.\n",
-                              gmep->grp.unix_name, gmep->grp.nt_name ));
-                       return True;
-               }
-       }
-
-       return False;
-}
-
-/***********************************************************
- Lookup by gid_t.
-************************************************************/
-static BOOL map_unixid(DOM_MAP_TYPE type, uint32 unix_id, DOM_NAME_MAP *grp_info)
-{
-       name_map_entry *gmep;
-       ubi_slList *map_list;
-
-       /*
-        * Initialise and load if not already loaded.
-        */
-       map_list = load_name_map(type);
-
-       for (gmep = (name_map_entry *)ubi_slFirst(map_list);
-            gmep != NULL;
-            gmep = (name_map_entry *)ubi_slNext(gmep ))
-       {
-               fstring sid_str;
-               sid_to_string(sid_str, &gmep->grp.sid);
-               DEBUG(10,("map_unixid: enum entry unix group %s %d nt %s %s\n",
-                              gmep->grp.unix_name, gmep->grp.unix_id, gmep->grp.nt_name, sid_str));
-               if (gmep->grp.unix_id == unix_id)
-               {
-                       copy_grp_map_entry(grp_info, &gmep->grp);
-                       DEBUG(7,("map_unixid: Mapping unix name %s to nt name %s type %d\n",
-                              gmep->grp.unix_name, gmep->grp.nt_name, gmep->grp.type));
-                       return True;
-               }
-       }
-
-       return False;
-}
-
-/***********************************************************
- *
- * Call four functions to resolve unix group ids and either
- * local group SIDs or domain group SIDs listed in the local group
- * or domain group map files.
- *
- * Note that it is *NOT* the responsibility of these functions to
- * resolve entries that are not in the map files.
- *
- * Any SID can be in the map files (i.e from any Domain).
- *
- ***********************************************************/
-
-#if 0
-
-/***********************************************************
- Lookup a UNIX Group entry by name.
-************************************************************/
-BOOL map_unix_group_name(char *group_name, DOM_NAME_MAP *grp_info)
-{
-       return map_unixname(DOM_MAP_DOMAIN, group_name, grp_info);
-}
-
-/***********************************************************
- Lookup a UNIX Alias entry by name.
-************************************************************/
-BOOL map_unix_alias_name(char *alias_name, DOM_NAME_MAP *grp_info)
-{
-       return map_unixname(DOM_MAP_LOCAL, alias_name, grp_info);
-}
-
-/***********************************************************
- Lookup an Alias name entry 
-************************************************************/
-BOOL map_nt_alias_name(char *ntalias_name, char *nt_domain, DOM_NAME_MAP *grp_info)
-{
-       return map_ntname(DOM_MAP_LOCAL, ntalias_name, nt_domain, grp_info);
-}
-
-/***********************************************************
- Lookup a Group entry
-************************************************************/
-BOOL map_nt_group_name(char *ntgroup_name, char *nt_domain, DOM_NAME_MAP *grp_info)
-{
-       return map_ntname(DOM_MAP_DOMAIN, ntgroup_name, nt_domain, grp_info);
-}
-
-#endif
-
-/***********************************************************
- Lookup a Username entry by name.
-************************************************************/
-static BOOL map_nt_username(char *nt_name, char *nt_domain, DOM_NAME_MAP *grp_info)
-{
-       return map_ntname(DOM_MAP_USER, nt_name, nt_domain, grp_info);
-}
-
-/***********************************************************
- Lookup a Username entry by SID.
-************************************************************/
-static BOOL map_username_sid(DOM_SID *sid, DOM_NAME_MAP *grp_info)
-{
-       return map_sid(DOM_MAP_USER, sid, grp_info);
-}
-
-/***********************************************************
- Lookup a Username SID entry by uid.
-************************************************************/
-static BOOL map_username_uid(uid_t gid, DOM_NAME_MAP *grp_info)
-{
-       return map_unixid(DOM_MAP_USER, (uint32)gid, grp_info);
-}
-
-/***********************************************************
- Lookup an Alias SID entry by name.
-************************************************************/
-BOOL map_alias_sid(DOM_SID *psid, DOM_NAME_MAP *grp_info)
-{
-       return map_sid(DOM_MAP_LOCAL, psid, grp_info);
-}
-
-/***********************************************************
- Lookup a Group entry by sid.
-************************************************************/
-BOOL map_group_sid(DOM_SID *psid, DOM_NAME_MAP *grp_info)
-{
-       return map_sid(DOM_MAP_DOMAIN, psid, grp_info);
-}
-
-/***********************************************************
- Lookup an Alias SID entry by gid_t.
-************************************************************/
-static BOOL map_alias_gid(gid_t gid, DOM_NAME_MAP *grp_info)
-{
-       return map_unixid(DOM_MAP_LOCAL, (uint32)gid, grp_info);
-}
-
-/***********************************************************
- Lookup a Group SID entry by gid_t.
-************************************************************/
-static BOOL map_group_gid( gid_t gid, DOM_NAME_MAP *grp_info)
-{
-       return map_unixid(DOM_MAP_DOMAIN, (uint32)gid, grp_info);
-}
-
-
-/************************************************************************
- Routine to look up User details by UNIX name
-*************************************************************************/
-BOOL lookupsmbpwnam(const char *unix_usr_name, DOM_NAME_MAP *grp)
-{
-       uid_t uid;
-       DEBUG(10,("lookupsmbpwnam: unix user name %s\n", unix_usr_name));
-       if (nametouid(unix_usr_name, &uid))
-       {
-               return lookupsmbpwuid(uid, grp);
-       }
-       else
-       {
-               return False;
-       }
-}
-
-/************************************************************************
- Routine to look up a remote nt name
-*************************************************************************/
-static BOOL lookup_remote_ntname(const char *ntname, DOM_SID *sid, uint8 *type)
-{
-       struct cli_state cli;
-       POLICY_HND lsa_pol;
-       fstring srv_name;
-       extern struct ntuser_creds *usr_creds;
-       struct ntuser_creds usr;
-
-       BOOL res3 = True;
-       BOOL res4 = True;
-       uint32 num_sids;
-       DOM_SID *sids;
-       uint8 *types;
-       char *names[1];
-
-       usr_creds = &usr;
-
-       ZERO_STRUCT(usr);
-       pwd_set_nullpwd(&usr.pwd);
-
-       DEBUG(5,("lookup_remote_ntname: %s\n", ntname));
-
-       if (!cli_connect_serverlist(&cli, lp_passwordserver()))
-       {
-               return False;
-       }
-
-       names[0] = ntname;
-
-       fstrcpy(srv_name, "\\\\");
-       fstrcat(srv_name, cli.desthost);
-       strupper(srv_name);
-
-       /* lookup domain controller; receive a policy handle */
-       res3 = res3 ? lsa_open_policy( srv_name,
-                               &lsa_pol, True) : False;
-
-       /* send lsa lookup sids call */
-       res4 = res3 ? lsa_lookup_names( &lsa_pol,
-                                      1, names, 
-                                      &sids, &types, &num_sids) : False;
-
-       res3 = res3 ? lsa_close(&lsa_pol) : False;
-
-       if (res4 && res3 && sids != NULL && types != NULL)
-       {
-               sid_copy(sid, &sids[0]);
-               *type = types[0];
-       }
-       else
-       {
-               res3 = False;
-       }
-       if (types != NULL)
-       {
-               free(types);
-       }
-       
-       if (sids != NULL)
-       {
-               free(sids);
-       }
-       
-       return res3 && res4;
-}
-
-/************************************************************************
- Routine to look up a remote nt name
-*************************************************************************/
-static BOOL get_sid_and_type(const char *fullntname, uint8 expected_type,
-                               DOM_NAME_MAP *gmep)
-{
-       /*
-        * check with the PDC to see if it owns the name.  if so,
-        * the SID is resolved with the PDC database.
-        */
-
-       if (lp_server_role() == ROLE_DOMAIN_MEMBER)
-       {
-               if (lookup_remote_ntname(fullntname, &gmep->sid, &gmep->type))
-               {
-                       if (sid_front_equal(&gmep->sid, &global_member_sid) &&
-                           strequal(gmep->nt_domain, global_myworkgroup) &&
-                           gmep->type == expected_type)
-                       {
-                               return True;
-                       }
-                       return False;
-               }
-       }
-
-       /*
-        * ... otherwise, it's one of ours.  map the sid ourselves,
-        * which can only happen in our own SAM database.
-        */
-
-       if (!strequal(gmep->nt_domain, global_sam_name))
-       {
-               return False;
-       }
-       if (!pwdb_unixid_to_sam_sid(gmep->unix_id, gmep->type, &gmep->sid))
-       {
-               return False;
-       }
-
-       return True;
-}
-
-/*
- * used by lookup functions below
- */
-
-static fstring nt_name;
-static fstring unix_name;
-static fstring nt_domain;
-
-/*************************************************************************
- looks up a uid, returns User Information.  
-*************************************************************************/
-BOOL lookupsmbpwuid(uid_t uid, DOM_NAME_MAP *gmep)
-{
-       DEBUG(10,("lookupsmbpwuid: unix uid %d\n", uid));
-       if (map_username_uid(uid, gmep))
-       {
-               return True;
-       }
-#if 0
-       if (lp_server_role() != ROLE_DOMAIN_NONE)
-#endif
-       {
-               gmep->nt_name   = nt_name;
-               gmep->unix_name = unix_name;
-               gmep->nt_domain = nt_domain;
-
-               gmep->unix_id = (uint32)uid;
-
-               /*
-                * ok, assume it's one of ours.  then double-check it
-                * if we are a member of a domain
-                */
-
-               gmep->type = SID_NAME_USER;
-               fstrcpy(gmep->nt_name, uidtoname(uid));
-               fstrcpy(gmep->unix_name, gmep->nt_name);
-
-               /*
-                * here we should do a LsaLookupNames() call
-                * to check the status of the name with the PDC.
-                * if the PDC know nothing of the name, it's ours.
-                */
-
-               if (lp_server_role() == ROLE_DOMAIN_MEMBER)
-               {
-#if 0
-                       lsa_lookup_names(global_myworkgroup, gmep->nt_name, &gmep->sid...);
-#endif
-               }
-
-               /*
-                * ok, it's one of ours.
-                */
-
-               gmep->nt_domain = global_sam_name;
-               pwdb_unixid_to_sam_sid(gmep->unix_id, gmep->type, &gmep->sid);
-
-               return True;
-       }
-
-       /* oops. */
-
-       return False;
-}
-
-/*************************************************************************
- looks up by NT name, returns User Information.  
-*************************************************************************/
-BOOL lookupsmbpwntnam(const char *fullntname, DOM_NAME_MAP *gmep)
-{
-       DEBUG(10,("lookupsmbpwntnam: nt user name %s\n", fullntname));
-
-       if (!split_domain_name(fullntname, nt_domain, nt_name))
-       {
-               return False;
-       }
-
-       if (map_nt_username(nt_name, nt_domain, gmep))
-       {
-               return True;
-       }
-       if (lp_server_role() != ROLE_DOMAIN_NONE)
-       {
-               uid_t uid;
-               gmep->nt_name   = nt_name;
-               gmep->unix_name = unix_name;
-               gmep->nt_domain = nt_domain;
-
-               /*
-                * ok, it's one of ours.  we therefore "create" an nt user named
-                * after the unix user.  this is the point where "appliance mode"
-                * should get its teeth in, as unix users won't really exist,
-                * they will only be numbers...
-                */
-
-               gmep->type = SID_NAME_USER;
-               fstrcpy(gmep->unix_name, gmep->nt_name);
-               if (!nametouid(gmep->unix_name, &uid))
-               {
-                       return False;
-               }
-               gmep->unix_id = (uint32)uid;
-
-               return get_sid_and_type(fullntname, gmep->type, gmep);
-       }
-
-       /* oops. */
-
-       return False;
-}
-
-/*************************************************************************
- looks up by RID, returns User Information.  
-*************************************************************************/
-BOOL lookupsmbpwsid(DOM_SID *sid, DOM_NAME_MAP *gmep)
-{
-       fstring sid_str;
-       sid_to_string(sid_str, sid);
-       DEBUG(10,("lookupsmbpwsid: nt sid %s\n", sid_str));
-
-       if (map_username_sid(sid, gmep))
-       {
-               return True;
-       }
-       if (lp_server_role() != ROLE_DOMAIN_NONE)
-       {
-               gmep->nt_name   = nt_name;
-               gmep->unix_name = unix_name;
-               gmep->nt_domain = nt_domain;
-
-               /*
-                * here we should do a LsaLookupNames() call
-                * to check the status of the name with the PDC.
-                * if the PDC know nothing of the name, it's ours.
-                */
-
-               if (lp_server_role() == ROLE_DOMAIN_MEMBER)
-               {
-#if 0
-                       if (lookup_remote_sid(global_myworkgroup, gmep->sid, gmep->nt_name, gmep->nt_domain...);
-#endif
-               }
-
-               /*
-                * ok, it's one of ours.  we therefore "create" an nt user named
-                * after the unix user.  this is the point where "appliance mode"
-                * should get its teeth in, as unix users won't really exist,
-                * they will only be numbers...
-                */
-
-               gmep->type = SID_NAME_USER;
-               sid_copy(&gmep->sid, sid);
-               if (!pwdb_sam_sid_to_unixid(&gmep->sid, gmep->type, &gmep->unix_id))
-               {
-                       return False;
-               }
-               fstrcpy(gmep->nt_name, uidtoname((uid_t)gmep->unix_id));
-               fstrcpy(gmep->unix_name, gmep->nt_name);
-               gmep->nt_domain = global_sam_name;
-
-               return True;
-       }
-
-       /* oops. */
-
-       return False;
-}
-
-/************************************************************************
- Routine to look up group / alias / well-known group RID by UNIX name
-*************************************************************************/
-BOOL lookupsmbgrpnam(const char *unix_grp_name, DOM_NAME_MAP *grp)
-{
-       gid_t gid;
-       DEBUG(10,("lookupsmbgrpnam: unix user group %s\n", unix_grp_name));
-       if (nametogid(unix_grp_name, &gid))
-       {
-               return lookupsmbgrpgid(gid, grp);
-       }
-       else
-       {
-               return False;
-       }
-}
-
-/*************************************************************************
- looks up a SID, returns name map entry
-*************************************************************************/
-BOOL lookupsmbgrpsid(DOM_SID *sid, DOM_NAME_MAP *gmep)
-{
-       fstring sid_str;
-       sid_to_string(sid_str, sid);
-       DEBUG(10,("lookupsmbgrpsid: nt sid %s\n", sid_str));
-
-       if (map_alias_sid(sid, gmep))
-       {
-               return True;
-       }
-       if (map_group_sid(sid, gmep))
-       {
-               return True;
-       }
-       if (lp_server_role() != ROLE_DOMAIN_NONE)
-       {
-               gmep->nt_name   = nt_name;
-               gmep->unix_name = unix_name;
-               gmep->nt_domain = nt_domain;
-
-               /*
-                * here we should do a LsaLookupNames() call
-                * to check the status of the name with the PDC.
-                * if the PDC know nothing of the name, it's ours.
-                */
-
-               if (lp_server_role() == ROLE_DOMAIN_MEMBER)
-               {
-#if 0
-                       lsa_lookup_sids(global_myworkgroup, gmep->sid, gmep->nt_name, gmep->nt_domain...);
-#endif
-               }
-
-               /*
-                * ok, it's one of ours.  we therefore "create" an nt group or
-                * alias name named after the unix group.  this is the point
-                * where "appliance mode" should get its teeth in, as unix
-                * groups won't really exist, they will only be numbers...
-                */
-
-               /* name is not explicitly mapped
-                * with map files or the PDC
-                * so we are responsible for it...
-                */
-
-               if (lp_server_role() == ROLE_DOMAIN_MEMBER)
-               {
-                       /* ... as a LOCAL group. */
-                       gmep->type = SID_NAME_ALIAS;
-               }
-               else
-               {
-                       /* ... as a DOMAIN group. */
-                       gmep->type = SID_NAME_DOM_GRP;
-               }
-
-               sid_copy(&gmep->sid, sid);
-               if (!pwdb_sam_sid_to_unixid(&gmep->sid, gmep->type, &gmep->unix_id))
-               {
-                       return False;
-               }
-               fstrcpy(gmep->nt_name, gidtoname((gid_t)gmep->unix_id));
-               fstrcpy(gmep->unix_name, gmep->nt_name);
-               gmep->nt_domain = global_sam_name;
-
-               return True;
-       }
-
-       /* oops */
-       return False;
-}
-
-/*************************************************************************
- looks up a gid, returns RID and type local, domain or well-known domain group
-*************************************************************************/
-BOOL lookupsmbgrpgid(gid_t gid, DOM_NAME_MAP *gmep)
-{
-       DEBUG(10,("lookupsmbgrpgid: unix gid %d\n", (int)gid));
-       if (map_alias_gid(gid, gmep))
-       {
-               return True;
-       }
-       if (map_group_gid(gid, gmep))
-       {
-               return True;
-       }
-       if (lp_server_role() != ROLE_DOMAIN_NONE)
-       {
-               gmep->nt_name   = nt_name;
-               gmep->unix_name = unix_name;
-               gmep->nt_domain = nt_domain;
-
-               gmep->unix_id = (uint32)gid;
-
-               /*
-                * here we should do a LsaLookupNames() call
-                * to check the status of the name with the PDC.
-                * if the PDC know nothing of the name, it's ours.
-                */
-
-               if (lp_server_role() == ROLE_DOMAIN_MEMBER)
-               {
-#if 0
-                       if (lsa_lookup_names(global_myworkgroup, gmep->nt_name, &gmep->sid...);
-                       {
-                               return True;
-                       }
-#endif
-               }
-
-               /*
-                * ok, it's one of ours.  we therefore "create" an nt group or
-                * alias name named after the unix group.  this is the point
-                * where "appliance mode" should get its teeth in, as unix
-                * groups won't really exist, they will only be numbers...
-                */
-
-               /* name is not explicitly mapped
-                * with map files or the PDC
-                * so we are responsible for it...
-                */
-
-               if (lp_server_role() == ROLE_DOMAIN_MEMBER)
-               {
-                       /* ... as a LOCAL group. */
-                       gmep->type = SID_NAME_ALIAS;
-               }
-               else
-               {
-                       /* ... as a DOMAIN group. */
-                       gmep->type = SID_NAME_DOM_GRP;
-               }
-               fstrcpy(gmep->nt_name, gidtoname(gid));
-               fstrcpy(gmep->unix_name, gmep->nt_name);
-
-               return get_sid_and_type(gmep->nt_name, gmep->type, gmep);
-       }
-
-       /* oops */
-       return False;
-}
-
index 17aefe115904e6fe63bef3ee31a9a45e70e951d9..7eecbfd2cd118cdc9ac89448df86ab61c8b185e2 100644 (file)
@@ -514,116 +514,121 @@ BOOL local_lookup_sid(DOM_SID *sid, char *name, enum SID_NAME_USE *psid_name_use
        uint32 rid;
        BOOL is_user;
        SAM_ACCOUNT *sam_account = NULL;
-       uid_t uid;
-       struct passwd *pass;
-       GROUP_MAP map;
-       
+       BOOL found = False;
 
        sid_peek_rid(sid, &rid);
+       is_user = pdb_rid_is_user(rid);
        *psid_name_use = SID_NAME_UNKNOWN;
-       
-       DEBUG(5,("local_lookup_sid: looking up RID %u.\n", (unsigned int)rid));
-       
-       if (rid == DOMAIN_USER_RID_ADMIN) {
-               char **admin_list = lp_admin_users(-1);
-               *psid_name_use = SID_NAME_USER;
-               if (admin_list) {
-                       char *p = *admin_list;
-                       if(!next_token(&p, name, NULL, sizeof(fstring)))
+
+       DEBUG(5,("local_lookup_sid: looking up %s RID %u.\n", is_user ? "user" :
+                       "group", (unsigned int)rid));
+
+       if(is_user) {
+               if(rid == DOMAIN_USER_RID_ADMIN) {
+                       char **admin_list = lp_admin_users(-1);
+                       *psid_name_use = SID_NAME_USER;
+                       if (admin_list) {
+                               char *p = *admin_list;
+                               if(!next_token(&p, name, NULL, sizeof(fstring)))
+                                       fstrcpy(name, "Administrator");
+                       } else {
                                fstrcpy(name, "Administrator");
+                       }
+               } else if (rid == DOMAIN_USER_RID_GUEST) {
+                       char *p = lp_guestaccount();
+                       *psid_name_use = SID_NAME_USER;
+                       if(!next_token(&p, name, NULL, sizeof(fstring)))
+                               fstrcpy(name, "Guest");
                } else {
-                       fstrcpy(name, "Administrator");
-               }
-               return True;
-
-       } else if (rid == DOMAIN_USER_RID_GUEST) {
-               char *p = lp_guestaccount();
-               *psid_name_use = SID_NAME_USER;
-               if(!next_token(&p, name, NULL, sizeof(fstring)))
-                       fstrcpy(name, "Guest");
-               return True;
-
-       }
-
-       /*
-        * Don't try to convert the rid to a name if 
-        * running in appliance mode
-        */
-
-       if (lp_hide_local_users())
-               return False;
-               
-       if (!NT_STATUS_IS_OK(pdb_init_sam(&sam_account))) {
-               return False;
-       }
-               
-       if (pdb_getsampwrid(sam_account, rid)) {
-               fstrcpy(name, pdb_get_username(sam_account));
-               *psid_name_use = SID_NAME_USER;
-
-               pdb_free_sam(&sam_account);
+                       uid_t uid;
+                       struct passwd *pass;
                        
-               return True;
-       }
-               
-       pdb_free_sam(&sam_account);
-               
-       if (get_group_map_from_sid(*sid, &map, MAPPING_WITHOUT_PRIV)) {
-               if (map.gid!=-1) {
-                       DEBUG(5,("local_lookup_sid: mapped group %s to gid %u\n", map.nt_name, (unsigned int)map.gid));
-                       fstrcpy(name, map.nt_name);
-                       *psid_name_use = map.sid_name_use;
-                       return True;
-               }
-       }
-               
-       is_user = pdb_rid_is_user(rid);
-
-       DEBUG(5, ("assuming RID %u is a %s\n", (unsigned)rid, is_user ? "user" : "group"));
+                       /*
+                        * Don't try to convert the rid to a name if 
+                        * running in appliance mode
+                        */
+                       if (lp_hide_local_users())
+                               return False;
 
-       if (pdb_rid_is_user(rid)) {
-               uid = fallback_pdb_user_rid_to_uid(rid);
-               pass = getpwuid_alloc(uid);
+                       if (!NT_STATUS_IS_OK(pdb_init_sam(&sam_account))) {
+                               return False;
+                       }
                        
-               *psid_name_use = SID_NAME_USER;
+                       if (pdb_getsampwrid(sam_account, rid)) {
+                               fstrcpy(name, pdb_get_username(sam_account));
+                               *psid_name_use = SID_NAME_USER;
+                               found = True;
+                       }
                        
-               DEBUG(5,("local_lookup_sid: looking up uid %u %s\n", (unsigned int)uid,
-                        pass ? "succeeded" : "failed" ));
+                       pdb_free_sam(&sam_account);
                        
-               if(!pass) {
-                       slprintf(name, sizeof(fstring)-1, "unix_user.%u", (unsigned int)uid);
-                       return True;
-               }
+                       if (found) {
+                               return True;
+                       }
                        
-               fstrcpy(name, pass->pw_name);
+                       uid = fallback_pdb_user_rid_to_uid(rid);
+                       pass = getpwuid_alloc(uid);
                        
-               DEBUG(5,("local_lookup_sid: found user %s for rid %u\n", name,
-                        (unsigned int)rid ));
+                       *psid_name_use = SID_NAME_USER;
                        
-               passwd_free(&pass);
+                       DEBUG(5,("local_lookup_sid: looking up uid %u %s\n", (unsigned int)uid,
+                                pass ? "succeeded" : "failed" ));
+                       
+                       if(!pass) {
+                               slprintf(name, sizeof(fstring)-1, "unix_user.%u", (unsigned int)uid);
+                               return True;
+                       }
+                       
+                       fstrcpy(name, pass->pw_name);
+                       
+                       DEBUG(5,("local_lookup_sid: found user %s for rid %u\n", name,
+                                (unsigned int)rid ));
                        
+                       passwd_free(&pass);
+               }
+               
        } else {
                gid_t gid;
                struct group *gr; 
-                       
+               GROUP_MAP map;
+               
+               /* 
+                * Don't try to convert the rid to a name if running
+                * in appliance mode
+                */
+               
+               if (lp_hide_local_users()) 
+                       return False;
+
+               /* check if it's a mapped group */
+               if (get_group_map_from_sid(*sid, &map, MAPPING_WITHOUT_PRIV)) {
+                       if (map.gid!=-1) {
+                               DEBUG(5,("local_lookup_sid: mapped group %s to gid %u\n", map.nt_name, (unsigned int)map.gid));
+                               fstrcpy(name, map.nt_name);
+                               *psid_name_use = map.sid_name_use;
+                               return True;
+                       }
+               }
+               
                gid = pdb_group_rid_to_gid(rid);
                gr = getgrgid(gid);
-                       
+
                *psid_name_use = SID_NAME_ALIAS;
-                       
+
                DEBUG(5,("local_lookup_sid: looking up gid %u %s\n", (unsigned int)gid,
-                        gr ? "succeeded" : "failed" ));
-                       
+                       gr ? "succeeded" : "failed" ));
+
                if(!gr) {
                        slprintf(name, sizeof(fstring)-1, "unix_group.%u", (unsigned int)gid);
                        return False;
                }
-                       
+
                fstrcpy( name, gr->gr_name);
-                       
+
                DEBUG(5,("local_lookup_sid: found group %s for rid %u\n", name,
-                        (unsigned int)rid ));
+                       (unsigned int)rid ));
        }
+
        return True;
 }
 
@@ -638,6 +643,7 @@ BOOL local_lookup_name(const char *c_user, DOM_SID *psid, enum SID_NAME_USE *psi
        DOM_SID local_sid;
        fstring user;
        SAM_ACCOUNT *sam_account = NULL;
+       BOOL found = False;
        
        *psid_name_use = SID_NAME_UNKNOWN;
 
@@ -678,23 +684,25 @@ BOOL local_lookup_name(const char *c_user, DOM_SID *psid, enum SID_NAME_USE *psi
                *psid_name_use = SID_NAME_USER;
                
                sid_copy( psid, &local_sid);
-               pdb_free_sam(&sam_account);
-               return True;
+               found = True;
        }
 
        pdb_free_sam(&sam_account);
 
-       if ((pass = Get_Pwnam(user))) {
+       if (!found && (pass = Get_Pwnam(user))) {
                sid_append_rid( &local_sid, fallback_pdb_uid_to_user_rid(pass->pw_uid));
                *psid_name_use = SID_NAME_USER;
+               pdb_free_sam(&sam_account);
 
-       } else {
+       } else if (!found) {
                /*
                 * Maybe it was a group ?
                 */
                struct group *grp;
                GROUP_MAP map;
                
+               pdb_free_sam(&sam_account);
+
                /* check if it's a mapped group */
                if (get_group_map_from_ntname(user, &map, MAPPING_WITHOUT_PRIV)) {
                        if (map.gid!=-1) {
@@ -746,37 +754,28 @@ DOM_SID *local_uid_to_sid(DOM_SID *psid, uid_t uid)
        extern DOM_SID global_sam_sid;
        struct passwd *pass;
        SAM_ACCOUNT *sam_user = NULL;
-       fstring str; /* sid string buffer */
 
        sid_copy(psid, &global_sam_sid);
 
-       if((pass = getpwuid_alloc(uid))) {
-
-               if (NT_STATUS_IS_ERR(pdb_init_sam(&sam_user))) {
-                       passwd_free(&pass);
-                       return NULL;
-               }
-               
-               if (pdb_getsampwnam(sam_user, pass->pw_name)) {
-                       sid_append_rid(psid, pdb_get_user_rid(sam_user));
-               } else {
-                       sid_append_rid(psid, fallback_pdb_uid_to_user_rid(uid));
-               }
-
-               DEBUG(10,("local_uid_to_sid: uid %u -> SID (%s) (%s).\n", 
-                         (unsigned)uid, sid_to_string( str, psid),
-                         pass->pw_name ));
+       if(!(pass = getpwuid_alloc(uid)))
+               return NULL;
 
+       if (NT_STATUS_IS_ERR(pdb_init_sam(&sam_user))) {
                passwd_free(&pass);
-               pdb_free_sam(&sam_user);
+               return NULL;
+       }
        
-       } else {
-               sid_append_rid(psid, fallback_pdb_uid_to_user_rid(uid));
-
-               DEBUG(10,("local_uid_to_sid: uid %u -> SID (%s) (unknown user).\n", 
-                         (unsigned)uid, sid_to_string( str, psid)));
+       if (!pdb_getsampwnam(sam_user, pass->pw_name)) {
+               pdb_free_sam(&sam_user);
+               return NULL;
        }
 
+       passwd_free(&pass);
+
+       sid_append_rid(psid, pdb_get_user_rid(sam_user));
+
+       pdb_free_sam(&sam_user);
+
        return psid;
 }
 
@@ -791,6 +790,7 @@ BOOL local_sid_to_uid(uid_t *puid, DOM_SID *psid, enum SID_NAME_USE *name_type)
        DOM_SID dom_sid;
        uint32 rid;
        fstring str;
+       struct passwd *pass;
        SAM_ACCOUNT *sam_user = NULL;
 
        *name_type = SID_NAME_UNKNOWN;
@@ -798,6 +798,9 @@ BOOL local_sid_to_uid(uid_t *puid, DOM_SID *psid, enum SID_NAME_USE *name_type)
        sid_copy(&dom_sid, psid);
        sid_split_rid(&dom_sid, &rid);
 
+       if (!pdb_rid_is_user(rid))
+               return False;
+
        /*
         * We can only convert to a uid if this is our local
         * Domain SID (ie. we are the controling authority).
@@ -808,26 +811,28 @@ BOOL local_sid_to_uid(uid_t *puid, DOM_SID *psid, enum SID_NAME_USE *name_type)
        if (NT_STATUS_IS_ERR(pdb_init_sam(&sam_user)))
                return False;
        
-       if (pdb_getsampwrid(sam_user, rid)) {
-               *puid = pdb_get_uid(sam_user);
-               if (*puid == -1) {
-                       pdb_free_sam(&sam_user);
-                       return False;
-               }
-               DEBUG(10,("local_sid_to_uid: SID %s -> uid (%u) (%s).\n", sid_to_string( str, psid),
-                         (unsigned int)*puid, pdb_get_username(sam_user)));
-       } else {
-               if (pdb_rid_is_user(rid)) {
-                       *puid = fallback_pdb_user_rid_to_uid(rid);
-                       DEBUG(10,("local_sid_to_uid: SID %s -> uid (%u) (non-passdb user).\n", sid_to_string( str, psid),
-                                 (unsigned int)*puid));
-               } else {
-                       pdb_free_sam(&sam_user);
-                       return False;                   
-               }
+       if (!pdb_getsampwrid(sam_user, rid)) {
+               pdb_free_sam(&sam_user);
+               return False;
        }
+       
+       *puid = pdb_get_uid(sam_user);
+       if (*puid == -1)
+               return False;
+
        pdb_free_sam(&sam_user);
 
+       /*
+        * Ensure this uid really does exist.
+        */
+       if(!(pass = getpwuid_alloc(*puid)))
+               return False;
+
+       DEBUG(10,("local_sid_to_uid: SID %s -> uid (%u) (%s).\n", sid_to_string( str, psid),
+               (unsigned int)*puid, pass->pw_name ));
+
+       passwd_free(&pass);
+
        *name_type = SID_NAME_USER;
 
        return True;
@@ -882,6 +887,9 @@ BOOL local_sid_to_gid(gid_t *pgid, DOM_SID *psid, enum SID_NAME_USE *name_type)
        if (!sid_equal(&global_sam_sid, &dom_sid))
                return False;
 
+       if (pdb_rid_is_user(rid))
+               return False;
+
        if (get_group_map_from_sid(*psid, &map, MAPPING_WITHOUT_PRIV)) {
                
                /* the SID is in the mapping table but not mapped */
@@ -889,12 +897,9 @@ BOOL local_sid_to_gid(gid_t *pgid, DOM_SID *psid, enum SID_NAME_USE *name_type)
                        return False;
 
                sid_peek_rid(&map.sid, &rid);
-               *pgid = map.gid;
+               *pgid = rid;
                *name_type = map.sid_name_use;
        } else {
-               if (pdb_rid_is_user(rid))
-                       return False;
-
                *pgid = pdb_group_rid_to_gid(rid);
                *name_type = SID_NAME_ALIAS;
        }
diff --git a/source3/python/.cvsignore b/source3/python/.cvsignore
deleted file mode 100644 (file)
index 659ddbf..0000000
+++ /dev/null
@@ -1 +0,0 @@
-setup.py
diff --git a/source3/python/py_common.c b/source3/python/py_common.c
deleted file mode 100644 (file)
index bc3153c..0000000
+++ /dev/null
@@ -1,117 +0,0 @@
-/* 
-   Python wrappers for DCERPC/SMB client routines.
-
-   Copyright (C) Tim Potter, 2002
-   
-   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 02139, USA.
-*/
-
-#include "includes.h"
-#include "Python.h"
-
-/* Return a tuple of (error code, error string) from a WERROR */
-
-PyObject *py_werror_tuple(WERROR werror)
-{
-       return Py_BuildValue("is", W_ERROR_V(werror), 
-                            dos_errstr(werror));
-}
-
-/* Return a tuple of (error code, error string) from a WERROR */
-
-PyObject *py_ntstatus_tuple(NTSTATUS ntstatus)
-{
-       return Py_BuildValue("is", NT_STATUS_V(ntstatus), 
-                            nt_errstr(ntstatus));
-}
-
-/* Initialise samba client routines */
-
-static BOOL initialised;
-
-void py_samba_init(void)
-{
-       if (initialised)
-               return;
-
-       /* Load configuration file */
-
-       if (!lp_load(dyn_CONFIGFILE, True, False, False))
-               fprintf(stderr, "Can't load %s\n", dyn_CONFIGFILE);
-
-       /* Misc other stuff */
-
-       load_interfaces();
-       
-       initialised = True;
-}
-
-/* Debuglevel routines */
-
-PyObject *get_debuglevel(PyObject *self, PyObject *args)
-{
-       PyObject *debuglevel;
-
-       if (!PyArg_ParseTuple(args, ""))
-               return NULL;
-
-       debuglevel = PyInt_FromLong(DEBUGLEVEL);
-
-       return debuglevel;
-}
-
-PyObject *set_debuglevel(PyObject *self, PyObject *args)
-{
-       int debuglevel;
-
-       if (!PyArg_ParseTuple(args, "i", &debuglevel))
-               return NULL;
-
-       DEBUGLEVEL = debuglevel;
-
-       Py_INCREF(Py_None);
-       return Py_None;
-}
-
-/* Initialise logging */
-
-PyObject *py_setup_logging(PyObject *self, PyObject *args, PyObject *kw)
-{
-       BOOL interactive = False;
-       char *logfilename = NULL;
-       static char *kwlist[] = {"interactive", "logfilename", NULL};
-
-       if (!PyArg_ParseTupleAndKeywords(args, kw, "|is", kwlist,
-                                        &interactive, &logfilename))
-               return NULL;
-       
-       if (interactive && logfilename) {
-               PyErr_SetString(PyExc_RuntimeError,
-                               "can't be interactive and set log file name");
-               return NULL;
-       }
-
-       if (interactive)
-               setup_logging("spoolss", True);
-
-       if (logfilename) {
-               lp_set_logfile(logfilename);
-               setup_logging(logfilename, False);
-               reopen_logs();
-       }
-
-       Py_INCREF(Py_None);
-       return Py_None;
-}
diff --git a/source3/python/py_common.h b/source3/python/py_common.h
deleted file mode 100644 (file)
index 4a5c92c..0000000
+++ /dev/null
@@ -1,34 +0,0 @@
-/* 
-   Python wrappers for DCERPC/SMB client routines.
-
-   Copyright (C) Tim Potter, 2002
-   
-   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 02139, USA.
-*/
-
-#ifndef _PY_COMMON_H
-#define _PY_COMMON_H
-
-/* Function prototypes */
-
-void py_samba_init(void);
-PyObject *py_werror_tuple(WERROR werror);
-PyObject *py_ntstatus_tuple(NTSTATUS ntstatus);
-
-PyObject *py_setup_logging(PyObject *self, PyObject *args);
-PyObject *get_debuglevel(PyObject *self, PyObject *args);
-PyObject *set_debuglevel(PyObject *self, PyObject *args);
-
-#endif /* _PY_COMMON_H */
diff --git a/source3/python/py_conv.c b/source3/python/py_conv.c
deleted file mode 100644 (file)
index 8806889..0000000
+++ /dev/null
@@ -1,126 +0,0 @@
-/* 
-   Python wrappers for DCERPC/SMB client routines.
-
-   Copyright (C) Tim Potter, 2002
-   
-   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 02139, USA.
-*/
-
-#include "includes.h"
-#include "Python.h"
-#include "py_conv.h"
-
-/* Helper for rpcstr_pull() function */
-
-static void fstr_pull(fstring str, UNISTR *uni)
-{
-       rpcstr_pull(str, uni->buffer, sizeof(fstring), 0, STR_TERMINATE);
-}
-
-/* Convert a structure to a Python dict */
-
-PyObject *from_struct(void *s, struct pyconv *conv)
-{
-       PyObject *obj, *item;
-       int i;
-
-       obj = PyDict_New();
-
-       for (i = 0; conv[i].name; i++) {
-               switch (conv[i].type) {
-               case PY_UNISTR: {
-                       UNISTR *u = (UNISTR *)((char *)s + conv[i].offset);
-                       fstring s = "";
-
-                       if (u->buffer)
-                               fstr_pull(s, u);
-
-                       item = PyString_FromString(s);
-                       PyDict_SetItemString(obj, conv[i].name, item);
-
-                       break;
-               }
-               case PY_UINT32: {
-                       uint32 *u = (uint32 *)((char *)s + conv[i].offset);
-
-                       item = PyInt_FromLong(*u);
-                       PyDict_SetItemString(obj, conv[i].name, item);
-                       
-                       break;
-               }
-               case PY_UINT16: {
-                       uint16 *u = (uint16 *)((char *)s + conv[i].offset);
-
-                       item = PyInt_FromLong(*u);
-                       PyDict_SetItemString(obj, conv[i].name, item);
-
-                       break;
-               }
-               default:
-                       break;
-               }
-       }
-
-       return obj;
-}
-
-/* Convert a Python dict to a structure */
-
-void to_struct(void *s, PyObject *dict, struct pyconv *conv)
-{
-       int i;
-
-       for (i = 0; conv[i].name; i++) {
-               PyObject *obj;
-               
-               obj = PyDict_GetItemString(dict, conv[i].name);
-               
-               switch (conv[i].type) {
-               case PY_UNISTR: {
-                       UNISTR *u = (UNISTR *)((char *)s + conv[i].offset);
-                       char *s = "";
-
-                       if (obj && PyString_Check(obj))
-                               s = PyString_AsString(obj);
-
-                       init_unistr(u, s);
-                       
-                       break;
-               }
-               case PY_UINT32: {
-                       uint32 *u = (uint32 *)((char *)s + conv[i].offset);
-
-                       if (obj && PyInt_Check(obj)) 
-                               *u = PyInt_AsLong(obj);
-                       else
-                               *u = 0;
-
-                       break;
-               }
-               case PY_UINT16: {
-                       uint16 *u = (uint16 *)((char *)s + conv[i].offset);
-
-                       if (obj && PyInt_Check(obj)) 
-                               *u = PyInt_AsLong(obj);
-                       else
-                               *u = 0;
-
-                       break;
-               }
-               default:
-                       break;
-               }
-       }
-}
diff --git a/source3/python/py_conv.h b/source3/python/py_conv.h
deleted file mode 100644 (file)
index 0de2d67..0000000
+++ /dev/null
@@ -1,40 +0,0 @@
-/* 
-   Python wrappers for DCERPC/SMB client routines.
-
-   Copyright (C) Tim Potter, 2002
-   
-   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 02139, USA.
-*/
-
-#ifndef _PY_CONV_H
-#define _PY_CONV_H
-
-enum pyconv_types { PY_UNISTR, PY_UINT32, PY_UINT16 };
-
-struct pyconv {
-       char *name;             /* Name of member */
-       enum pyconv_types type; /* Type */
-       size_t offset;          /* Offset into structure */
-};
-
-PyObject *from_struct(void *s, struct pyconv *conv);
-void to_struct(void *s, PyObject *dict, struct pyconv *conv);
-
-/* Another version of offsetof (-: */
-
-#undef offsetof
-#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
-
-#endif /* _PY_CONV_H */
diff --git a/source3/python/py_lsa.c b/source3/python/py_lsa.c
deleted file mode 100644 (file)
index dfb9b64..0000000
+++ /dev/null
@@ -1,141 +0,0 @@
-#include "includes.h"
-#include "Python.h"
-#include "python/py_common.h"
-
-static void py_policy_hnd_dealloc(PyObject* self)
-{
-       PyObject_Del(self);
-}
-
-typedef struct {
-       PyObject_HEAD
-       struct cli_state *cli;
-       TALLOC_CTX *mem_ctx;
-       POLICY_HND pol;
-} lsa_policy_hnd_object;
-
-PyTypeObject lsa_policy_hnd_type = {
-       PyObject_HEAD_INIT(NULL)
-       0,
-       "LSA Policy Handle",
-       sizeof(lsa_policy_hnd_object),
-       0,
-       py_policy_hnd_dealloc, /*tp_dealloc*/
-       0,          /*tp_print*/
-       0,          /*tp_getattr*/
-       0,          /*tp_setattr*/
-       0,          /*tp_compare*/
-       0,          /*tp_repr*/
-       0,          /*tp_as_number*/
-       0,          /*tp_as_sequence*/
-       0,          /*tp_as_mapping*/
-       0,          /*tp_hash */
-};
-
-/* 
- * Exceptions raised by this module 
- */
-
-PyObject *lsa_error;           /* This indicates a non-RPC related error
-                                  such as name lookup failure */
-
-PyObject *lsa_ntstatus;                /* This exception is raised when a RPC call
-                                  returns a status code other than
-                                  NT_STATUS_OK */
-
-/*
- * Open/close lsa handles
- */
-
-static PyObject *lsa_openpolicy(PyObject *self, PyObject *args, 
-                               PyObject *kw) 
-{
-       static char *kwlist[] = { "servername", "creds", "access", NULL };
-       char *server_name;
-       PyObject *creds = NULL;
-       uint32 desired_access = MAXIMUM_ALLOWED_ACCESS;
-
-       if (!PyArg_ParseTupleAndKeywords(
-               args, kw, "s|O!i", kwlist, &server_name, &PyDict_Type,
-               &creds, &desired_access)) {
-
-               goto done;
-       }
-
- done:
-       return NULL;
-}
-
-static PyObject *lsa_close(PyObject *self, PyObject *args, PyObject *kw) 
-{
-       return NULL;
-}
-
-static PyObject *lsa_lookupnames(PyObject *self, PyObject *args, 
-                                PyObject *kw) 
-{
-       return NULL;
-}
-
-static PyObject *lsa_lookupsids(PyObject *self, PyObject *args, 
-                               PyObject *kw) 
-{
-       return NULL;
-}
-
-/*
- * Method dispatch table
- */
-
-static PyMethodDef lsa_methods[] = {
-
-       /* Open/close lsa handles */
-       
-       { "openpolicy", lsa_openpolicy, METH_VARARGS | METH_KEYWORDS, 
-         "Open a policy handle" },
-       
-       { "close", lsa_close, METH_VARARGS, 
-         "Close a policy handle" },
-
-       /* Name <-> SID resolution */
-
-       { "lookupnames", lsa_lookupnames, METH_VARARGS | METH_KEYWORDS,
-         "Look up SIDS from a list of names" },
-
-       { "lookupsids", lsa_lookupsids, METH_VARARGS | METH_KEYWORDS,
-         "Look up names from a list of SIDS" },
-
-       { NULL }
-};
-
-/*
- * Module initialisation 
-*/
-
-void initlsa(void)
-{
-       PyObject *module, *dict;
-
-       /* Initialise module */
-
-       module = Py_InitModule("lsa", lsa_methods);
-       dict = PyModule_GetDict(module);
-
-       lsa_error = PyErr_NewException("lsa.error", NULL, NULL);
-       PyDict_SetItemString(dict, "error", lsa_error);
-
-       lsa_ntstatus = PyErr_NewException("lsa.ntstatus", NULL, NULL);
-       PyDict_SetItemString(dict, "ntstatus", lsa_ntstatus);
-
-       /* Initialise policy handle object */
-
-       lsa_policy_hnd_type.ob_type = &PyType_Type;
-
-       /* Initialise constants */
-
-//     const_init(dict);
-
-       /* Do samba initialisation */
-
-       py_samba_init();
-}
diff --git a/source3/python/py_spoolss.c b/source3/python/py_spoolss.c
deleted file mode 100644 (file)
index ead54fe..0000000
+++ /dev/null
@@ -1,433 +0,0 @@
-/* 
-   Python wrappers for DCERPC/SMB client routines.
-
-   Copyright (C) Tim Potter, 2002
-   
-   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 02139, USA.
-*/
-
-#include "python/py_spoolss.h"
-
-/* Exceptions this module can raise */
-
-PyObject *spoolss_error, *spoolss_werror;
-
-/*
- * Routines to convert from python hashes to Samba structures
- */
-
-struct cli_state *open_pipe_creds(char *system_name, PyObject *creds, 
-                                 cli_pipe_fn *connect_fn,
-                                 struct cli_state *cli)
-{
-       struct ntuser_creds nt_creds;
-
-       if (!cli) {
-               cli = (struct cli_state *)malloc(sizeof(struct cli_state));
-               if (!cli)
-                       return NULL;
-       }
-
-       ZERO_STRUCTP(cli);
-
-       /* Extract credentials from the python dictionary and initialise
-          the ntuser_creds struct from them. */
-
-       ZERO_STRUCT(nt_creds);
-       nt_creds.pwd.null_pwd = True;
-
-       if (creds && PyDict_Size(creds) > 0) {
-               char *username, *password, *domain;
-               PyObject *username_obj, *password_obj, *domain_obj;
-
-               /* Check credentials passed are valid.  This means the
-                  username, domain and password keys must exist and be
-                  string objects. */
-
-               username_obj = PyDict_GetItemString(creds, "username");
-               domain_obj = PyDict_GetItemString(creds, "domain");
-               password_obj = PyDict_GetItemString(creds, "password");
-
-               if (!username_obj || !domain_obj || !password_obj) {
-               error:
-                       PyErr_SetString(spoolss_error, "invalid credentials");
-                       return NULL;
-               }
-
-               if (!PyString_Check(username_obj) || 
-                   !PyString_Check(domain_obj) || 
-                   !PyString_Check(password_obj))
-                       goto error;
-
-               username = PyString_AsString(username_obj);
-               domain = PyString_AsString(domain_obj);
-               password = PyString_AsString(password_obj);
-
-               if (!username || !domain || !password)
-                       goto error;
-
-               /* Initialise nt_creds structure with passed creds */
-
-               fstrcpy(nt_creds.user_name, username);
-               fstrcpy(nt_creds.domain, domain);
-
-               if (lp_encrypted_passwords())
-                       pwd_make_lm_nt_16(&nt_creds.pwd, password);
-               else
-                       pwd_set_cleartext(&nt_creds.pwd, password);
-
-               nt_creds.pwd.null_pwd = False;
-       }
-
-       /* Now try to connect */
-
-       connect_fn(cli, system_name, &nt_creds);
-
-       return cli;
-}
-
-PyObject *new_policy_hnd_object(struct cli_state *cli, TALLOC_CTX *mem_ctx, 
-                               POLICY_HND *pol)
-{
-       spoolss_policy_hnd_object *o;
-
-       o = PyObject_New(spoolss_policy_hnd_object, &spoolss_policy_hnd_type);
-
-       o->cli = cli;
-       o->mem_ctx = mem_ctx;
-       memcpy(&o->pol, pol, sizeof(POLICY_HND));
-
-       return (PyObject*)o;
-}
-     
-/* 
- * Method dispatch table
- */
-
-static PyMethodDef spoolss_methods[] = {
-
-       /* Open/close printer handles */
-       
-       { "openprinter", spoolss_openprinter, METH_VARARGS | METH_KEYWORDS, 
-         "openprinter(printername, [creds, access]) -> <spoolss hnd object>
-
-Open a printer given by printername in UNC format.  Optionally a 
-dictionary of (username, password) may be given in which case they are
-used when opening the RPC pipe.  An access mask may also be given which
-defaults to MAXIMUM_ALLOWED_ACCESS.
-
-Example:
-
->>> hnd = spoolss.openprinter(\"\\\\\\\\NPSD-PDC2\\\\meanie\")
-"},
-       
-       { "closeprinter", spoolss_closeprinter, METH_VARARGS, 
-         "closeprinter()
-
-Close a printer handle opened with openprinter or addprinter.
-
-Example:
-
->>> spoolss.closeprinter(hnd)
-"},
-
-       /* Server enumeratation functions */
-
-       { "enumprinters", spoolss_enumprinters, METH_VARARGS | METH_KEYWORDS,
-         "enumprinters(server, [creds, level, flags]) -> list
-
-Return a list of printers on a print server.  The credentials, info level
-and flags may be specified as keyword arguments.
-
-Example:
-
->>> print spoolss.enumprinters(\"\\\\\\\\npsd-pdc2\")
-[{'comment': 'i am a comment', 'printer_name': 'meanie', 'flags': 8388608, 
-  'description': 'meanie,Generic / Text Only,i am a location'}, 
- {'comment': '', 'printer_name': 'fileprint', 'flags': 8388608, 
-  'description': 'fileprint,Generic / Text Only,'}]
-"},
-
-       { "enumports", spoolss_enumports, METH_VARARGS | METH_KEYWORDS,
-         "enumports(server, [creds, level]) -> list
-
-Return a list of ports on a print server.
-
-Example:
-
->>> print spoolss.enumports(\"\\\\\\\\npsd-pdc2\")
-[{'name': 'LPT1:'}, {'name': 'LPT2:'}, {'name': 'COM1:'}, {'name': 'COM2:'}, 
- {'name': 'FILE:'}, {'name': '\\\\nautilus1\\zpekt3r'}]
-"},
-
-       { "enumprinterdrivers", spoolss_enumprinterdrivers, METH_VARARGS |
-         METH_KEYWORDS, 
-"enumprinterdrivers(server, [level, arch, creds]) -> list
-
-Return a list of printer drivers.
-"},
-       /* Miscellaneous other commands */
-
-       { "getprinterdriverdir", spoolss_getprinterdriverdir, METH_VARARGS |
-         METH_KEYWORDS, "getprinterdriverdir(server, [creds]) -> string
-
-Return the printer driver directory for a given architecture.  The 
-architecture defaults to \"Windows NT x86\".
-"},
-
-       /* Other stuff - this should really go into a samba config module
-          but for the moment let's leave it here. */
-
-       { "setup_logging", py_setup_logging, METH_VARARGS | METH_KEYWORDS, 
-         "" },
-
-       { "get_debuglevel", get_debuglevel, METH_VARARGS, "" },
-       { "set_debuglevel", set_debuglevel, METH_VARARGS, "" },
-
-       { NULL }
-};
-
-/* Methods attached to a spoolss handle object */
-
-static PyMethodDef spoolss_hnd_methods[] = {
-
-       /* Printer info */
-
-       { "getprinter", spoolss_getprinter, METH_VARARGS | METH_KEYWORDS,
-         "getprinter([level]) -> dict
-
-Return a dictionary of print information.  The info level defaults to 1.
-
-Example:
-
->>> hnd.getprinter()
-{'comment': 'i am a comment', 'printer_name': '\\\\NPSD-PDC2\\meanie', 
- 'description': '\\\\NPSD-PDC2\\meanie,Generic / Text Only,i am a location',
- 'flags': 8388608}
-"},
-
-       { "setprinter", spoolss_setprinter, METH_VARARGS | METH_KEYWORDS,
-         "setprinter(dict) -> None
-
-Set printer information.
-"},
-
-       /* Printer drivers */
-
-       { "getprinterdriver", spoolss_getprinterdriver, 
-         METH_VARARGS | METH_KEYWORDS, 
-         "getprinterdriver([level = 1, arch = \"Windows NT x86\"] -> dict
-
-Return a dictionary of printer driver information.
-"},
-
-       /* Forms */
-
-       { "enumforms", spoolss_enumforms, METH_VARARGS | METH_KEYWORDS,
-         "enumforms([level = 1]) -> list
-
-Return a list of forms supported by a printer.
-"},
-
-       { "setform", spoolss_setform, METH_VARARGS | METH_KEYWORDS,
-         "setform(dict) -> None
-
-Set the form given by the dictionary argument.
-"},
-
-       { "addform", spoolss_addform, METH_VARARGS | METH_KEYWORDS,
-         "Insert a form" },
-
-       { "getform", spoolss_getform, METH_VARARGS | METH_KEYWORDS,
-         "Fetch form properties" },
-
-       { "deleteform", spoolss_deleteform, METH_VARARGS | METH_KEYWORDS,
-         "Delete a form" },
-
-       { NULL }
-
-};
-
-static void py_policy_hnd_dealloc(PyObject* self)
-{
-       PyObject_Del(self);
-}
-
-static PyObject *py_policy_hnd_getattr(PyObject *self, char *attrname)
-{
-       return Py_FindMethod(spoolss_hnd_methods, self, attrname);
-}
-
-static char spoolss_type_doc[] = 
-"Python wrapper for Windows NT SPOOLSS rpc pipe.";
-
-PyTypeObject spoolss_policy_hnd_type = {
-       PyObject_HEAD_INIT(NULL)
-       0,
-       "spoolss.hnd",
-       sizeof(spoolss_policy_hnd_object),
-       0,
-       py_policy_hnd_dealloc,  /* tp_dealloc*/
-       0,                      /* tp_print*/
-       py_policy_hnd_getattr,  /* tp_getattr*/
-       0,                      /* tp_setattr*/
-       0,                      /* tp_compare*/
-       0,                      /* tp_repr*/
-       0,                      /* tp_as_number*/
-       0,                      /* tp_as_sequence*/
-       0,                      /* tp_as_mapping*/
-       0,                      /* tp_hash */
-       0,                      /* tp_call */
-       0,                      /* tp_str */
-       0,                      /* tp_getattro */
-       0,                      /* tp_setattro */
-       0,                      /* tp_as_buffer*/
-       Py_TPFLAGS_DEFAULT,     /* tp_flags */
-       spoolss_type_doc,       /* tp_doc */
-};
-
-/* Initialise constants */
-
-struct spoolss_const {
-       char *name;
-       uint32 value;
-} spoolss_const_vals[] = {
-       
-       /* Access permissions */
-
-       { "MAXIMUM_ALLOWED_ACCESS", MAXIMUM_ALLOWED_ACCESS },
-       { "SERVER_ALL_ACCESS", SERVER_ALL_ACCESS },
-       { "SERVER_READ", SERVER_READ },
-       { "SERVER_WRITE", SERVER_WRITE },
-       { "SERVER_EXECUTE", SERVER_EXECUTE },
-       { "SERVER_ACCESS_ADMINISTER", SERVER_ACCESS_ADMINISTER },
-       { "SERVER_ACCESS_ENUMERATE", SERVER_ACCESS_ENUMERATE },
-       { "PRINTER_ALL_ACCESS", PRINTER_ALL_ACCESS },
-       { "PRINTER_READ", PRINTER_READ },
-       { "PRINTER_WRITE", PRINTER_WRITE },
-       { "PRINTER_EXECUTE", PRINTER_EXECUTE },
-       { "PRINTER_ACCESS_ADMINISTER", PRINTER_ACCESS_ADMINISTER },
-       { "PRINTER_ACCESS_USE", PRINTER_ACCESS_USE },
-       { "JOB_ACCESS_ADMINISTER", JOB_ACCESS_ADMINISTER },
-       { "JOB_ALL_ACCESS", JOB_ALL_ACCESS },
-       { "JOB_READ", JOB_READ },
-       { "JOB_WRITE", JOB_WRITE },
-       { "JOB_EXECUTE", JOB_EXECUTE },
-       { "STANDARD_RIGHTS_ALL_ACCESS", STANDARD_RIGHTS_ALL_ACCESS },
-       { "STANDARD_RIGHTS_EXECUTE_ACCESS", STANDARD_RIGHTS_EXECUTE_ACCESS },
-       { "STANDARD_RIGHTS_READ_ACCESS", STANDARD_RIGHTS_READ_ACCESS },
-       { "STANDARD_RIGHTS_REQUIRED_ACCESS", STANDARD_RIGHTS_REQUIRED_ACCESS },
-       { "STANDARD_RIGHTS_WRITE_ACCESS", STANDARD_RIGHTS_WRITE_ACCESS },
-
-       /* Printer enumeration flags */
-
-       { "PRINTER_ENUM_DEFAULT", PRINTER_ENUM_DEFAULT },
-       { "PRINTER_ENUM_LOCAL", PRINTER_ENUM_LOCAL },
-       { "PRINTER_ENUM_CONNECTIONS", PRINTER_ENUM_CONNECTIONS },
-       { "PRINTER_ENUM_FAVORITE", PRINTER_ENUM_FAVORITE },
-       { "PRINTER_ENUM_NAME", PRINTER_ENUM_NAME },
-       { "PRINTER_ENUM_REMOTE", PRINTER_ENUM_REMOTE },
-       { "PRINTER_ENUM_SHARED", PRINTER_ENUM_SHARED },
-       { "PRINTER_ENUM_NETWORK", PRINTER_ENUM_NETWORK },
-
-       /* Form types */
-
-       { "FORM_USER", FORM_USER },
-       { "FORM_BUILTIN", FORM_BUILTIN },
-       { "FORM_PRINTER", FORM_PRINTER },
-
-       /* WERRORs */
-
-       { "WERR_OK", 0 },
-       { "WERR_BADFILE", 2 },
-       { "WERR_ACCESS_DENIED", 5 },
-       { "WERR_BADFID", 6 },
-       { "WERR_BADFUNC", 1 },
-       { "WERR_INSUFFICIENT_BUFFER", 122 },
-       { "WERR_NO_SUCH_SHARE", 67 },
-       { "WERR_ALREADY_EXISTS", 80 },
-       { "WERR_INVALID_PARAM", 87 },
-       { "WERR_NOT_SUPPORTED", 50 },
-       { "WERR_BAD_PASSWORD", 86 },
-       { "WERR_NOMEM", 8 },
-       { "WERR_INVALID_NAME", 123 },
-       { "WERR_UNKNOWN_LEVEL", 124 },
-       { "WERR_OBJECT_PATH_INVALID", 161 },
-       { "WERR_NO_MORE_ITEMS", 259 },
-       { "WERR_MORE_DATA", 234 },
-       { "WERR_UNKNOWN_PRINTER_DRIVER", 1797 },
-       { "WERR_INVALID_PRINTER_NAME", 1801 },
-       { "WERR_PRINTER_ALREADY_EXISTS", 1802 },
-       { "WERR_INVALID_DATATYPE", 1804 },
-       { "WERR_INVALID_ENVIRONMENT", 1805 },
-       { "WERR_INVALID_FORM_NAME", 1902 },
-       { "WERR_INVALID_FORM_SIZE", 1903 },
-       { "WERR_BUF_TOO_SMALL", 2123 },
-       { "WERR_JOB_NOT_FOUND", 2151 },
-       { "WERR_DEST_NOT_FOUND", 2152 },
-       { "WERR_NOT_LOCAL_DOMAIN", 2320 },
-       { "WERR_PRINTER_DRIVER_IN_USE", 3001 },
-       { "WERR_STATUS_MORE_ENTRIES  ", 0x0105 },
-
-       { NULL },
-};
-
-static void const_init(PyObject *dict)
-{
-       struct spoolss_const *tmp;
-       PyObject *obj;
-
-       for (tmp = spoolss_const_vals; tmp->name; tmp++) {
-               obj = PyInt_FromLong(tmp->value);
-               PyDict_SetItemString(dict, tmp->name, obj);
-               Py_DECREF(obj);
-       }
-}
-
-/* Module initialisation */
-
-void initspoolss(void)
-{
-       PyObject *module, *dict;
-
-       /* Initialise module */
-
-       module = Py_InitModule("spoolss", spoolss_methods);
-       dict = PyModule_GetDict(module);
-
-       /* Make spools_error global an exception we can raise when an error
-          occurs. */
-
-       spoolss_error = PyErr_NewException("spoolss.error", NULL, NULL);
-       PyDict_SetItemString(dict, "error", spoolss_error);
-
-       spoolss_werror = PyErr_NewException("spoolss.werror", NULL, NULL);
-       PyDict_SetItemString(dict, "werror", spoolss_werror);
-
-       /* Initialise policy handle object */
-
-       spoolss_policy_hnd_type.ob_type = &PyType_Type;
-
-       PyDict_SetItemString(dict, "spoolss.hnd", 
-                            (PyObject *)&spoolss_policy_hnd_type);
-
-       /* Initialise constants */
-
-       const_init(dict);
-
-       /* Do samba initialisation */
-
-       py_samba_init();
-}
diff --git a/source3/python/py_spoolss.h b/source3/python/py_spoolss.h
deleted file mode 100644 (file)
index 7c7669c..0000000
+++ /dev/null
@@ -1,53 +0,0 @@
-/* 
-   Python wrappers for DCERPC/SMB client routines.
-
-   Copyright (C) Tim Potter, 2002
-   
-   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 02139, USA.
-*/
-
-#ifndef _PY_SPOOLSS_H
-#define _PY_SPOOLSS_H
-
-#include "includes.h"
-#include "Python.h"
-
-#include "python/py_common.h"
-
-/* Spoolss policy handle object */
-
-typedef struct {
-       PyObject_HEAD
-       struct cli_state *cli;
-       TALLOC_CTX *mem_ctx;
-       POLICY_HND pol;
-} spoolss_policy_hnd_object;
-     
-/* Exceptions raised by this module */
-
-extern PyTypeObject spoolss_policy_hnd_type;
-
-extern PyObject *spoolss_error, *spoolss_werror;
-
-/* Return a cli_state struct opened on the SPOOLSS pipe.  If credentials
-   are passed use them. */
-
-typedef struct cli_state *(cli_pipe_fn)(
-       struct cli_state *cli, char *system_name,
-       struct ntuser_creds *creds);
-
-#include "python/py_spoolss_proto.h"
-
-#endif /* _PY_SPOOLSS_H */
diff --git a/source3/python/py_spoolss_drivers.c b/source3/python/py_spoolss_drivers.c
deleted file mode 100644 (file)
index 5c0d617..0000000
+++ /dev/null
@@ -1,243 +0,0 @@
-/* 
-   Python wrappers for DCERPC/SMB client routines.
-
-   Copyright (C) Tim Potter, 2002
-   
-   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 02139, USA.
-*/
-
-#include "python/py_spoolss.h"
-
-/* Enumerate printer drivers */
-
-PyObject *spoolss_enumprinterdrivers(PyObject *self, PyObject *args,
-                                    PyObject *kw)
-{
-       WERROR werror;
-       PyObject *result = Py_None, *creds = NULL;
-       PRINTER_DRIVER_CTR ctr;
-       int level = 1, i;
-       uint32 needed, num_drivers;
-       char *arch = "Windows NT x86", *server_name;
-       static char *kwlist[] = {"server", "level", "arch", "creds", NULL};
-       struct cli_state *cli = NULL;
-       TALLOC_CTX *mem_ctx = NULL;
-
-       /* Parse parameters */
-
-       if (!PyArg_ParseTupleAndKeywords(args, kw, "s|isO!", kwlist, 
-                                        &server_name, &level, &arch,
-                                        &PyDict_Type, &creds))
-               return NULL;
-       
-       /* Call rpc function */
-       
-       if (!(cli = open_pipe_creds(server_name, creds, 
-                                   cli_spoolss_initialise, NULL))) {
-               fprintf(stderr, "could not initialise cli state\n");
-               goto done;
-       }
-
-       if (!(mem_ctx = talloc_init())) {
-               fprintf(stderr, "unable to initialise talloc context\n");
-               goto done;
-       }       
-
-       werror = cli_spoolss_enumprinterdrivers(
-               cli, mem_ctx, 0, &needed, level, arch,
-               &num_drivers, &ctr);
-
-       if (W_ERROR_V(werror) == ERRinsufficientbuffer)
-               werror = cli_spoolss_enumprinterdrivers(
-                       cli, mem_ctx, needed, NULL, level, arch, 
-                       &num_drivers, &ctr);
-
-       if (!W_ERROR_IS_OK(werror)) {
-               PyErr_SetObject(spoolss_werror, py_werror_tuple(werror));
-               return NULL;
-       }
-
-       /* Return value */
-       
-       switch (level) {
-       case 1:
-               result = PyList_New(num_drivers);
-               
-               for (i = 0; i < num_drivers; i++) {
-                       PyObject *value;
-                       
-                       py_from_DRIVER_INFO_1(&value, ctr.info1);
-                       PyList_SetItem(result, i, value);
-               }
-               
-               break;
-       case 2: 
-               result = PyList_New(num_drivers);
-
-               for(i = 0; i < num_drivers; i++) {
-                       PyObject *value;
-
-                       py_from_DRIVER_INFO_2(&value, ctr.info2);
-                       PyList_SetItem(result, i, value);
-               }
-
-               break;
-       case 6: 
-               result = PyList_New(num_drivers);
-
-               for(i = 0; i < num_drivers; i++) {
-                       PyObject *value;
-
-                       py_from_DRIVER_INFO_6(&value, ctr.info6);
-                       PyList_SetItem(result, i, value);
-               }
-
-               break;
-       default:
-               result = Py_None;
-               break;
-       }
-       
- done:
-       if (cli)
-               cli_shutdown(cli);
-
-       if (mem_ctx)
-               talloc_destroy(mem_ctx);
-
-       Py_INCREF(result);
-       return result;
-}
-
-/* Fetch printer driver */
-
-PyObject *spoolss_getprinterdriver(PyObject *self, PyObject *args,
-                                  PyObject *kw)
-{
-       spoolss_policy_hnd_object *hnd = (spoolss_policy_hnd_object *)self;
-       WERROR werror;
-       PyObject *result = Py_None;
-       PRINTER_DRIVER_CTR ctr;
-       int level = 1;
-       uint32 needed;
-       char *arch = "Windows NT x86";
-       static char *kwlist[] = {"level", "arch", NULL};
-
-       /* Parse parameters */
-
-       if (!PyArg_ParseTupleAndKeywords(args, kw, "|is", kwlist, 
-                                        &level, &arch))
-               return NULL;
-
-       /* Call rpc function */
-
-       werror = cli_spoolss_getprinterdriver(
-               hnd->cli, hnd->mem_ctx, 0, &needed, &hnd->pol, level,
-               arch, &ctr);
-
-       if (W_ERROR_V(werror) == ERRinsufficientbuffer)
-               werror = cli_spoolss_getprinterdriver(
-                       hnd->cli, hnd->mem_ctx, needed, NULL, &hnd->pol,
-                       level, arch, &ctr);
-
-       if (!W_ERROR_IS_OK(werror)) {
-               PyErr_SetObject(spoolss_werror, py_werror_tuple(werror));
-               return NULL;
-       }
-
-       /* Return value */
-       
-       switch (level) {
-       case 1:
-               py_from_DRIVER_INFO_1(&result, ctr.info1);
-               break;
-       case 2: 
-               py_from_DRIVER_INFO_2(&result, ctr.info2);
-               break;
-       case 6:
-               py_from_DRIVER_INFO_6(&result,  ctr.info6);
-               break;
-       default:
-               break;
-       }
-       
-       Py_INCREF(result);
-       return result;
-}
-
-/* Fetch printer driver directory */
-
-PyObject *spoolss_getprinterdriverdir(PyObject *self, PyObject *args, 
-                                     PyObject *kw)
-{
-       WERROR werror;
-       PyObject *result = Py_None, *creds = NULL;
-       DRIVER_DIRECTORY_CTR ctr;
-       uint32 needed, level;
-       char *arch = "Windows NT x86", *server_name;
-       static char *kwlist[] = {"server", "level", "arch", "creds", NULL};
-       struct cli_state *cli = NULL;
-       TALLOC_CTX *mem_ctx = NULL;
-
-       /* Parse parameters */
-
-       if (!PyArg_ParseTupleAndKeywords(args, kw, "s|isO!", kwlist, 
-                                        &server_name, &level, &arch,
-                                        &PyDict_Type, &creds))
-               return NULL;
-
-       /* Call rpc function */
-
-       if (!(cli = open_pipe_creds(server_name, creds, 
-                                   cli_spoolss_initialise, NULL))) {
-               fprintf(stderr, "could not initialise cli state\n");
-               goto done;
-       }
-
-       if (!(mem_ctx = talloc_init())) {
-               fprintf(stderr, "unable to initialise talloc context\n");
-               goto done;
-       }       
-
-       werror = cli_spoolss_getprinterdriverdir(
-               cli, mem_ctx, 0, &needed, level, arch, &ctr);
-
-       if (W_ERROR_V(werror) == ERRinsufficientbuffer)
-               werror = cli_spoolss_getprinterdriverdir(
-                       cli, mem_ctx, needed, NULL, level, arch, &ctr);
-
-       if (!W_ERROR_IS_OK(werror)) {
-               PyErr_SetObject(spoolss_werror, py_werror_tuple(werror));
-               return NULL;
-       }
-
-       /* Return value */
-       
-       switch (level) {
-       case 1:
-               py_from_DRIVER_DIRECTORY_1(&result, ctr.info1);
-               break;
-       }
-       
- done:
-       if (cli)
-               cli_shutdown(cli);
-       
-       if (mem_ctx)
-               talloc_destroy(mem_ctx);
-
-       Py_INCREF(result);
-       return result;
-}
diff --git a/source3/python/py_spoolss_drivers_conv.c b/source3/python/py_spoolss_drivers_conv.c
deleted file mode 100644 (file)
index 70a57a1..0000000
+++ /dev/null
@@ -1,137 +0,0 @@
-/* 
-   Python wrappers for DCERPC/SMB client routines.
-
-   Copyright (C) Tim Potter, 2002
-   
-   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 02139, USA.
-*/
-
-#include "python/py_spoolss.h"
-#include "python/py_conv.h"
-
-/* Structure/hash conversions */
-
-struct pyconv py_DRIVER_INFO_1[] = {
-       { "name", PY_UNISTR, offsetof(DRIVER_INFO_1, name) },
-       { NULL }
-};
-
-struct pyconv py_DRIVER_INFO_2[] = {
-       { "version", PY_UINT32, offsetof(DRIVER_INFO_2, version) },
-       { "name", PY_UNISTR, offsetof(DRIVER_INFO_2, name) },
-       { "architecture", PY_UNISTR, offsetof(DRIVER_INFO_2, architecture) },
-       { "driver_path", PY_UNISTR, offsetof(DRIVER_INFO_2, driverpath) },
-       { "data_file", PY_UNISTR, offsetof(DRIVER_INFO_2, datafile) },
-       { "config_file", PY_UNISTR, offsetof(DRIVER_INFO_2, configfile) },
-       { NULL }
-};
-
-struct pyconv py_DRIVER_INFO_3[] = {
-       { "version", PY_UINT32, offsetof(DRIVER_INFO_3, version) },
-       { "name", PY_UNISTR, offsetof(DRIVER_INFO_3, name) },
-       { "architecture", PY_UNISTR, offsetof(DRIVER_INFO_3, architecture) },
-       { "driver_path", PY_UNISTR, offsetof(DRIVER_INFO_3, driverpath) },
-       { "data_file", PY_UNISTR, offsetof(DRIVER_INFO_3, datafile) },
-       { "config_file", PY_UNISTR, offsetof(DRIVER_INFO_3, configfile) },
-       { "help_file", PY_UNISTR, offsetof(DRIVER_INFO_3, helpfile) },
-       /* dependentfiles */
-       { "monitor_name", PY_UNISTR, offsetof(DRIVER_INFO_3, monitorname) },
-       { "default_datatype", PY_UNISTR, offsetof(DRIVER_INFO_3, defaultdatatype) },
-       { NULL }
-};
-
-struct pyconv py_DRIVER_INFO_6[] = {
-       { "version", PY_UINT32, offsetof(DRIVER_INFO_6, version) },
-       { "name", PY_UNISTR, offsetof(DRIVER_INFO_6, name) },
-       { "architecture", PY_UNISTR, offsetof(DRIVER_INFO_6, architecture) },
-       { "driver_path", PY_UNISTR, offsetof(DRIVER_INFO_6, driverpath) },
-       { "data_file", PY_UNISTR, offsetof(DRIVER_INFO_6, datafile) },
-       { "config_file", PY_UNISTR, offsetof(DRIVER_INFO_6, configfile) },
-       { "help_file", PY_UNISTR, offsetof(DRIVER_INFO_6, helpfile) },
-       /* dependentfiles */
-       { "monitor_name", PY_UNISTR, offsetof(DRIVER_INFO_6, monitorname) },
-       { "default_datatype", PY_UNISTR, offsetof(DRIVER_INFO_6, defaultdatatype) },
-       /* driver_date */
-
-       { "padding", PY_UINT32, offsetof(DRIVER_INFO_6, padding) },
-       { "driver_version_low", PY_UINT32, offsetof(DRIVER_INFO_6, driver_version_low) },
-       { "driver_version_high", PY_UINT32, offsetof(DRIVER_INFO_6, driver_version_high) },
-       { "mfg_name", PY_UNISTR, offsetof(DRIVER_INFO_6, mfgname) },
-       { "oem_url", PY_UNISTR, offsetof(DRIVER_INFO_6, oem_url) },
-       { "hardware_id", PY_UNISTR, offsetof(DRIVER_INFO_6, hardware_id) },
-       { "provider", PY_UNISTR, offsetof(DRIVER_INFO_6, provider) },
-       
-       { NULL }
-};
-
-struct pyconv py_DRIVER_DIRECTORY_1[] = {
-       { "name", PY_UNISTR, offsetof(DRIVER_DIRECTORY_1, name) },
-       { NULL }
-};
-
-BOOL py_from_DRIVER_INFO_1(PyObject **dict, DRIVER_INFO_1 *info)
-{
-       *dict = from_struct(info, py_DRIVER_INFO_1);
-       return True;
-}
-
-BOOL py_to_DRIVER_INFO_1(DRIVER_INFO_1 *info, PyObject *dict)
-{
-       return False;
-}
-
-BOOL py_from_DRIVER_INFO_2(PyObject **dict, DRIVER_INFO_2 *info)
-{
-       *dict = from_struct(info, py_DRIVER_INFO_2);
-       return True;
-}
-
-BOOL py_to_DRIVER_INFO_2(DRIVER_INFO_2 *info, PyObject *dict)
-{
-       return False;
-}
-
-BOOL py_from_DRIVER_INFO_3(PyObject **dict, DRIVER_INFO_3 *info)
-{
-       *dict = from_struct(info, py_DRIVER_INFO_3);
-       return True;
-}
-
-BOOL py_to_DRIVER_INFO_3(DRIVER_INFO_3 *info, PyObject *dict)
-{
-       return False;
-}
-
-BOOL py_from_DRIVER_INFO_6(PyObject **dict, DRIVER_INFO_6 *info)
-{
-       *dict = from_struct(info, py_DRIVER_INFO_6);
-       return True;
-}
-
-BOOL py_to_DRIVER_INFO_6(DRIVER_INFO_6 *info, PyObject *dict)
-{
-       return False;
-}
-
-BOOL py_from_DRIVER_DIRECTORY_1(PyObject **dict, DRIVER_DIRECTORY_1 *info)
-{
-       *dict = from_struct(info, py_DRIVER_DIRECTORY_1);
-       return True;
-}
-
-BOOL py_to_DRIVER_DIRECTORY_1(DRIVER_DIRECTORY_1 *info, PyObject *dict)
-{
-       return False;
-}
diff --git a/source3/python/py_spoolss_forms.c b/source3/python/py_spoolss_forms.c
deleted file mode 100644 (file)
index 9f8a49b..0000000
+++ /dev/null
@@ -1,237 +0,0 @@
-/* 
-   Python wrappers for DCERPC/SMB client routines.
-
-   Copyright (C) Tim Potter, 2002
-   
-   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 02139, USA.
-*/
-
-#include "python/py_spoolss.h"
-
-/* Add a form */
-
-PyObject *spoolss_addform(PyObject *self, PyObject *args, PyObject *kw)
-{
-       spoolss_policy_hnd_object *hnd = (spoolss_policy_hnd_object *)self;
-       WERROR werror;
-       PyObject *py_form, *py_form_name;
-       char *form_name;
-       FORM form;
-       int level = 1;
-       static char *kwlist[] = {"form", "level", NULL};
-
-       /* Parse parameters */
-
-       if (!PyArg_ParseTupleAndKeywords(
-                   args, kw, "O!|i", kwlist, &PyDict_Type, &py_form, &level))
-               return NULL;
-       
-       /* Call rpc function */
-
-       if (!py_to_FORM(&form, py_form) ||
-           !(py_form_name = PyDict_GetItemString(py_form, "name")) ||
-           !(form_name = PyString_AsString(py_form_name))) {
-               PyErr_SetString(spoolss_error, "invalid form");
-               return NULL;
-       }
-
-       switch (level) {
-       case 1:
-               init_unistr2(&form.name, form_name, strlen(form_name) + 1);
-               break;
-       default:
-               PyErr_SetString(spoolss_error, "unsupported info level");
-               return NULL;
-       }
-
-       werror = cli_spoolss_addform(hnd->cli, hnd->mem_ctx, &hnd->pol,
-                                    level, &form);
-
-
-       if (!W_ERROR_IS_OK(werror)) {
-               PyErr_SetObject(spoolss_werror, py_werror_tuple(werror));
-               return NULL;
-       }
-
-       Py_INCREF(Py_None);
-       return Py_None;
-}
-
-/* Get form properties */
-
-PyObject *spoolss_getform(PyObject *self, PyObject *args, PyObject *kw)
-{
-       spoolss_policy_hnd_object *hnd = (spoolss_policy_hnd_object *)self;
-       WERROR werror;
-       PyObject *result;
-       char *form_name;
-       int level = 1;
-       static char *kwlist[] = {"form_name", "level", NULL};
-       uint32 needed;
-       FORM_1 form;
-
-       /* Parse parameters */
-
-       if (!PyArg_ParseTupleAndKeywords(args, kw, "s|i", kwlist, 
-                                        &form_name, &level))
-               return NULL;
-       
-       /* Call rpc function */
-
-       werror = cli_spoolss_getform(hnd->cli, hnd->mem_ctx, 0, &needed,
-                                    &hnd->pol, form_name, 1, &form);
-
-       if (W_ERROR_V(werror) == ERRinsufficientbuffer)
-               werror = cli_spoolss_getform(
-                       hnd->cli, hnd->mem_ctx, needed, NULL, &hnd->pol,
-                       form_name, 1, &form);
-
-       if (!W_ERROR_IS_OK(werror)) {
-               PyErr_SetObject(spoolss_werror, py_werror_tuple(werror));
-               return NULL;
-       }
-
-       result = Py_None;
-
-       switch(level) {
-       case 1:
-               py_from_FORM_1(&result, &form);
-               break;
-       }
-
-       Py_INCREF(result);
-       return result;
-}
-
-/* Set form properties */
-
-PyObject *spoolss_setform(PyObject *self, PyObject *args, PyObject *kw)
-{
-       spoolss_policy_hnd_object *hnd = (spoolss_policy_hnd_object *)self;
-       WERROR werror;
-       PyObject *py_form, *py_form_name;
-       int level = 1;
-       static char *kwlist[] = {"form", "level", NULL};
-       char *form_name;
-       FORM form;
-
-       /* Parse parameters */
-
-       if (!PyArg_ParseTupleAndKeywords(args, kw, "O!|i", kwlist, 
-                                        &PyDict_Type, &py_form, &level))
-               return NULL;
-       
-       /* Call rpc function */
-
-       if (!py_to_FORM(&form, py_form) ||
-           !(py_form_name = PyDict_GetItemString(py_form, "name")) ||
-           !(form_name = PyString_AsString(py_form_name))) {
-               PyErr_SetString(spoolss_error, "invalid form");
-               return NULL;
-       }
-
-       init_unistr2(&form.name, form_name, strlen(form_name) + 1);
-
-       werror = cli_spoolss_setform(hnd->cli, hnd->mem_ctx, &hnd->pol,
-                                    level, form_name, &form);
-
-       if (!W_ERROR_IS_OK(werror)) {
-               PyErr_SetObject(spoolss_werror, py_werror_tuple(werror));
-               return NULL;
-       }
-
-       Py_INCREF(Py_None);
-       return Py_None;
-}
-
-/* Delete a form */
-
-PyObject *spoolss_deleteform(PyObject *self, PyObject *args, PyObject *kw)
-{
-       spoolss_policy_hnd_object *hnd = (spoolss_policy_hnd_object *)self;
-       WERROR werror;
-       int level = 1;
-       static char *kwlist[] = {"form_name", "level", NULL};
-       char *form_name;
-
-       /* Parse parameters */
-       
-       if (!PyArg_ParseTupleAndKeywords(
-                   args, kw, "s|i", kwlist, &form_name, &level))
-               return NULL;
-       
-       /* Call rpc function */
-
-       werror = cli_spoolss_deleteform(
-               hnd->cli, hnd->mem_ctx, &hnd->pol, form_name);
-
-       if (!W_ERROR_IS_OK(werror)) {
-               PyErr_SetObject(spoolss_werror, py_werror_tuple(werror));
-               return NULL;
-       }
-
-       Py_INCREF(Py_None);
-       return Py_None;
-}
-
-/* Enumerate forms */
-
-PyObject *spoolss_enumforms(PyObject *self, PyObject *args, PyObject *kw)
-{
-       PyObject *result;
-       spoolss_policy_hnd_object *hnd = (spoolss_policy_hnd_object *)self;
-       WERROR werror;
-       uint32 level = 1, num_forms, needed, i;
-       static char *kwlist[] = {"level", NULL};
-       FORM_1 *forms;
-
-       /* Parse parameters */
-       
-       if (!PyArg_ParseTupleAndKeywords(
-                   args, kw, "|i", kwlist, &level))
-               return NULL;
-       
-       /* Call rpc function */
-
-       werror = cli_spoolss_enumforms(
-               hnd->cli, hnd->mem_ctx, 0, &needed, &hnd->pol, level,
-               &num_forms, &forms);
-
-       if (W_ERROR_V(werror) == ERRinsufficientbuffer)
-               werror = cli_spoolss_enumforms(
-                       hnd->cli, hnd->mem_ctx, needed, NULL, &hnd->pol, level,
-                       &num_forms, &forms);
-
-       if (!W_ERROR_IS_OK(werror)) {
-               PyErr_SetObject(spoolss_werror, py_werror_tuple(werror));
-               return NULL;
-       }
-
-       result = PyList_New(num_forms);
-
-       for (i = 0; i < num_forms; i++) {
-               PyObject *obj = NULL;
-
-               switch(level) {
-               case 1:
-                       py_from_FORM_1(&obj, &forms[i]);
-                       break;
-               }
-
-               PyList_SetItem(result, i, obj);
-       }
-
-       return result;
-}
diff --git a/source3/python/py_spoolss_forms_conv.c b/source3/python/py_spoolss_forms_conv.c
deleted file mode 100644 (file)
index 2ded9af..0000000
+++ /dev/null
@@ -1,57 +0,0 @@
-/* 
-   Python wrappers for DCERPC/SMB client routines.
-
-   Copyright (C) Tim Potter, 2002
-   
-   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 02139, USA.
-*/
-
-#include "python/py_spoolss.h"
-#include "python/py_conv.h"
-
-struct pyconv py_FORM[] = {
-       { "flags", PY_UINT32, offsetof(FORM, flags) },
-       { "width", PY_UINT32, offsetof(FORM, size_x) },
-       { "length", PY_UINT32, offsetof(FORM, size_y) },
-       { "top", PY_UINT32, offsetof(FORM, top) },
-       { "left", PY_UINT32, offsetof(FORM, left) },
-       { "right", PY_UINT32, offsetof(FORM, right) },
-       { "bottom", PY_UINT32, offsetof(FORM, bottom) },
-       { NULL }
-};
-
-struct pyconv py_FORM_1[] = {
-       { "flags", PY_UINT32, offsetof(FORM_1, flag) },
-       { "width", PY_UINT32, offsetof(FORM_1, width) },
-       { "length", PY_UINT32, offsetof(FORM_1, length) },
-       { "top", PY_UINT32, offsetof(FORM_1, top) },
-       { "left", PY_UINT32, offsetof(FORM_1, left) },
-       { "right", PY_UINT32, offsetof(FORM_1, right) },
-       { "bottom", PY_UINT32, offsetof(FORM_1, bottom) },
-       { "name", PY_UNISTR, offsetof(FORM_1, name) },
-       { NULL }
-};
-
-BOOL py_from_FORM_1(PyObject **dict, FORM_1 *form)
-{
-       *dict = from_struct(form, py_FORM_1);
-       return True;
-}
-
-BOOL py_to_FORM(FORM *form, PyObject *dict)
-{
-       to_struct(form, dict, py_FORM);
-       return True;
-}
diff --git a/source3/python/py_spoolss_ports.c b/source3/python/py_spoolss_ports.c
deleted file mode 100644 (file)
index 2d73a6e..0000000
+++ /dev/null
@@ -1,95 +0,0 @@
-/* 
-   Python wrappers for DCERPC/SMB client routines.
-
-   Copyright (C) Tim Potter, 2002
-   
-   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 02139, USA.
-*/
-
-#include "python/py_spoolss.h"
-
-/* Enumerate ports */
-
-PyObject *spoolss_enumports(PyObject *self, PyObject *args, PyObject *kw)
-{
-       WERROR werror;
-       PyObject *result, *creds = NULL;
-       int level = 1;
-       uint32 i, needed, num_ports;
-       static char *kwlist[] = {"server", "level", "creds", NULL};
-       TALLOC_CTX *mem_ctx = NULL;
-       struct cli_state *cli = NULL;
-       char *server;
-       PORT_INFO_CTR ctr;
-
-       /* Parse parameters */
-
-       if (!PyArg_ParseTupleAndKeywords(args, kw, "s|iO!", kwlist, 
-                                        &server, &creds, &level, 
-                                        &PyDict_Type))
-               return NULL;
-       
-       if (server[0] == '\\' && server[1] == '\\')
-               server += 2;
-
-       mem_ctx = talloc_init();
-       cli = open_pipe_creds(server, creds, cli_spoolss_initialise, NULL);
-
-       /* Call rpc function */
-       
-       werror = cli_spoolss_enum_ports(
-               cli, mem_ctx, 0, &needed, level, &num_ports, &ctr);
-
-       if (W_ERROR_V(werror) == ERRinsufficientbuffer)
-               werror = cli_spoolss_enum_ports(
-                       cli, mem_ctx, needed, NULL, level,
-                       &num_ports, &ctr);
-
-       /* Return value */
-       
-       result = Py_None;
-
-       if (!W_ERROR_IS_OK(werror))
-               goto done;
-
-       result = PyList_New(num_ports);
-
-       switch (level) {
-       case 1: 
-               for (i = 0; i < num_ports; i++) {
-                       PyObject *value;
-
-                       py_from_PORT_INFO_1(&value, &ctr.port.info_1[i]);
-
-                       PyList_SetItem(result, i, value);
-               }
-
-               break;
-       case 2:
-               for(i = 0; i < num_ports; i++) {
-                       PyObject *value;
-
-                       py_from_PORT_INFO_2(&value, &ctr.port.info_2[i]);
-
-                       PyList_SetItem(result, i, value);
-               }
-               
-               break;
-       }
-
- done:
-       Py_INCREF(result);
-       return result;
-}
diff --git a/source3/python/py_spoolss_printers.c b/source3/python/py_spoolss_printers.c
deleted file mode 100644 (file)
index b003340..0000000
+++ /dev/null
@@ -1,363 +0,0 @@
-/* 
-   Python wrappers for DCERPC/SMB client routines.
-
-   Copyright (C) Tim Potter, 2002
-   
-   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 02139, USA.
-*/
-
-#include "python/py_spoolss.h"
-
-/* Open a printer */
-
-PyObject *spoolss_openprinter(PyObject *self, PyObject *args, PyObject *kw)
-{
-       char *full_name, *computer_name = NULL;
-       TALLOC_CTX *mem_ctx;
-       POLICY_HND hnd;
-       WERROR werror;
-       PyObject *result = NULL, *creds = NULL;
-       static char *kwlist[] = { "printername", "creds", "access", NULL };
-       uint32 desired_access = MAXIMUM_ALLOWED_ACCESS;
-       struct cli_state *cli;
-
-       if (!PyArg_ParseTupleAndKeywords(
-               args, kw, "s|O!i", kwlist, &full_name, &PyDict_Type, &creds,
-               &desired_access)) {
-
-               goto done;
-       }
-
-       /* FIXME: Return name format exception for names without a UNC
-          prefix */ 
-
-       computer_name = strdup(full_name + 2);
-
-       if (strchr(computer_name, '\\')) {
-               char *c = strchr(computer_name, '\\');
-               *c = 0;
-       }
-
-       if (!(cli = open_pipe_creds(computer_name, creds, 
-                                   cli_spoolss_initialise, NULL))) {
-               fprintf(stderr, "could not initialise cli state\n");
-               goto done;
-       }
-
-       if (!(mem_ctx = talloc_init())) {
-               fprintf(stderr, "unable to initialise talloc context\n");
-               goto done;
-       }
-
-       werror = cli_spoolss_open_printer_ex(
-               cli, mem_ctx, full_name, "", desired_access, computer_name, 
-               "", &hnd);
-
-       if (!W_ERROR_IS_OK(werror)) {
-               cli_shutdown(cli);
-               SAFE_FREE(cli);
-               PyErr_SetObject(spoolss_werror, py_werror_tuple(werror));
-               goto done;
-       }
-
-       result = new_policy_hnd_object(cli, mem_ctx, &hnd);
-
- done:
-       SAFE_FREE(computer_name);
-
-       return result;
-}
-
-/* Close a printer */
-
-PyObject *spoolss_closeprinter(PyObject *self, PyObject *args)
-{
-       PyObject *po;
-       spoolss_policy_hnd_object *hnd;
-       WERROR result;
-
-       /* Parse parameters */
-
-       if (!PyArg_ParseTuple(args, "O!", &spoolss_policy_hnd_type, &po))
-               return NULL;
-
-       hnd = (spoolss_policy_hnd_object *)po;
-
-       /* Call rpc function */
-
-       result = cli_spoolss_close_printer(hnd->cli, hnd->mem_ctx, &hnd->pol);
-
-       /* Cleanup samba stuf */
-
-       cli_shutdown(hnd->cli);
-       talloc_destroy(hnd->mem_ctx);
-
-       /* Return value */
-
-       Py_INCREF(Py_None);
-       return Py_None; 
-}
-
-/* Fetch printer information */
-
-PyObject *spoolss_getprinter(PyObject *self, PyObject *args, PyObject *kw)
-{
-       spoolss_policy_hnd_object *hnd = (spoolss_policy_hnd_object *)self;
-       WERROR werror;
-       PyObject *result = NULL;
-       PRINTER_INFO_CTR ctr;
-       int level = 1;
-       uint32 needed;
-       static char *kwlist[] = {"level", NULL};
-
-       /* Parse parameters */
-
-       if (!PyArg_ParseTupleAndKeywords(args, kw, "|i", kwlist, &level))
-               return NULL;
-       
-       /* Call rpc function */
-       
-       werror = cli_spoolss_getprinter(
-               hnd->cli, hnd->mem_ctx, 0, &needed, &hnd->pol, level, &ctr);
-
-       if (W_ERROR_V(werror) == ERRinsufficientbuffer)
-               werror = cli_spoolss_getprinter(
-                       hnd->cli, hnd->mem_ctx, needed, NULL, &hnd->pol,
-                       level, &ctr);
-
-       /* Return value */
-
-       if (!W_ERROR_IS_OK(werror)) {
-               PyErr_SetObject(spoolss_werror,
-                               PyInt_FromLong(W_ERROR_V(werror)));
-               return NULL;
-       }
-
-       result = Py_None;
-
-       switch (level) {
-               
-       case 0:
-               py_from_PRINTER_INFO_0(&result, ctr.printers_0);
-               break;
-
-       case 1:
-               py_from_PRINTER_INFO_1(&result, ctr.printers_1);
-               break;
-
-       case 2:
-               py_from_PRINTER_INFO_2(&result, ctr.printers_2);
-               break;
-
-       case 3:
-               py_from_PRINTER_INFO_3(&result, ctr.printers_3);
-               break;
-       }
-
-       PyDict_SetItemString(result, "level", PyInt_FromLong(level));
-
-       Py_INCREF(result);
-       return result;
-}
-
-/* Set printer information */
-
-PyObject *spoolss_setprinter(PyObject *self, PyObject *args, PyObject *kw)
-{
-       spoolss_policy_hnd_object *hnd = (spoolss_policy_hnd_object *)self;
-       WERROR werror;
-       PyObject *info, *level_obj;
-       PRINTER_INFO_CTR ctr;
-       uint32 level;
-       static char *kwlist[] = {"dict", NULL};
-       union {
-               PRINTER_INFO_0 printers_0;
-               PRINTER_INFO_1 printers_1;
-               PRINTER_INFO_2 printers_2;
-               PRINTER_INFO_3 printers_3;
-               PRINTER_INFO_4 printers_4;
-               PRINTER_INFO_5 printers_5;
-       } pinfo;
-
-       /* Parse parameters */
-
-       if (!PyArg_ParseTupleAndKeywords(args, kw, "O!", kwlist, 
-                                        &PyDict_Type, &info))
-               return NULL;
-       
-       /* Check dictionary contains a level */
-
-       if ((level_obj = PyDict_GetItemString(info, "level"))) {
-
-               if (!PyInt_Check(level_obj))
-                       goto error;
-
-               level = PyInt_AsLong(level_obj);
-
-       } else {
-       error:
-               PyErr_SetString(spoolss_error, "invalid info");
-               return NULL;
-       }
-
-       /* Fill in printer info */
-
-       ZERO_STRUCT(ctr);
-
-       switch (level) {
-       case 2: {
-               PyObject *devmode_obj;
-
-               ctr.printers_2 = &pinfo.printers_2;
-
-               if (!py_to_PRINTER_INFO_2(&pinfo.printers_2, info))
-                       goto error;
-
-#if 0
-               devmode_obj = PyDict_GetItemString(info, "device_mode");
-
-               pinfo.printers_2.devmode = talloc(
-                       hnd->mem_ctx, sizeof(DEVICEMODE));
-
-               PyDEVICEMODE_AsDEVICEMODE(pinfo.printers_2.devmode, 
-                                         devmode_obj);
-
-#else
-
-               /* FIXME: can we actually set the security descriptor using
-                  a setprinter level 2? */
-
-               pinfo.printers_2.secdesc = NULL;
-               pinfo.printers_2.secdesc = NULL;
-
-#endif
-               break;
-       }
-       default:
-               PyErr_SetString(spoolss_error, "unsupported info level");
-               return NULL;
-       }
-
-       /* Call rpc function */
-       
-       werror = cli_spoolss_setprinter(hnd->cli, hnd->mem_ctx, &hnd->pol,
-                                       level, &ctr, 0);
-
-       /* Return value */
-
-       if (!W_ERROR_IS_OK(werror)) {
-               PyErr_SetObject(spoolss_werror, py_werror_tuple(werror));
-               return NULL;
-       }
-
-       Py_INCREF(Py_None);
-       return Py_None;
-}
-
-/* Enumerate printers */
-
-PyObject *spoolss_enumprinters(PyObject *self, PyObject *args, PyObject *kw)
-{
-       WERROR werror;
-       PyObject *result, *creds = NULL;
-       PRINTER_INFO_CTR ctr;
-       int level = 1, flags = PRINTER_ENUM_LOCAL, i;
-       uint32 needed, num_printers;
-       static char *kwlist[] = {"server", "name", "level", "flags", 
-                                "creds", NULL};
-       TALLOC_CTX *mem_ctx = NULL;
-       struct cli_state *cli = NULL;
-       char *server, *name = NULL;
-
-       /* Parse parameters */
-
-       if (!PyArg_ParseTupleAndKeywords(args, kw, "s|siiO!", kwlist, 
-                                        &server, &name, &level, &flags, 
-                                        &PyDict_Type, &creds))
-               return NULL;
-       
-       if (server[0] == '\\' && server[1] == '\\')
-               server += 2;
-
-       mem_ctx = talloc_init();
-       cli = open_pipe_creds(server, creds, cli_spoolss_initialise, NULL);
-
-       /* Call rpc function */
-       
-       werror = cli_spoolss_enum_printers(
-               cli, mem_ctx, 0, &needed, flags, level,
-               &num_printers, &ctr);
-
-       if (W_ERROR_V(werror) == ERRinsufficientbuffer)
-               werror = cli_spoolss_enum_printers(
-                       cli, mem_ctx, needed, NULL, flags, level,
-                       &num_printers, &ctr);
-
-       /* Return value */
-       
-       if (!W_ERROR_IS_OK(werror)) {
-               PyErr_SetObject(spoolss_werror,
-                               PyInt_FromLong(W_ERROR_V(werror)));
-               return NULL;
-       }
-
-       result = PyList_New(num_printers);
-
-       switch (level) {
-       case 0: 
-               for (i = 0; i < num_printers; i++) {
-                       PyObject *value;
-
-                       py_from_PRINTER_INFO_0(&value, &ctr.printers_0[i]);
-
-                       PyList_SetItem(result, i, value);
-               }
-
-               break;
-       case 1:
-               for(i = 0; i < num_printers; i++) {
-                       PyObject *value;
-
-                       py_from_PRINTER_INFO_1(&value, &ctr.printers_1[i]);
-
-                       PyList_SetItem(result, i, value);
-               }
-               
-               break;
-       case 2:
-               for(i = 0; i < num_printers; i++) {
-                       PyObject *value;
-
-                       py_from_PRINTER_INFO_2(&value, &ctr.printers_2[i]);
-
-                       PyList_SetItem(result, i, value);
-               }
-               
-               break;
-       case 3:
-               for(i = 0; i < num_printers; i++) {
-                       PyObject *value;
-
-                       py_from_PRINTER_INFO_3(&value, &ctr.printers_3[i]);
-
-                       PyList_SetItem(result, i, value);
-               }
-               
-               break;
-       }
-
-       Py_INCREF(result);
-       return result;
-}
diff --git a/source3/python/py_spoolss_printers_conv.c b/source3/python/py_spoolss_printers_conv.c
deleted file mode 100644 (file)
index 84a0681..0000000
+++ /dev/null
@@ -1,367 +0,0 @@
-/* 
-   Python wrappers for DCERPC/SMB client routines.
-
-   Copyright (C) Tim Potter, 2002
-   
-   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 02139, USA.
-*/
-
-#include "python/py_spoolss.h"
-#include "python/py_conv.h"
-
-struct pyconv py_PRINTER_INFO_0[] = {
-       { "printer_name", PY_UNISTR, offsetof(PRINTER_INFO_0, printername) },
-       { "server_name", PY_UNISTR, offsetof(PRINTER_INFO_0, servername) },
-
-       { "cjobs", PY_UINT32, offsetof(PRINTER_INFO_0, cjobs) },
-       { "total_jobs", PY_UINT32, offsetof(PRINTER_INFO_0, total_jobs) },
-       { "total_bytes", PY_UINT32, offsetof(PRINTER_INFO_0, total_bytes) },
-
-       { "year", PY_UINT16, offsetof(PRINTER_INFO_0, year) },
-       { "month", PY_UINT16, offsetof(PRINTER_INFO_0, month) },
-       { "day_of_week", PY_UINT16, offsetof(PRINTER_INFO_0, dayofweek) },
-       { "day", PY_UINT16, offsetof(PRINTER_INFO_0, day) },
-       { "hour", PY_UINT16, offsetof(PRINTER_INFO_0, hour) },
-       { "minute", PY_UINT16, offsetof(PRINTER_INFO_0, minute) },
-       { "second", PY_UINT16, offsetof(PRINTER_INFO_0, second) },
-       { "milliseconds", PY_UINT16, offsetof(PRINTER_INFO_0, milliseconds) },
-
-       { "global_counter", PY_UINT32, offsetof(PRINTER_INFO_0, global_counter) },
-       { "total_pages", PY_UINT32, offsetof(PRINTER_INFO_0, total_pages) },
-
-       { "major_version", PY_UINT16, offsetof(PRINTER_INFO_0, major_version) },
-       { "build_version", PY_UINT16, offsetof(PRINTER_INFO_0, build_version) },
-
-       { "unknown7", PY_UINT32, offsetof(PRINTER_INFO_0, unknown7) },
-       { "unknown8", PY_UINT32, offsetof(PRINTER_INFO_0, unknown8) },
-       { "unknown9", PY_UINT32, offsetof(PRINTER_INFO_0, unknown9) },
-       { "session_counter", PY_UINT32, offsetof(PRINTER_INFO_0, session_counter)},
-       { "unknown11", PY_UINT32, offsetof(PRINTER_INFO_0, unknown11) },
-       { "printer_errors", PY_UINT32, offsetof(PRINTER_INFO_0, printer_errors) },
-       { "unknown13", PY_UINT32, offsetof(PRINTER_INFO_0, unknown13) },
-       { "unknown14", PY_UINT32, offsetof(PRINTER_INFO_0, unknown14) },
-       { "unknown15", PY_UINT32, offsetof(PRINTER_INFO_0, unknown15) },
-       { "unknown16", PY_UINT32, offsetof(PRINTER_INFO_0, unknown16) },
-       { "change_id", PY_UINT32, offsetof(PRINTER_INFO_0, change_id) },
-       { "unknown18", PY_UINT32, offsetof(PRINTER_INFO_0, unknown18) },
-       { "status", PY_UINT32, offsetof(PRINTER_INFO_0, status) },
-       { "unknown20", PY_UINT32, offsetof(PRINTER_INFO_0, unknown20) },
-       { "c_setprinter", PY_UINT32, offsetof(PRINTER_INFO_0, c_setprinter) },
-       { "unknown22", PY_UINT32, offsetof(PRINTER_INFO_0, unknown22) },
-       { "unknown23", PY_UINT32, offsetof(PRINTER_INFO_0, unknown23) },
-       { "unknown24", PY_UINT32, offsetof(PRINTER_INFO_0, unknown24) },
-       { "unknown25", PY_UINT32, offsetof(PRINTER_INFO_0, unknown25) },
-       { "unknown26", PY_UINT32, offsetof(PRINTER_INFO_0, unknown26) },
-       { "unknown27", PY_UINT32, offsetof(PRINTER_INFO_0, unknown27) },
-       { "unknown28", PY_UINT32, offsetof(PRINTER_INFO_0, unknown28) },
-       { "unknown29", PY_UINT32, offsetof(PRINTER_INFO_0, unknown29) },
-
-       { NULL }
-};     
-
-struct pyconv py_PRINTER_INFO_1[] = {
-       { "printer_name", PY_UNISTR, offsetof(PRINTER_INFO_1, name) },
-       { "description", PY_UNISTR, offsetof(PRINTER_INFO_1, description) },
-       { "comment", PY_UNISTR, offsetof(PRINTER_INFO_1, comment) },
-       { "flags", PY_UINT32, offsetof(PRINTER_INFO_1, flags) },
-       { NULL }
-};     
-
-struct pyconv py_PRINTER_INFO_2[] = {
-       { "server_name", PY_UNISTR, offsetof(PRINTER_INFO_2, servername) },
-       { "printer_name", PY_UNISTR, offsetof(PRINTER_INFO_2, printername) },
-       { "share_name", PY_UNISTR, offsetof(PRINTER_INFO_2, sharename) },
-       { "port_name", PY_UNISTR, offsetof(PRINTER_INFO_2, portname) },
-       { "driver_name", PY_UNISTR, offsetof(PRINTER_INFO_2, drivername) },
-       { "comment", PY_UNISTR, offsetof(PRINTER_INFO_2, comment) },
-       { "location", PY_UNISTR, offsetof(PRINTER_INFO_2, location) },
-       { "datatype", PY_UNISTR, offsetof(PRINTER_INFO_2, datatype) },
-       { "sepfile", PY_UNISTR, offsetof(PRINTER_INFO_2, sepfile) },
-       { "print_processor", PY_UNISTR, offsetof(PRINTER_INFO_2, printprocessor) },
-       { "parameters", PY_UNISTR, offsetof(PRINTER_INFO_2, parameters) },
-       { "attributes", PY_UINT32, offsetof(PRINTER_INFO_2, attributes) },
-       { "default_priority", PY_UINT32, offsetof(PRINTER_INFO_2, defaultpriority) },
-       { "priority", PY_UINT32, offsetof(PRINTER_INFO_2, priority) },
-       { "start_time", PY_UINT32, offsetof(PRINTER_INFO_2, starttime) },
-       { "until_time", PY_UINT32, offsetof(PRINTER_INFO_2, untiltime) },
-       { "status", PY_UINT32, offsetof(PRINTER_INFO_2, status) },
-       { "cjobs", PY_UINT32, offsetof(PRINTER_INFO_2, cjobs) },
-       { "average_ppm", PY_UINT32, offsetof(PRINTER_INFO_2, averageppm) },
-       { NULL }
-};     
-
-struct pyconv py_PRINTER_INFO_3[] = {
-       { "flags", PY_UINT32, offsetof(PRINTER_INFO_3, flags) },
-       { NULL }
-};     
-
-struct pyconv py_DEVICEMODE[] = {
-       { "device_name", PY_UNISTR, offsetof(DEVICEMODE, devicename) },
-       { "spec_version", PY_UINT16, offsetof(DEVICEMODE, specversion) },
-       { "driver_version", PY_UINT16, offsetof(DEVICEMODE, driverversion) },
-       { "size", PY_UINT16, offsetof(DEVICEMODE, size) },
-       { "fields", PY_UINT16, offsetof(DEVICEMODE, fields) },
-       { "orientation", PY_UINT16, offsetof(DEVICEMODE, orientation) },
-       { "paper_size", PY_UINT16, offsetof(DEVICEMODE, papersize) },
-       { "paper_width", PY_UINT16, offsetof(DEVICEMODE, paperwidth) },
-       { "paper_length", PY_UINT16, offsetof(DEVICEMODE, paperlength) },
-       { "scale", PY_UINT16, offsetof(DEVICEMODE, scale) },
-       { "copies", PY_UINT16, offsetof(DEVICEMODE, copies) },
-       { "default_source", PY_UINT16, offsetof(DEVICEMODE, defaultsource) },
-       { "print_quality", PY_UINT16, offsetof(DEVICEMODE, printquality) },
-       { "color", PY_UINT16, offsetof(DEVICEMODE, color) },
-       { "duplex", PY_UINT16, offsetof(DEVICEMODE, duplex) },
-       { "y_resolution", PY_UINT16, offsetof(DEVICEMODE, yresolution) },
-       { "tt_option", PY_UINT16, offsetof(DEVICEMODE, ttoption) },
-       { "collate", PY_UINT16, offsetof(DEVICEMODE, collate) },
-       { "form_name", PY_UNISTR, offsetof(DEVICEMODE, formname) },
-       { "log_pixels", PY_UINT16, offsetof(DEVICEMODE, logpixels) },
-       { "bits_per_pel", PY_UINT32, offsetof(DEVICEMODE, bitsperpel) },
-       { "pels_width", PY_UINT32, offsetof(DEVICEMODE, pelswidth) },
-       { "pels_height", PY_UINT32, offsetof(DEVICEMODE, pelsheight) },
-       { "display_flags", PY_UINT32, offsetof(DEVICEMODE, displayflags) },
-       { "display_frequency", PY_UINT32, offsetof(DEVICEMODE, displayfrequency) },
-       { "icm_method", PY_UINT32, offsetof(DEVICEMODE, icmmethod) },
-       { "icm_intent", PY_UINT32, offsetof(DEVICEMODE, icmintent) },
-       { "media_type", PY_UINT32, offsetof(DEVICEMODE, mediatype) },
-       { "dither_type", PY_UINT32, offsetof(DEVICEMODE, dithertype) },
-       { "reserved1", PY_UINT32, offsetof(DEVICEMODE, reserved1) },
-       { "reserved2", PY_UINT32, offsetof(DEVICEMODE, reserved2) },
-       { "panning_width", PY_UINT32, offsetof(DEVICEMODE, panningwidth) },
-       { "panning_height", PY_UINT32, offsetof(DEVICEMODE, panningheight) },
-       { NULL }
-};
-
-/* Convert a security descriptor to a Python dict */
-
-BOOL py_from_SID(PyObject **obj, DOM_SID *sid)
-{
-       fstring sidstr;
-
-       if (!sid) {
-               Py_INCREF(Py_None);
-               *obj = Py_None;
-               return True;
-       }
-
-       if (!sid_to_string(sidstr, sid))
-               return False;
-
-       *obj = PyString_FromString(sidstr);
-
-       return True;
-}
-
-BOOL py_to_SID(DOM_SID *sid, PyObject *dict)
-{
-       return False;
-}
-
-BOOL py_from_ACE(PyObject **dict, SEC_ACE *ace)
-{
-       PyObject *obj;
-
-       if (!ace) {
-               Py_INCREF(Py_None);
-               *dict = Py_None;
-               return True;
-       }
-
-       *dict = PyDict_New();
-
-       PyDict_SetItemString(*dict, "type", PyInt_FromLong(ace->type));
-       PyDict_SetItemString(*dict, "flags", PyInt_FromLong(ace->flags));
-       PyDict_SetItemString(*dict, "mask", PyInt_FromLong(ace->info.mask));
-
-       if (py_from_SID(&obj, &ace->trustee))
-               PyDict_SetItemString(*dict, "trustee", obj);
-
-       return True;
-}
-
-BOOL py_to_ACE(SEC_ACE *ace, PyObject *dict)
-{
-       return False;
-}
-
-BOOL py_from_ACL(PyObject **dict, SEC_ACL *acl)
-{
-       PyObject *ace_list;
-       int i;
-
-       if (!acl) {
-               Py_INCREF(Py_None);
-               *dict = Py_None;
-               return True;
-       }
-
-       *dict = PyDict_New();
-
-       PyDict_SetItemString(*dict, "revision", PyInt_FromLong(acl->revision));
-
-       ace_list = PyList_New(acl->num_aces);
-
-       for (i = 0; i < acl->num_aces; i++) {
-               PyObject *obj;
-
-               if (py_from_ACE(&obj, &acl->ace[i]))
-                       PyList_SetItem(ace_list, i, obj);
-       }
-
-       PyDict_SetItemString(*dict, "ace_list", ace_list);
-
-       return True;
-}
-
-BOOL py_to_ACL(SEC_ACL *acl, PyObject *dict)
-{
-       return False;
-}
-
-BOOL py_from_SECDESC(PyObject **dict, SEC_DESC *sd)
-{
-       PyObject *obj;
-
-       *dict = PyDict_New();
-
-       PyDict_SetItemString(*dict, "revision", PyInt_FromLong(sd->revision));
-       PyDict_SetItemString(*dict, "type", PyInt_FromLong(sd->type));
-
-       if (py_from_SID(&obj, sd->owner_sid))
-               PyDict_SetItemString(*dict, "owner_sid", obj);
-
-       if (py_from_SID(&obj, sd->grp_sid))
-               PyDict_SetItemString(*dict, "group_sid", obj);
-
-       if (py_from_ACL(&obj, sd->dacl))
-               PyDict_SetItemString(*dict, "dacl", obj);
-
-       if (py_from_ACL(&obj, sd->sacl))
-               PyDict_SetItemString(*dict, "sacl", obj);
-
-       return True;
-}
-
-BOOL py_to_SECDESC(SEC_DESC *sd, PyObject *dict)
-{
-       return False;
-}
-
-/*
- * Convert between DEVICEMODE and Python
- */
-
-BOOL py_from_DEVICEMODE(PyObject **dict, DEVICEMODE *devmode)
-{
-       *dict = from_struct(devmode, py_DEVICEMODE);
-
-       PyDict_SetItemString(*dict, "private",
-                            PyString_FromStringAndSize(
-                                    devmode->private, devmode->driverextra));
-
-       return True;
-}
-
-BOOL py_to_DEVICEMODE(DEVICEMODE *devmode, PyObject *dict)
-{
-       PyObject *obj;
-
-       to_struct(devmode, dict, py_DEVICEMODE);
-
-       obj = PyDict_GetItemString(dict, "private");
-
-       if (!obj)
-               return False;
-
-       devmode->private = PyString_AsString(obj);
-       devmode->driverextra = PyString_Size(obj);
-
-       return True;
-}
-
-/*
- * Convert between PRINTER_INFO_0 and Python 
- */
-
-BOOL py_from_PRINTER_INFO_0(PyObject **dict, PRINTER_INFO_0 *info)
-{
-       *dict = from_struct(info, py_PRINTER_INFO_0);
-       return True;
-}
-
-BOOL py_to_PRINTER_INFO_0(PRINTER_INFO_0 *info, PyObject *dict)
-{
-       return False;
-}
-
-/*
- * Convert between PRINTER_INFO_1 and Python 
- */
-
-BOOL py_from_PRINTER_INFO_1(PyObject **dict, PRINTER_INFO_1 *info)
-{
-       *dict = from_struct(info, py_PRINTER_INFO_1);
-       return True;
-}
-
-BOOL py_to_PRINTER_INFO_1(PRINTER_INFO_1 *info, PyObject *dict)
-{
-       return False;
-}
-
-/*
- * Convert between PRINTER_INFO_2 and Python 
- */
-
-BOOL py_from_PRINTER_INFO_2(PyObject **dict, PRINTER_INFO_2 *info)
-{
-       PyObject *obj;
-
-       *dict = from_struct(info, py_PRINTER_INFO_2);
-
-       if (py_from_SECDESC(&obj, info->secdesc))
-               PyDict_SetItemString(*dict, "security_descriptor", obj);
-
-       if (py_from_DEVICEMODE(&obj, info->devmode))
-               PyDict_SetItemString(*dict, "device_mode", obj);
-
-       return True;
-}
-
-BOOL py_to_PRINTER_INFO_2(PRINTER_INFO_2 *info, PyObject *dict)
-{
-       return False;
-}
-
-/*
- * Convert between PRINTER_INFO_1 and Python 
- */
-
-BOOL py_from_PRINTER_INFO_3(PyObject **dict, PRINTER_INFO_3 *info)
-{
-       PyObject *obj;
-
-       *dict = from_struct(info, py_PRINTER_INFO_3);
-
-       if (py_from_SECDESC(&obj, info->secdesc))
-               PyDict_SetItemString(*dict, "security_descriptor", obj);
-
-       return True;
-}
-
-BOOL py_to_PRINTER_INFO_3(PRINTER_INFO_3 *info, PyObject *dict)
-{
-       return False;
-}
diff --git a/source3/python/py_spoolss_proto.h b/source3/python/py_spoolss_proto.h
deleted file mode 100644 (file)
index 6788dcc..0000000
+++ /dev/null
@@ -1,91 +0,0 @@
-#ifndef _PY_SPOOLSS_PROTO_H
-#define _PY_SPOOLSS_PROTO_H
-
-/* This file is automatically generated with "make proto". DO NOT EDIT */
-
-
-/* The following definitions come from python/py_spoolss.c  */
-
-struct cli_state *open_pipe_creds(char *system_name, PyObject *creds, 
-                                 cli_pipe_fn *connect_fn,
-                                 struct cli_state *cli);
-PyObject *new_policy_hnd_object(struct cli_state *cli, TALLOC_CTX *mem_ctx, 
-                               POLICY_HND *pol);
-void initspoolss(void);
-
-/* The following definitions come from python/py_spoolss_drivers.c  */
-
-PyObject *spoolss_enumprinterdrivers(PyObject *self, PyObject *args,
-                                    PyObject *kw);
-PyObject *spoolss_getprinterdriver(PyObject *self, PyObject *args,
-                                  PyObject *kw);
-PyObject *spoolss_getprinterdriverdir(PyObject *self, PyObject *args, 
-                                     PyObject *kw);
-
-/* The following definitions come from python/py_spoolss_drivers_conv.c  */
-
-BOOL py_from_DRIVER_INFO_1(PyObject **dict, DRIVER_INFO_1 *info);
-BOOL py_to_DRIVER_INFO_1(DRIVER_INFO_1 *info, PyObject *dict);
-BOOL py_from_DRIVER_INFO_2(PyObject **dict, DRIVER_INFO_2 *info);
-BOOL py_to_DRIVER_INFO_2(DRIVER_INFO_2 *info, PyObject *dict);
-BOOL py_from_DRIVER_INFO_3(PyObject **dict, DRIVER_INFO_3 *info);
-BOOL py_to_DRIVER_INFO_3(DRIVER_INFO_3 *info, PyObject *dict);
-BOOL py_from_DRIVER_INFO_6(PyObject **dict, DRIVER_INFO_6 *info);
-BOOL py_to_DRIVER_INFO_6(DRIVER_INFO_6 *info, PyObject *dict);
-BOOL py_from_DRIVER_DIRECTORY_1(PyObject **dict, DRIVER_DIRECTORY_1 *info);
-BOOL py_to_DRIVER_DIRECTORY_1(DRIVER_DIRECTORY_1 *info, PyObject *dict);
-
-/* The following definitions come from python/py_spoolss_forms.c  */
-
-PyObject *spoolss_addform(PyObject *self, PyObject *args, PyObject *kw);
-PyObject *spoolss_getform(PyObject *self, PyObject *args, PyObject *kw);
-PyObject *spoolss_setform(PyObject *self, PyObject *args, PyObject *kw);
-PyObject *spoolss_deleteform(PyObject *self, PyObject *args, PyObject *kw);
-PyObject *spoolss_enumforms(PyObject *self, PyObject *args, PyObject *kw);
-
-/* The following definitions come from python/py_spoolss_forms_conv.c  */
-
-BOOL py_from_FORM_1(PyObject **dict, FORM_1 *form);
-BOOL py_to_FORM(FORM *form, PyObject *dict);
-
-/* The following definitions come from python/py_spoolss_ports.c  */
-
-PyObject *spoolss_enumports(PyObject *self, PyObject *args, PyObject *kw);
-
-/* The following definitions come from python/py_spoolss_ports_conv.c  */
-
-BOOL py_from_PORT_INFO_1(PyObject **dict, PORT_INFO_1 *info);
-BOOL py_to_PORT_INFO_1(PORT_INFO_1 *info, PyObject *dict);
-BOOL py_from_PORT_INFO_2(PyObject **dict, PORT_INFO_2 *info);
-BOOL py_to_PORT_INFO_2(PORT_INFO_2 *info, PyObject *dict);
-
-/* The following definitions come from python/py_spoolss_printers.c  */
-
-PyObject *spoolss_openprinter(PyObject *self, PyObject *args, PyObject *kw);
-PyObject *spoolss_closeprinter(PyObject *self, PyObject *args);
-PyObject *spoolss_getprinter(PyObject *self, PyObject *args, PyObject *kw);
-PyObject *spoolss_setprinter(PyObject *self, PyObject *args, PyObject *kw);
-PyObject *spoolss_enumprinters(PyObject *self, PyObject *args, PyObject *kw);
-
-/* The following definitions come from python/py_spoolss_printers_conv.c  */
-
-BOOL py_from_SID(PyObject **obj, DOM_SID *sid);
-BOOL py_to_SID(DOM_SID *sid, PyObject *dict);
-BOOL py_from_ACE(PyObject **dict, SEC_ACE *ace);
-BOOL py_to_ACE(SEC_ACE *ace, PyObject *dict);
-BOOL py_from_ACL(PyObject **dict, SEC_ACL *acl);
-BOOL py_to_ACL(SEC_ACL *acl, PyObject *dict);
-BOOL py_from_SECDESC(PyObject **dict, SEC_DESC *sd);
-BOOL py_to_SECDESC(SEC_DESC *sd, PyObject *dict);
-BOOL py_from_DEVICEMODE(PyObject **dict, DEVICEMODE *devmode);
-BOOL py_to_DEVICEMODE(DEVICEMODE *devmode, PyObject *dict);
-BOOL py_from_PRINTER_INFO_0(PyObject **dict, PRINTER_INFO_0 *info);
-BOOL py_to_PRINTER_INFO_0(PRINTER_INFO_0 *info, PyObject *dict);
-BOOL py_from_PRINTER_INFO_1(PyObject **dict, PRINTER_INFO_1 *info);
-BOOL py_to_PRINTER_INFO_1(PRINTER_INFO_1 *info, PyObject *dict);
-BOOL py_from_PRINTER_INFO_2(PyObject **dict, PRINTER_INFO_2 *info);
-BOOL py_to_PRINTER_INFO_2(PRINTER_INFO_2 *info, PyObject *dict);
-BOOL py_from_PRINTER_INFO_3(PyObject **dict, PRINTER_INFO_3 *info);
-BOOL py_to_PRINTER_INFO_3(PRINTER_INFO_3 *info, PyObject *dict);
-
-#endif /*  _PY_SPOOLSS_PROTO_H  */
diff --git a/source3/python/py_winbind.c b/source3/python/py_winbind.c
deleted file mode 100644 (file)
index 657e982..0000000
+++ /dev/null
@@ -1,651 +0,0 @@
-/* 
-   Unix SMB/CIFS implementation.
-
-   Python wrapper for winbind client functions.
-
-   Copyright (C) Tim Potter      2002
-   
-   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 02139, USA.
-*/
-
-#include "includes.h"
-#include "Python.h"
-
-#include "py_common.h"
-
-/* 
- * Exceptions raised by this module 
- */
-
-PyObject *winbind_error;       /* A winbind call returned WINBINDD_ERROR */
-
-/* Prototypes from common.h */
-
-NSS_STATUS winbindd_request(int req_type, 
-                           struct winbindd_request *request,
-                           struct winbindd_response *response);
-
-/*
- * Name <-> SID conversion
- */
-
-/* Convert a name to a sid */
-
-static PyObject *py_name_to_sid(PyObject *self, PyObject *args)
-
-{
-       struct winbindd_request request;
-       struct winbindd_response response;
-       PyObject *result;
-       char *name, *p, *sep;
-
-       if (!PyArg_ParseTuple(args, "s", &name))
-               return NULL;
-
-       ZERO_STRUCT(request);
-       ZERO_STRUCT(response);
-
-       sep = lp_winbind_separator();
-
-       if ((p = strchr(name, sep[0]))) {
-               *p = 0;
-               fstrcpy(request.data.name.dom_name, name);
-               fstrcpy(request.data.name.name, p + 1);
-       } else {
-               fstrcpy(request.data.name.dom_name, lp_workgroup());
-               fstrcpy(request.data.name.name, name);
-       }
-
-       if (winbindd_request(WINBINDD_LOOKUPNAME, &request, &response)  
-           != NSS_STATUS_SUCCESS) {
-               PyErr_SetString(winbind_error, "lookup failed");
-               return NULL;
-       }
-
-       result = PyString_FromString(response.data.sid.sid);
-
-       return result;
-}
-
-/* Convert a sid to a name */
-
-static PyObject *py_sid_to_name(PyObject *self, PyObject *args)
-{
-       struct winbindd_request request;
-       struct winbindd_response response;
-       PyObject *result;
-       char *sid, *name;
-
-       if (!PyArg_ParseTuple(args, "s", &sid))
-               return NULL;
-
-       ZERO_STRUCT(request);
-       ZERO_STRUCT(response);
-
-       fstrcpy(request.data.sid, sid);
-
-       if (winbindd_request(WINBINDD_LOOKUPSID, &request, &response)  
-           != NSS_STATUS_SUCCESS) {
-               PyErr_SetString(winbind_error, "lookup failed");
-               return NULL;
-       }
-
-       asprintf(&name, "%s%s%s", response.data.name.dom_name,
-                lp_winbind_separator(), response.data.name.name);
-
-       result = PyString_FromString(name);
-
-       free(name);
-
-       return result;
-}
-
-/*
- * Enumerate users/groups
- */
-
-/* Enumerate domain users */
-
-static PyObject *py_enum_domain_users(PyObject *self, PyObject *args)
-{
-       struct winbindd_response response;
-       PyObject *result;
-
-       if (!PyArg_ParseTuple(args, ""))
-               return NULL;
-
-       ZERO_STRUCT(response);
-
-       if (winbindd_request(WINBINDD_LIST_USERS, NULL, &response) 
-           != NSS_STATUS_SUCCESS) {
-               PyErr_SetString(winbind_error, "lookup failed");
-               return NULL;            
-       }
-
-       result = PyList_New(0);
-
-       if (response.extra_data) {
-               char *extra_data = response.extra_data;
-               fstring name;
-
-               while (next_token(&extra_data, name, ",", sizeof(fstring)))
-                       PyList_Append(result, PyString_FromString(name));
-       }
-
-       return result;
-}
-
-/* Enumerate domain groups */
-
-static PyObject *py_enum_domain_groups(PyObject *self, PyObject *args)
-{
-       struct winbindd_response response;
-       PyObject *result = NULL;
-
-       if (!PyArg_ParseTuple(args, ""))
-               return NULL;
-
-       ZERO_STRUCT(response);
-
-       if (winbindd_request(WINBINDD_LIST_GROUPS, NULL, &response) 
-           != NSS_STATUS_SUCCESS) {
-               PyErr_SetString(winbind_error, "lookup failed");
-               return NULL;            
-       }
-
-       result = PyList_New(0);
-
-       if (response.extra_data) {
-               char *extra_data = response.extra_data;
-               fstring name;
-
-               while (next_token(&extra_data, name, ",", sizeof(fstring)))
-                       PyList_Append(result, PyString_FromString(name));
-       }
-
-       return result;
-}
-
-/*
- * Miscellaneous domain related
- */
-
-/* Enumerate domain groups */
-
-static PyObject *py_enum_trust_dom(PyObject *self, PyObject *args)
-{
-       struct winbindd_response response;
-       PyObject *result = NULL;
-
-       if (!PyArg_ParseTuple(args, ""))
-               return NULL;
-
-       ZERO_STRUCT(response);
-
-       if (winbindd_request(WINBINDD_LIST_TRUSTDOM, NULL, &response) 
-           != NSS_STATUS_SUCCESS) {
-               PyErr_SetString(winbind_error, "lookup failed");
-               return NULL;            
-       }
-
-       result = PyList_New(0);
-
-       if (response.extra_data) {
-               char *extra_data = response.extra_data;
-               fstring name;
-
-               while (next_token(&extra_data, name, ",", sizeof(fstring)))
-                       PyList_Append(result, PyString_FromString(name));
-       }
-
-       return result;
-}
-
-/* Check machine account password */
-
-static PyObject *py_check_secret(PyObject *self, PyObject *args)
-{
-       struct winbindd_response response;
-
-       if (!PyArg_ParseTuple(args, ""))
-               return NULL;
-
-       ZERO_STRUCT(response);
-
-       if (winbindd_request(WINBINDD_CHECK_MACHACC, NULL, &response) 
-           != NSS_STATUS_SUCCESS) {
-               PyErr_SetString(winbind_error, "lookup failed");
-               return NULL;            
-       }
-
-       return PyInt_FromLong(response.data.num_entries);
-}
-
-/*
- * Return a dictionary consisting of all the winbind related smb.conf
- * parameters.  This is stored in the module object.
- */
-
-static PyObject *py_config_dict(void)
-{
-       PyObject *result;
-       uid_t ulow, uhi;
-       gid_t glow, ghi;
-       
-       if (!(result = PyDict_New()))
-               return NULL;
-
-       /* Various string parameters */
-
-       PyDict_SetItemString(result, "workgroup", 
-                            PyString_FromString(lp_workgroup()));
-
-       PyDict_SetItemString(result, "separator", 
-                            PyString_FromString(lp_winbind_separator()));
-
-       PyDict_SetItemString(result, "template_homedir", 
-                            PyString_FromString(lp_template_homedir()));
-
-       PyDict_SetItemString(result, "template_shell", 
-                            PyString_FromString(lp_template_shell()));
-
-       /* Winbind uid/gid range */
-
-       if (lp_winbind_uid(&ulow, &uhi)) {
-               PyDict_SetItemString(result, "uid_low", PyInt_FromLong(ulow));
-               PyDict_SetItemString(result, "uid_high", PyInt_FromLong(uhi));
-       }
-
-       if (lp_winbind_gid(&glow, &ghi)) {
-               PyDict_SetItemString(result, "gid_low", PyInt_FromLong(glow));
-               PyDict_SetItemString(result, "gid_high", PyInt_FromLong(ghi));
-       }
-
-       return result;
-}
-
-/*
- * ID mapping
- */
-
-/* Convert a uid to a SID */
-
-static PyObject *py_uid_to_sid(PyObject *self, PyObject *args)
-{
-       struct winbindd_request request;
-       struct winbindd_response response;
-       int id;
-
-       if (!PyArg_ParseTuple(args, "i", &id))
-               return NULL;
-
-       ZERO_STRUCT(request);
-       ZERO_STRUCT(response);
-
-       request.data.uid = id;
-
-       if (winbindd_request(WINBINDD_UID_TO_SID, &request, &response) 
-           != NSS_STATUS_SUCCESS) {
-               PyErr_SetString(winbind_error, "lookup failed");
-               return NULL;            
-       }
-
-       return PyString_FromString(response.data.sid.sid);
-}
-
-/* Convert a gid to a SID */
-
-static PyObject *py_gid_to_sid(PyObject *self, PyObject *args)
-{
-       struct winbindd_request request;
-       struct winbindd_response response;
-       int id;
-
-       if (!PyArg_ParseTuple(args, "i", &id))
-               return NULL;
-
-       ZERO_STRUCT(request);
-       ZERO_STRUCT(response);
-
-       request.data.gid = id;
-
-       if (winbindd_request(WINBINDD_GID_TO_SID, &request, &response) 
-           != NSS_STATUS_SUCCESS) {
-               PyErr_SetString(winbind_error, "lookup failed");
-               return NULL;            
-       }
-
-       return PyString_FromString(response.data.sid.sid);
-}
-
-/* Convert a sid to a uid */
-
-static PyObject *py_sid_to_uid(PyObject *self, PyObject *args)
-{
-       struct winbindd_request request;
-       struct winbindd_response response;
-       char *sid;
-
-       if (!PyArg_ParseTuple(args, "s", &sid))
-               return NULL;
-
-       ZERO_STRUCT(request);
-       ZERO_STRUCT(response);
-
-       fstrcpy(request.data.sid, sid);
-
-       if (winbindd_request(WINBINDD_SID_TO_UID, &request, &response) 
-           != NSS_STATUS_SUCCESS) {
-               PyErr_SetString(winbind_error, "lookup failed");
-               return NULL;            
-       }
-
-       return PyInt_FromLong(response.data.uid);
-}
-
-/* Convert a sid to a gid */
-
-static PyObject *py_sid_to_gid(PyObject *self, PyObject *args)
-{
-       struct winbindd_request request;
-       struct winbindd_response response;
-       char *sid;
-
-       if (!PyArg_ParseTuple(args, "s", &sid))
-               return NULL;
-
-       ZERO_STRUCT(request);
-       ZERO_STRUCT(response);
-
-       fstrcpy(request.data.sid, sid);
-
-       if (winbindd_request(WINBINDD_SID_TO_GID, &request, &response) 
-           != NSS_STATUS_SUCCESS) {
-               PyErr_SetString(winbind_error, "lookup failed");
-               return NULL;            
-       }
-       
-       return PyInt_FromLong(response.data.gid);
-}
-
-/*
- * PAM authentication functions
- */
-
-/* Plaintext authentication */
-
-static PyObject *py_auth_plaintext(PyObject *self, PyObject *args)
-{
-       struct winbindd_request request;
-       struct winbindd_response response;
-       char *username, *password;
-
-       if (!PyArg_ParseTuple(args, "ss", &username, &password))
-               return NULL;
-
-       ZERO_STRUCT(request);
-       ZERO_STRUCT(response);
-
-       fstrcpy(request.data.auth.user, username);
-       fstrcpy(request.data.auth.pass, password);
-
-       if (winbindd_request(WINBINDD_PAM_AUTH, &request, &response) 
-           != NSS_STATUS_SUCCESS) {
-               PyErr_SetString(winbind_error, "lookup failed");
-               return NULL;            
-       }
-       
-       return PyInt_FromLong(response.data.auth.nt_status);
-}
-
-/* Challenge/response authentication */
-
-static PyObject *py_auth_crap(PyObject *self, PyObject *args)
-{
-       struct winbindd_request request;
-       struct winbindd_response response;
-       char *username, *password;
-
-       if (!PyArg_ParseTuple(args, "ss", &username, &password))
-               return NULL;
-
-       ZERO_STRUCT(request);
-       ZERO_STRUCT(response);
-
-       fstrcpy(request.data.auth_crap.user, username);
-
-       generate_random_buffer(request.data.auth_crap.chal, 8, False);
-        
-        SMBencrypt((uchar *)password, request.data.auth_crap.chal, 
-                   (uchar *)request.data.auth_crap.lm_resp);
-        SMBNTencrypt((uchar *)password, request.data.auth_crap.chal,
-                     (uchar *)request.data.auth_crap.nt_resp);
-
-        request.data.auth_crap.lm_resp_len = 24;
-        request.data.auth_crap.nt_resp_len = 24;
-
-       if (winbindd_request(WINBINDD_PAM_AUTH_CRAP, &request, &response) 
-           != NSS_STATUS_SUCCESS) {
-               PyErr_SetString(winbind_error, "lookup failed");
-               return NULL;            
-       }
-       
-       return PyInt_FromLong(response.data.auth.nt_status);
-}
-
-/*
- * Method dispatch table
- */
-
-static PyMethodDef winbind_methods[] = {
-
-       /* Name <-> SID conversion */
-
-       { "name_to_sid", py_name_to_sid, METH_VARARGS,
-         "name_to_sid(s) -> string
-
-Return the SID for a name.
-
-Example:
-
->>> winbind.name_to_sid('FOO/Administrator')
-'S-1-5-21-406022937-1377575209-526660263-500' " },
-
-       { "sid_to_name", py_sid_to_name, METH_VARARGS,
-         "sid_to_name(s) -> string
-
-Return the name for a SID.
-
-Example:
-
->>> import winbind
->>> winbind.sid_to_name('S-1-5-21-406022937-1377575209-526660263-500')
-'FOO/Administrator' " },
-
-       /* Enumerate users/groups */
-
-       { "enum_domain_users", py_enum_domain_users, METH_VARARGS,
-         "enum_domain_users() -> list of strings
-
-Return a list of domain users.
-
-Example:
-
->>> winbind.enum_domain_users()
-['FOO/Administrator', 'FOO/anna', 'FOO/Anne Elk', 'FOO/build', 
-'FOO/foo', 'FOO/foo2', 'FOO/foo3', 'FOO/Guest', 'FOO/user1', 
-'FOO/whoops-ptang'] " },
-
-       { "enum_domain_groups", py_enum_domain_groups, METH_VARARGS,
-         "enum_domain_groups() -> list of strings
-
-Return a list of domain groups.
-
-Example:
-
->>> winbind.enum_domain_groups()
-['FOO/cows', 'FOO/Domain Admins', 'FOO/Domain Guests', 
-'FOO/Domain Users'] " },
-
-       /* ID mapping */
-
-       { "uid_to_sid", py_uid_to_sid, METH_VARARGS,
-         "uid_to_sid(int) -> string
-
-Return the SID for a UNIX uid.
-
-Example:
-
->>> winbind.uid_to_sid(10000)   
-'S-1-5-21-406022937-1377575209-526660263-500' " },
-
-       { "gid_to_sid", py_gid_to_sid, METH_VARARGS,
-         "gid_to_sid(int) -> string
-
-Return the UNIX gid for a SID.
-
-Example:
-
->>> winbind.gid_to_sid(10001)
-'S-1-5-21-406022937-1377575209-526660263-512' " },
-
-       { "sid_to_uid", py_sid_to_uid, METH_VARARGS,
-         "sid_to_uid(string) -> int
-
-Return the UNIX uid for a SID.
-
-Example:
-
->>> winbind.sid_to_uid('S-1-5-21-406022937-1377575209-526660263-500')
-10000 " },
-
-       { "sid_to_gid", py_sid_to_gid, METH_VARARGS,
-         "sid_to_gid(string) -> int
-
-Return the UNIX gid corresponding to a SID.
-
-Example:
-
->>> winbind.sid_to_gid('S-1-5-21-406022937-1377575209-526660263-512')
-10001 " },
-
-       /* Miscellaneous */
-
-       { "check_secret", py_check_secret, METH_VARARGS,
-         "check_secret() -> int
-
-Check the machine trust account password.  The NT status is returned
-with zero indicating success. " },
-
-       { "enum_trust_dom", py_enum_trust_dom, METH_VARARGS,
-         "enum_trust_dom() -> list of strings
-
-Return a list of trusted domains.  The domain the server is a member 
-of is not included.
-
-Example:
-
->>> winbind.enum_trust_dom()
-['NPSD-TEST2', 'SP2NDOM'] " },
-
-       /* PAM authorisation functions */
-
-       { "auth_plaintext", py_auth_plaintext, METH_VARARGS,
-         "auth_plaintext(s, s) -> int
-
-Authenticate a username and password using plaintext authentication.
-The NT status code is returned with zero indicating success." },
-
-       { "auth_crap", py_auth_crap, METH_VARARGS,
-         "auth_crap(s, s) -> int
-
-Authenticate a username and password using the challenge/response
-protocol.  The NT status code is returned with zero indicating
-success." },
-
-       { NULL }
-};
-
-static struct winbind_const {
-       char *name;
-       uint32 value;
-       char *docstring;
-} winbind_const_vals[] = {
-
-       /* Well known RIDs */
-       
-       { "DOMAIN_USER_RID_ADMIN", DOMAIN_USER_RID_ADMIN, 
-         "Well-known RID for Administrator user" },
-
-       { "DOMAIN_USER_RID_GUEST", DOMAIN_USER_RID_GUEST,
-         "Well-known RID for Guest user" },
-
-       { "DOMAIN_GROUP_RID_ADMINS", DOMAIN_GROUP_RID_ADMINS,
-         "Well-known RID for Domain Admins group" },
-
-       { "DOMAIN_GROUP_RID_USERS", DOMAIN_GROUP_RID_USERS,
-         "Well-known RID for Domain Users group" },
-
-       { "DOMAIN_GROUP_RID_GUESTS", DOMAIN_GROUP_RID_GUESTS,
-         "Well-known RID for Domain Guests group" }, 
-       
-       { NULL }
-};
-
-static void const_init(PyObject *dict)
-{
-       struct winbind_const *tmp;
-       PyObject *obj;
-
-       for (tmp = winbind_const_vals; tmp->name; tmp++) {
-               obj = PyInt_FromLong(tmp->value);
-               PyDict_SetItemString(dict, tmp->name, obj);
-               Py_DECREF(obj);
-       }
-}
-
-/*
- * Module initialisation 
- */
-
-static char winbind_module__doc__[] =
-"A python extension to winbind client functions.";
-
-void initwinbind(void)
-{
-       PyObject *module, *dict;
-
-       /* Initialise module */
-
-        module = Py_InitModule3("winbind", winbind_methods,
-                               winbind_module__doc__);
-
-       dict = PyModule_GetDict(module);
-
-       winbind_error = PyErr_NewException("winbind.error", NULL, NULL);
-       PyDict_SetItemString(dict, "error", winbind_error);
-
-       /* Do samba initialisation */
-
-       py_samba_init();
-
-       /* Initialise constants */
-
-       const_init(dict);
-
-       /* Insert configuration dictionary */
-
-       PyDict_SetItemString(dict, "config", py_config_dict());
-}
diff --git a/source3/python/samba-head.patch b/source3/python/samba-head.patch
deleted file mode 100644 (file)
index 2e0863e..0000000
+++ /dev/null
@@ -1,53 +0,0 @@
-Index: Makefile.in
-===================================================================
-RCS file: /data/cvs/samba/source/Makefile.in,v
-retrieving revision 1.465
-diff -u -r1.465 Makefile.in
---- Makefile.in        2002/04/04 22:58:56     1.465
-+++ Makefile.in        2002/04/05 05:48:51
-@@ -785,6 +785,29 @@
-       -$(INSTALLCMD) -d ${prefix}/include
-       -$(INSTALLCMD) include/libsmbclient.h ${prefix}/include
-+# Python extensions
-+
-+PYTHON_OBJS = $(LIB_OBJ) $(LIBSMB_OBJ) $(RPC_PARSE_OBJ) $(UBIQX_OBJ) \
-+      $(PARAM_OBJ) $(LIBMSRPC_OBJ) $(PASSDB_OBJ) $(GROUPDB_OBJ)
-+
-+PY_SPOOLSS_PROTO_OBJ = python/py_spoolss.o \
-+              python/py_spoolss_printers.o python/py_spoolss_printers_conv.o\
-+              python/py_spoolss_forms.o python/py_spoolss_forms_conv.o \
-+              python/py_spoolss_ports.o python/py_spoolss_ports_conv.o \
-+              python/py_spoolss_drivers.o python/py_spoolss_drivers_conv.o \
-+
-+python_proto: python_spoolss_proto
-+
-+python_spoolss_proto:
-+      @cd $(srcdir) && $(SHELL) script/mkproto.sh $(AWK) \
-+              -h _PY_SPOOLSS_PROTO_H python/py_spoolss_proto.h \
-+              $(PY_SPOOLSS_PROTO_OBJ)
-+
-+python_ext: $(PYTHON_OBJS)
-+      @echo python python/setup.py build
-+      @PYTHON_OBJS="$(PYTHON_OBJS)" PYTHON_CFLAGS="$(CFLAGS) $(CPPFLAGS)" \
-+              python python/setup.py build
-+
- # revert to the previously installed version
- revert:
-       @$(SHELL) $(srcdir)/script/revert.sh $(SBINDIR) $(SPROGS) 
-Index: configure.in
-===================================================================
-RCS file: /data/cvs/samba/source/configure.in,v
-retrieving revision 1.298
-diff -u -r1.298 configure.in
---- configure.in       2002/04/04 05:47:41     1.298
-+++ configure.in       2002/04/05 05:48:52
-@@ -2695,7 +2695,7 @@
- builddir=`pwd`
- AC_SUBST(builddir)
--AC_OUTPUT(include/stamp-h Makefile)
-+AC_OUTPUT(include/stamp-h Makefile python/setup.py)
- #################################################
- # Print very concise instructions on building/use
diff --git a/source3/python/setup.py.in b/source3/python/setup.py.in
deleted file mode 100755 (executable)
index 37bcd84..0000000
+++ /dev/null
@@ -1,122 +0,0 @@
-# -*- mode: python -*-
-#
-# Unix SMB/CIFS implementation.
-# Module packaging setup for Samba python extensions
-#
-# Copyright (C) Tim Potter, 2002
-#
-# 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 02139, USA.
-#
-
-from distutils.core import setup
-from distutils.extension import Extension
-
-import sys, string, os
-
-# The Makefile passes in environment variable $PYTHON_OBJ as being the
-# list of Samba objects.  This kind of goes against the distutils.cmd
-# method of adding setup commands and will also confuse people who are
-# familiar with the python Distutils module.
-
-samba_objs = ""
-if os.environ.has_key("PYTHON_OBJS"):
-    samba_objs = os.environ.get("PYTHON_OBJS")
-
-samba_cflags = ""
-if os.environ.has_key("PYTHON_CFLAGS"):
-    samba_cflags = os.environ.get("PYTHON_CFLAGS")
-
-samba_srcdir = ""
-if os.environ.has_key("SRCDIR"):
-    samba_srcdir = os.environ.get("SRCDIR")
-
-# These variables are filled in by configure
-
-samba_libs = "@LIBS@"
-
-# Convert libs and objs from space separated strings to lists of strings
-# for distutils to digest.  Split "-l" prefix off library list.
-
-obj_list = string.split(samba_objs)
-
-lib_list = []
-
-for lib in string.split(samba_libs):
-    lib_list.append(string.replace(lib, "-l", ""))
-
-flags_list = string.split(samba_cflags)
-
-# Invoke distutils.setup
-
-setup(
-
-    # Overview information
-    
-    name = "Samba Python Extensions",
-    version = "0.1",
-    author = "Tim Potter",
-    author_email = "tpot@samba.org",
-    license = "GPL",
-
-    # Build info
-    
-    include_dirs = [samba_srcdir + '.', samba_srcdir + "include",
-                    samba_srcdir + "ubiqx", samba_srcdir + "smbwrapper",
-                    samba_srcdir + "popt", "/usr/kerberos/include",
-                    "/usr/local/include"],
-    
-    # Module list
-    
-    ext_modules = [
-
-    # SPOOLSS pipe module
-
-    Extension(name = "spoolss",
-              sources = [samba_srcdir + "python/py_spoolss.c",
-                         samba_srcdir + "python/py_common.c",
-                         samba_srcdir + "python/py_conv.c",
-                         samba_srcdir + "python/py_spoolss_forms.c",
-                         samba_srcdir + "python/py_spoolss_forms_conv.c",
-                         samba_srcdir + "python/py_spoolss_drivers.c",
-                         samba_srcdir + "python/py_spoolss_drivers_conv.c",
-                         samba_srcdir + "python/py_spoolss_printers.c",
-                         samba_srcdir + "python/py_spoolss_printers_conv.c",
-                         samba_srcdir + "python/py_spoolss_ports.c",
-                         samba_srcdir + "python/py_spoolss_ports_conv.c",
-                         ],
-              libraries = lib_list,
-              library_dirs = ["/usr/kerberos/lib"],
-              extra_objects = obj_list),
-
-    # LSA pipe module
-
-    Extension(name = "lsa",
-              sources = [samba_srcdir + "python/py_lsa.c",
-                         samba_srcdir + "python/py_common.c"],
-              libraries = lib_list,
-              library_dirs = ["/usr/kerberos/lib"],
-              extra_objects = obj_list),
-
-    # winbind client module
-
-    Extension(name = "winbind",
-              sources = [samba_srcdir + "python/py_winbind.c",
-                         samba_srcdir + "python/py_common.c"],
-              libraries = lib_list,
-              library_dirs = ["/usr/kerberos/lib"],
-              extra_objects = obj_list,
-              extra_compile_args = flags_list),
-    ]
-)
index 106d7c19234486c76520db7f0e1fa6af3ec8fe18..c83f6b3d8db57f1becdecf189fbd84c209ed0599 100644 (file)
@@ -1443,6 +1443,11 @@ static BOOL get_user_info_10(SAM_USER_INFO_10 *id10, uint32 user_rid)
        SAM_ACCOUNT *smbpass=NULL;
        BOOL ret;
 
+       if (!pdb_rid_is_user(user_rid)) {
+               DEBUG(4,("RID 0x%x is not a user RID\n", user_rid));
+               return False;
+       }
+
        pdb_init_sam(&smbpass);
 
        become_root();
@@ -1519,6 +1524,11 @@ static BOOL get_user_info_20(SAM_USER_INFO_20 *id20, uint32 user_rid)
        SAM_ACCOUNT *sampass=NULL;
        BOOL ret;
 
+       if (!pdb_rid_is_user(user_rid)) {
+               DEBUG(4,("RID 0x%x is not a user RID\n", user_rid));
+               return False;
+       }
+
        pdb_init_sam(&sampass);
 
        become_root();
@@ -1552,6 +1562,11 @@ static BOOL get_user_info_21(SAM_USER_INFO_21 *id21, uint32 user_rid)
        SAM_ACCOUNT *sampass=NULL;
        BOOL ret;
 
+       if (!pdb_rid_is_user(user_rid)) {
+               DEBUG(4,("RID 0x%x is not a user RID\n", user_rid));
+               return False;
+       }
+
        pdb_init_sam(&sampass);
 
        become_root();
index 959a93e07b19f5fb3f89b54b072377a531d3cfb0..96ca7360b89d0d0dbd93934e6603aab896ef6f58 100644 (file)
@@ -344,7 +344,6 @@ static BOOL check_cache(char *name)
 
        /* we found it - construct the full name */
        strncpy(extension, name+9, 3);
-       extension[3] = 0;
 
        if (extension[0]) {
                M_DEBUG(0,("check_cache: %s -> %s.%s\n", name, prefix, extension));
@@ -436,19 +435,6 @@ static BOOL name_map(char *name, BOOL need83, BOOL cache83)
        /* find the '.' if any */
        dot_p = strrchr(name, '.');
 
-       if (dot_p) {
-               /* if the extension contains any illegal characters or
-                  is too long or zero length then we treat it as part
-                  of the prefix */
-               for (i=0; i<4 && dot_p[i+1]; i++) {
-                       if (! FLAG_CHECK(dot_p[i+1], FLAG_ASCII)) {
-                               dot_p = NULL;
-                               break;
-                       }
-               }
-               if (i == 0 || i == 4) dot_p = NULL;
-       }
-
        /* the leading character in the mangled name is taken from
           the first character of the name, if it is ascii 
           otherwise '_' is used
index ac0b535c13d1f8355994fe6a984b8f2c59123fb1..864d3d6c666a09f8f546649cc59a9536835c04da 100644 (file)
@@ -546,12 +546,9 @@ DOM_SID *uid_to_sid(DOM_SID *psid, uid_t uid)
                        return psid;
                }
        }
-       
-       /* Make sure we report failure, (when psid == NULL) */
-       become_root();
-       psid = local_uid_to_sid(psid, uid);
-        unbecome_root();
 
+       local_uid_to_sid(psid, uid);
+        
        DEBUG(10,("uid_to_sid: local %u -> %s\n", (unsigned int)uid, sid_to_string(sid, psid)));
 
        return psid;
@@ -614,14 +611,10 @@ BOOL sid_to_uid(DOM_SID *psid, uid_t *puid, enum SID_NAME_USE *sidtype)
         */
 
        if ( (!winbind_lookup_sid(psid, dom_name, name, &name_type)) || (name_type != SID_NAME_USER) ) {
-               BOOL result;
                DEBUG(10,("sid_to_uid: winbind lookup for sid %s failed - trying local.\n",
                                sid_to_string(sid_str, psid) ));
 
-               become_root();
-               result = local_sid_to_uid(puid, psid, sidtype);
-               unbecome_root();
-               return result;
+               return local_sid_to_uid(puid, psid, sidtype);
        }
 
        /*
@@ -641,13 +634,9 @@ BOOL sid_to_uid(DOM_SID *psid, uid_t *puid, enum SID_NAME_USE *sidtype)
         */
 
        if (!winbind_sid_to_uid(puid, psid)) {
-               BOOL result;
                DEBUG(10,("sid_to_uid: winbind lookup for sid %s failed.\n",
                                sid_to_string(sid_str, psid) ));
-               become_root();
-               result = local_sid_to_uid(puid, psid, sidtype);
-               unbecome_root();
-               return result;
+               return local_sid_to_uid(puid, psid, sidtype);
        }
 
        DEBUG(10,("sid_to_uid: winbindd %s -> %u\n",
@@ -678,6 +667,7 @@ BOOL sid_to_gid(DOM_SID *psid, gid_t *pgid, enum SID_NAME_USE *sidtype)
        if (!winbind_lookup_sid(psid, dom_name, name, &name_type)) {
                DEBUG(10,("sid_to_gid: winbind lookup for sid %s failed - trying local.\n",
                                sid_to_string(sid_str, psid) ));
+
                if (!local_sid_to_gid(pgid, psid, sidtype)) {
                        /* this was probably a foreign sid - assume its a group rid 
                           and continue */
index 23624d07333a51aa78f8c9f234fde13b882e1110..29eeb802ffe2d37855567794c9d37d17233b7d13 100644 (file)
@@ -25,8 +25,7 @@
 static fstring host, workgroup, share, password, username, myname;
 static int max_protocol = PROTOCOL_NT1;
 static char *sockops="TCP_NODELAY";
-static int nprocs=1;
-int torture_numops=100;
+static int nprocs=1, numops=100;
 static int procnum; /* records process count number when forking */
 static struct cli_state current_cli;
 static fstring randomfname;
@@ -240,7 +239,7 @@ static BOOL rw_torture(struct cli_state *c)
        }
 
 
-       for (i=0;i<torture_numops;i++) {
+       for (i=0;i<numops;i++) {
                unsigned n = (unsigned)sys_random()%10;
                if (i % 10 == 0) {
                        printf("%d\r", i); fflush(stdout);
@@ -457,7 +456,7 @@ static BOOL rw_torture2(struct cli_state *c1, struct cli_state *c2)
                return False;
        }
 
-       for (i=0;i<torture_numops;i++)
+       for (i=0;i<numops;i++)
        {
                size_t buf_size = ((unsigned)sys_random()%(sizeof(buf)-1))+ 1;
                if (i % 10 == 0) {
@@ -1113,7 +1112,7 @@ static BOOL run_locktest3(int dummy)
        uint32 offset;
        BOOL correct = True;
 
-#define NEXT_OFFSET offset += (~(uint32)0) / torture_numops
+#define NEXT_OFFSET offset += (~(uint32)0) / numops
 
        if (!torture_open_connection(&cli1) || !torture_open_connection(&cli2)) {
                return False;
@@ -1136,7 +1135,7 @@ static BOOL run_locktest3(int dummy)
                return False;
        }
 
-       for (offset=i=0;i<torture_numops;i++) {
+       for (offset=i=0;i<numops;i++) {
                NEXT_OFFSET;
                if (!cli_lock(&cli1, fnum1, offset-1, 1, 0, WRITE_LOCK)) {
                        printf("lock1 %d failed (%s)\n", 
@@ -1153,7 +1152,7 @@ static BOOL run_locktest3(int dummy)
                }
        }
 
-       for (offset=i=0;i<torture_numops;i++) {
+       for (offset=i=0;i<numops;i++) {
                NEXT_OFFSET;
 
                if (cli_lock(&cli1, fnum1, offset-2, 1, 0, WRITE_LOCK)) {
@@ -1177,7 +1176,7 @@ static BOOL run_locktest3(int dummy)
                }
        }
 
-       for (offset=i=0;i<torture_numops;i++) {
+       for (offset=i=0;i<numops;i++) {
                NEXT_OFFSET;
 
                if (!cli_unlock(&cli1, fnum1, offset-1, 1)) {
@@ -3420,7 +3419,7 @@ static BOOL run_dirtest(int dummy)
        cli_sockopt(&cli, sockops);
 
        srandom(0);
-       for (i=0;i<torture_numops;i++) {
+       for (i=0;i<numops;i++) {
                fstring fname;
                slprintf(fname, sizeof(fname), "\\%x", (int)random());
                fnum = cli_open(&cli, fname, O_RDWR|O_CREAT, DENY_NONE);
@@ -3440,7 +3439,7 @@ static BOOL run_dirtest(int dummy)
        printf("dirtest core %g seconds\n", end_timer() - t1);
 
        srandom(0);
-       for (i=0;i<torture_numops;i++) {
+       for (i=0;i<numops;i++) {
                fstring fname;
                slprintf(fname, sizeof(fname), "\\%x", (int)random());
                cli_unlink(&cli, fname);
@@ -3694,7 +3693,6 @@ static struct {
        {"RENAME", run_rename, 0},
        {"DELETE", run_deletetest, 0},
        {"PROPERTIES", run_properties, 0},
-       {"MANGLE", torture_mangle, 0},
        {"W2K", run_w2ktest, 0},
        {"TRANS2SCAN", torture_trans2_scan, 0},
        {"NTTRANSSCAN", torture_nttrans_scan, 0},
@@ -3766,7 +3764,6 @@ static void usage(void)
        printf("\t-L use oplocks\n");
        printf("\t-c CLIENT.TXT   specify client load file for NBENCH\n");
        printf("\t-A showall\n");
-       printf("\t-s seed\n");
        printf("\n\n");
 
        printf("tests are:");
@@ -3837,11 +3834,8 @@ static void usage(void)
 
        fstrcpy(workgroup, lp_workgroup());
 
-       while ((opt = getopt(argc, argv, "hW:U:n:N:O:o:m:Ld:Ac:ks:")) != EOF) {
+       while ((opt = getopt(argc, argv, "hW:U:n:N:O:o:m:Ld:Ac:k")) != EOF) {
                switch (opt) {
-               case 's':
-                       srandom(atoi(optarg));
-                       break;
                case 'W':
                        fstrcpy(workgroup,optarg);
                        break;
@@ -3852,7 +3846,7 @@ static void usage(void)
                        nprocs = atoi(optarg);
                        break;
                case 'o':
-                       torture_numops = atoi(optarg);
+                       numops = atoi(optarg);
                        break;
                case 'd':
                        DEBUGLEVEL = atoi(optarg);