* Unix SMB/CIFS implementation.
* RPC Pipe client / server routines
* Copyright (C) Andrew Tridgell 1992-1997,
- * Copyright (C) Jeremy Allison 2001.
- * Copyright (C) Nigel Williams 2001.
+ * Copyright (C) Jeremy Allison 2001.
+ * Copyright (C) Nigel Williams 2001.
+ * Copyright (C) Gerald (Jerry) Carter 2006.
+ * Copyright (C) Jelmer Vernooij 2006.
*
* 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
+ * the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* 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.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
*/
/* This is the implementation of the srvsvc pipe. */
#include "includes.h"
+#define MAX_SERVER_DISK_ENTRIES 15
+
+extern struct generic_mapping file_generic_mapping;
+extern userdom_struct current_user_info;
+
#undef DBGC_CLASS
#define DBGC_CLASS DBGC_RPC_SRV
-/*******************************************************************
- Utility function to get the 'type' of a share from an snum.
- ********************************************************************/
-static uint32 get_share_type(int snum)
-{
- char *net_name = lp_servicename(snum);
- int len_net_name = strlen(net_name);
-
- /* work out the share type */
- uint32 type = STYPE_DISKTREE;
+/* Use for enumerating connections, pipes, & files */
- if (lp_print_ok(snum))
- type = STYPE_PRINTQ;
- if (strequal(lp_fstype(snum), "IPC"))
- type = STYPE_IPC;
- if (net_name[len_net_name] == '$')
- type |= STYPE_HIDDEN;
+struct file_enum_count {
+ TALLOC_CTX *ctx;
+ uint32 count;
+ struct srvsvc_NetFileInfo3 *info;
+};
- return type;
-}
-
-/*******************************************************************
- Fill in a share info level 0 structure.
- ********************************************************************/
+struct sess_file_count {
+ struct server_id pid;
+ uid_t uid;
+ int count;
+};
-static void init_srv_share_info_0(pipes_struct *p, SRV_SHARE_INFO_0 *sh0, int snum)
+/****************************************************************************
+ Count the entries belonging to a service in the connection db.
+****************************************************************************/
+
+static int pipe_enum_fn( struct db_record *rec, void *p)
{
- pstring net_name;
+ struct pipe_open_rec prec;
+ struct file_enum_count *fenum = (struct file_enum_count *)p;
+
+ if (rec->value.dsize != sizeof(struct pipe_open_rec))
+ return 0;
- pstrcpy(net_name, lp_servicename(snum));
+ memcpy(&prec, rec->value.dptr, sizeof(struct pipe_open_rec));
+
+ if ( process_exists(prec.pid) ) {
+ struct srvsvc_NetFileInfo3 *f;
+ int i = fenum->count;
+ pstring fullpath;
+
+ snprintf( fullpath, sizeof(fullpath), "\\PIPE\\%s", prec.name );
+
+ f = TALLOC_REALLOC_ARRAY( fenum->ctx, fenum->info, struct srvsvc_NetFileInfo3, i+1 );
+ if ( !f ) {
+ DEBUG(0,("conn_enum_fn: realloc failed for %d items\n", i+1));
+ return 1;
+ }
+
+ fenum->info = f;
+
+ fenum->info[i].fid = (uint32)((procid_to_pid(&prec.pid)<<16) & prec.pnum);
+ fenum->info[i].permissions = (FILE_READ_DATA|FILE_WRITE_DATA);
+ fenum->info[i].num_locks = 0;
+ if (!(fenum->info[i].user = talloc_strdup(
+ fenum->ctx, uidtoname(prec.uid)))) {
+ /* There's not much we can do here. */
+ fenum->info[i].user = "";
+ }
+ if (!(fenum->info[i].path = talloc_strdup(
+ fenum->ctx, fullpath))) {
+ /* There's not much we can do here. */
+ fenum->info[i].path = "";
+ }
+
+ fenum->count++;
+ }
- init_srv_share_info0(&sh0->info_0, net_name);
- init_srv_share_info0_str(&sh0->info_0_str, net_name);
+ return 0;
}
/*******************************************************************
- Fill in a share info level 1 structure.
- ********************************************************************/
+********************************************************************/
-static void init_srv_share_info_1(pipes_struct *p, SRV_SHARE_INFO_1 *sh1, int snum)
+static WERROR net_enum_pipes( TALLOC_CTX *ctx, struct srvsvc_NetFileInfo3 **info,
+ uint32 *count, uint32 *resume )
{
- pstring remark;
+ struct file_enum_count fenum;
- char *net_name = lp_servicename(snum);
- pstrcpy(remark, lp_comment(snum));
- standard_sub_conn(p->conn, remark,sizeof(remark));
+ fenum.ctx = ctx;
+ fenum.info = *info;
+ fenum.count = *count;
- init_srv_share_info1(&sh1->info_1, net_name, get_share_type(snum), remark);
- init_srv_share_info1_str(&sh1->info_1_str, net_name, remark);
+ if (connections_traverse(pipe_enum_fn, &fenum) == -1) {
+ DEBUG(0,("net_enum_pipes: traverse of connections.tdb "
+ "failed\n"));
+ return WERR_NOMEM;
+ }
+
+ *info = fenum.info;
+ *count = fenum.count;
+
+ return WERR_OK;
}
/*******************************************************************
- Fill in a share info level 2 structure.
- ********************************************************************/
+********************************************************************/
-static void init_srv_share_info_2(pipes_struct *p, SRV_SHARE_INFO_2 *sh2, int snum)
+static void enum_file_fn( const struct share_mode_entry *e,
+ const char *sharepath, const char *fname,
+ void *private_data )
{
- pstring remark;
- pstring path;
- pstring passwd;
-
- char *net_name = lp_servicename(snum);
- pstrcpy(remark, lp_comment(snum));
- standard_sub_conn(p->conn, remark,sizeof(remark));
- pstrcpy(path, "C:");
- pstrcat(path, lp_pathname(snum));
-
- /*
- * Change / to \\ so that win2k will see it as a valid path. This was added to
- * enable use of browsing in win2k add share dialog.
- */
-
- string_replace(path, '/', '\\');
-
- pstrcpy(passwd, "");
+ struct file_enum_count *fenum =
+ (struct file_enum_count *)&private_data;
+
+ /* If the pid was not found delete the entry from connections.tdb */
+
+ if ( process_exists(e->pid) ) {
+ struct srvsvc_NetFileInfo3 *f;
+ int i = fenum->count;
+ files_struct fsp;
+ struct byte_range_lock *brl;
+ int num_locks = 0;
+ pstring fullpath;
+ uint32 permissions;
+
+ f = TALLOC_REALLOC_ARRAY( fenum->ctx, fenum->info, struct srvsvc_NetFileInfo3, i+1 );
+ if ( !f ) {
+ DEBUG(0,("conn_enum_fn: realloc failed for %d items\n", i+1));
+ return;
+ }
+ fenum->info = f;
- init_srv_share_info2(&sh2->info_2, net_name, get_share_type(snum), remark, 0, 0xffffffff, 1, path, passwd);
- init_srv_share_info2_str(&sh2->info_2_str, net_name, remark, path, passwd);
-}
+ /* need to count the number of locks on a file */
+
+ ZERO_STRUCT( fsp );
+ fsp.file_id = e->id;
+
+ if ( (brl = brl_get_locks_readonly(NULL,&fsp)) != NULL ) {
+ num_locks = brl->num_locks;
+ TALLOC_FREE( brl );
+ }
+
+ if ( strcmp( fname, "." ) == 0 ) {
+ pstr_sprintf( fullpath, "C:%s", sharepath );
+ } else {
+ pstr_sprintf( fullpath, "C:%s/%s", sharepath, fname );
+ }
+ string_replace( fullpath, '/', '\\' );
+
+ /* mask out create (what ever that is) */
+ permissions = e->share_access & (FILE_READ_DATA|FILE_WRITE_DATA);
+
+ fenum->info[i].fid = e->share_file_id;
+ fenum->info[i].permissions = permissions;
+ fenum->info[i].num_locks = num_locks;
+ if (!(fenum->info[i].user = talloc_strdup(
+ fenum->ctx, uidtoname(e->uid)))) {
+ /* There's not much we can do here. */
+ fenum->info[i].user = "";
+ }
+ if (!(fenum->info[i].path = talloc_strdup(
+ fenum->ctx, fullpath))) {
+ /* There's not much we can do here. */
+ fenum->info[i].path = "";
+ }
+
+ fenum->count++;
+ }
-/*******************************************************************
- What to do when smb.conf is updated.
- ********************************************************************/
+ return;
-static void smb_conf_updated(int msg_type, pid_t src, void *buf, size_t len)
-{
- DEBUG(10,("smb_conf_updated: Got message saying smb.conf was updated. Reloading.\n"));
- reload_services(False);
}
/*******************************************************************
- Create the share security tdb.
- ********************************************************************/
-
-static TDB_CONTEXT *share_tdb; /* used for share security descriptors */
-#define SHARE_DATABASE_VERSION_V1 1
-#define SHARE_DATABASE_VERSION_V2 2 /* version id in little endian. */
+********************************************************************/
-BOOL share_info_db_init(void)
+static WERROR net_enum_files( TALLOC_CTX *ctx, struct srvsvc_NetFileInfo3 **info,
+ uint32 *count, uint32 *resume )
{
- static pid_t local_pid;
- const char *vstring = "INFO/version";
- int32 vers_id;
-
- if (share_tdb && local_pid == sys_getpid())
- return True;
- share_tdb = tdb_open_log(lock_path("share_info.tdb"), 0, TDB_DEFAULT, O_RDWR|O_CREAT, 0600);
- if (!share_tdb) {
- DEBUG(0,("Failed to open share info database %s (%s)\n",
- lock_path("share_info.tdb"), strerror(errno) ));
- return False;
- }
-
- local_pid = sys_getpid();
-
- /* handle a Samba upgrade */
- tdb_lock_bystring(share_tdb, vstring, 0);
-
- /* Cope with byte-reversed older versions of the db. */
- vers_id = tdb_fetch_int32(share_tdb, vstring);
- if ((vers_id == SHARE_DATABASE_VERSION_V1) || (IREV(vers_id) == SHARE_DATABASE_VERSION_V1)) {
- /* Written on a bigendian machine with old fetch_int code. Save as le. */
- tdb_store_int32(share_tdb, vstring, SHARE_DATABASE_VERSION_V2);
- vers_id = SHARE_DATABASE_VERSION_V2;
- }
-
- if (vers_id != SHARE_DATABASE_VERSION_V2) {
- tdb_traverse(share_tdb, tdb_traverse_delete_fn, NULL);
- tdb_store_int32(share_tdb, vstring, SHARE_DATABASE_VERSION_V2);
- }
- tdb_unlock_bystring(share_tdb, vstring);
+ struct file_enum_count f_enum_cnt;
- message_register(MSG_SMB_CONF_UPDATED, smb_conf_updated);
-
- return True;
+ f_enum_cnt.ctx = ctx;
+ f_enum_cnt.count = *count;
+ f_enum_cnt.info = *info;
+
+ share_mode_forall( enum_file_fn, (void *)&f_enum_cnt );
+
+ *info = f_enum_cnt.info;
+ *count = f_enum_cnt.count;
+
+ return WERR_OK;
}
/*******************************************************************
- Fake up a Everyone, full access as a default.
+ Utility function to get the 'type' of a share from a share definition.
********************************************************************/
-
-static SEC_DESC *get_share_security_default( TALLOC_CTX *ctx, int snum, size_t *psize)
+static uint32 get_share_type(const struct share_params *params)
{
- extern DOM_SID global_sid_World;
- extern struct generic_mapping file_generic_mapping;
- SEC_ACCESS sa;
- SEC_ACE ace;
- SEC_ACL *psa = NULL;
- SEC_DESC *psd = NULL;
- uint32 def_access = GENERIC_ALL_ACCESS;
-
- se_map_generic(&def_access, &file_generic_mapping);
-
- init_sec_access(&sa, GENERIC_ALL_ACCESS | def_access );
- init_sec_ace(&ace, &global_sid_World, SEC_ACE_TYPE_ACCESS_ALLOWED, sa, 0);
-
- if ((psa = make_sec_acl(ctx, NT4_ACL_REVISION, 1, &ace)) != NULL) {
- psd = make_sec_desc(ctx, SEC_DESC_REVISION, SEC_DESC_SELF_RELATIVE, NULL, NULL, NULL, psa, psize);
- }
+ char *net_name = lp_servicename(params->service);
+ int len_net_name = strlen(net_name);
+
+ /* work out the share type */
+ uint32 type = STYPE_DISKTREE;
- if (!psd) {
- DEBUG(0,("get_share_security: Failed to make SEC_DESC.\n"));
- return NULL;
- }
+ if (lp_print_ok(params->service))
+ type = STYPE_PRINTQ;
+ if (strequal(lp_fstype(params->service), "IPC"))
+ type = STYPE_IPC;
+ if (net_name[len_net_name-1] == '$')
+ type |= STYPE_HIDDEN;
- return psd;
+ return type;
}
-
+
/*******************************************************************
- Pull a security descriptor from the share tdb.
+ Fill in a share info level 0 structure.
********************************************************************/
-static SEC_DESC *get_share_security( TALLOC_CTX *ctx, int snum, size_t *psize)
+static void init_srv_share_info_0(pipes_struct *p, struct srvsvc_NetShareInfo0 *sh0,
+ const struct share_params *params)
{
- prs_struct ps;
- fstring key;
- SEC_DESC *psd = NULL;
-
- *psize = 0;
-
- /* Fetch security descriptor from tdb */
-
- slprintf(key, sizeof(key)-1, "SECDESC/%s", lp_servicename(snum));
-
- if (tdb_prs_fetch(share_tdb, key, &ps, ctx)!=0 ||
- !sec_io_desc("get_share_security", &psd, &ps, 1)) {
-
- DEBUG(4,("get_share_security: using default secdesc for %s\n", lp_servicename(snum) ));
-
- return get_share_security_default(ctx, snum, psize);
- }
-
- if (psd)
- *psize = sec_desc_size(psd);
-
- prs_mem_free(&ps);
- return psd;
+ sh0->name = lp_servicename(params->service);
}
/*******************************************************************
- Store a security descriptor in the share db.
+ Fill in a share info level 1 structure.
********************************************************************/
-static BOOL set_share_security(TALLOC_CTX *ctx, const char *share_name, SEC_DESC *psd)
+static void init_srv_share_info_1(pipes_struct *p, struct srvsvc_NetShareInfo1 *sh1,
+ const struct share_params *params)
{
- prs_struct ps;
- TALLOC_CTX *mem_ctx = NULL;
- fstring key;
- BOOL ret = False;
-
- mem_ctx = talloc_init("set_share_security");
- if (mem_ctx == NULL)
- return False;
+ connection_struct *conn = p->conn;
- prs_init(&ps, (uint32)sec_desc_size(psd), mem_ctx, MARSHALL);
-
- if (!sec_io_desc("share_security", &psd, &ps, 1))
- goto out;
-
- slprintf(key, sizeof(key)-1, "SECDESC/%s", share_name);
-
- if (tdb_prs_store(share_tdb, key, &ps)==0) {
- ret = True;
- DEBUG(5,("set_share_security: stored secdesc for %s\n", share_name ));
- } else {
- DEBUG(1,("set_share_security: Failed to store secdesc for %s\n", share_name ));
- }
+ sh1->comment = talloc_sub_advanced(p->mem_ctx, lp_servicename(SNUM(conn)),
+ conn->user, conn->connectpath, conn->gid,
+ get_current_username(),
+ current_user_info.domain,
+ lp_comment(params->service));
- /* Free malloc'ed memory */
-
-out:
-
- prs_mem_free(&ps);
- if (mem_ctx)
- talloc_destroy(mem_ctx);
- return ret;
+ sh1->name = lp_servicename(params->service);
+ sh1->type = get_share_type(params);
}
/*******************************************************************
- Delete a security descriptor.
-********************************************************************/
+ Fill in a share info level 2 structure.
+ ********************************************************************/
-static BOOL delete_share_security(int snum)
+static void init_srv_share_info_2(pipes_struct *p, struct srvsvc_NetShareInfo2 *sh2,
+ const struct share_params *params)
{
- TDB_DATA kbuf;
- fstring key;
+ connection_struct *conn = p->conn;
+ char *remark;
+ char *path;
+ int max_connections = lp_max_connections(params->service);
+ uint32 max_uses = max_connections!=0 ? max_connections : 0xffffffff;
+ int count = 0;
+ char *net_name = lp_servicename(params->service);
+
+ remark = talloc_sub_advanced(p->mem_ctx, lp_servicename(SNUM(conn)),
+ conn->user, conn->connectpath, conn->gid,
+ get_current_username(),
+ current_user_info.domain,
+ lp_comment(params->service));
+ path = talloc_asprintf(p->mem_ctx, "C:%s",
+ lp_pathname(params->service));
- slprintf(key, sizeof(key)-1, "SECDESC/%s", lp_servicename(snum));
- kbuf.dptr = key;
- kbuf.dsize = strlen(key)+1;
+ /*
+ * Change / to \\ so that win2k will see it as a valid path. This was
+ * added to enable use of browsing in win2k add share dialog.
+ */
- if (tdb_delete(share_tdb, kbuf) != 0) {
- DEBUG(0,("delete_share_security: Failed to delete entry for share %s\n",
- lp_servicename(snum) ));
- return False;
- }
+ string_replace(path, '/', '\\');
- return True;
+ count = count_current_connections( net_name, False );
+ sh2->name = net_name;
+ sh2->type = get_share_type(params);
+ sh2->comment = remark;
+ sh2->permissions = 0;
+ sh2->max_users = max_uses;
+ sh2->current_users = count;
+ sh2->path = path;
+ sh2->password = "";
}
/*******************************************************************
Map any generic bits to file specific bits.
********************************************************************/
-void map_generic_share_sd_bits(SEC_DESC *psd)
+static void map_generic_share_sd_bits(SEC_DESC *psd)
{
- extern struct generic_mapping file_generic_mapping;
int i;
SEC_ACL *ps_dacl = NULL;
return;
for (i = 0; i < ps_dacl->num_aces; i++) {
- SEC_ACE *psa = &ps_dacl->ace[i];
- uint32 orig_mask = psa->info.mask;
+ SEC_ACE *psa = &ps_dacl->aces[i];
+ uint32 orig_mask = psa->access_mask;
- se_map_generic(&psa->info.mask, &file_generic_mapping);
- psa->info.mask |= orig_mask;
+ se_map_generic(&psa->access_mask, &file_generic_mapping);
+ psa->access_mask |= orig_mask;
}
}
-/*******************************************************************
- Can this user access with share with the required permissions ?
-********************************************************************/
-
-BOOL share_access_check(connection_struct *conn, int snum, user_struct *vuser, uint32 desired_access)
-{
- uint32 granted;
- NTSTATUS status;
- TALLOC_CTX *mem_ctx = NULL;
- SEC_DESC *psd = NULL;
- size_t sd_size;
- NT_USER_TOKEN *token = NULL;
- BOOL ret = True;
-
- mem_ctx = talloc_init("share_access_check");
- if (mem_ctx == NULL)
- return False;
-
- psd = get_share_security(mem_ctx, snum, &sd_size);
-
- if (!psd)
- goto out;
-
- if (conn->nt_user_token)
- token = conn->nt_user_token;
- else
- token = vuser->nt_user_token;
-
- ret = se_access_check(psd, token, desired_access, &granted, &status);
-
-out:
-
- talloc_destroy(mem_ctx);
-
- return ret;
-}
-
/*******************************************************************
Fill in a share info level 501 structure.
********************************************************************/
-static void init_srv_share_info_501(pipes_struct *p, SRV_SHARE_INFO_501 *sh501, int snum)
+static void init_srv_share_info_501(pipes_struct *p, struct srvsvc_NetShareInfo501 *sh501,
+ const struct share_params *params)
{
- int len_net_name;
- pstring remark;
+ connection_struct *conn = p->conn;
+ char *remark;
+ const char *net_name = lp_servicename(params->service);
- char *net_name = lp_servicename(snum);
- pstrcpy(remark, lp_comment(snum));
- standard_sub_conn(p->conn, remark, sizeof(remark));
+ remark = talloc_sub_advanced(p->mem_ctx, lp_servicename(SNUM(conn)),
+ conn->user, conn->connectpath, conn->gid,
+ get_current_username(),
+ current_user_info.domain,
+ lp_comment(params->service));
- len_net_name = strlen(net_name);
- init_srv_share_info501(&sh501->info_501, net_name, get_share_type(snum), remark, (lp_csc_policy(snum) << 4));
- init_srv_share_info501_str(&sh501->info_501_str, net_name, remark);
+ sh501->name = net_name;
+ sh501->type = get_share_type(params);
+ sh501->comment = remark;
+ sh501->csc_policy = (lp_csc_policy(params->service) << 4);
}
/*******************************************************************
Fill in a share info level 502 structure.
********************************************************************/
-static void init_srv_share_info_502(pipes_struct *p, SRV_SHARE_INFO_502 *sh502, int snum)
+static void init_srv_share_info_502(pipes_struct *p, struct srvsvc_NetShareInfo502 *sh502,
+ const struct share_params *params)
{
- int len_net_name;
- pstring net_name;
- pstring remark;
- pstring path;
- pstring passwd;
+ int max_connections = lp_max_connections(params->service);
+ uint32 max_uses = max_connections!=0 ? max_connections : 0xffffffff;
+ connection_struct *conn = p->conn;
+ int count;
+ char *net_name;
+ char *remark;
+ char *path;
SEC_DESC *sd;
size_t sd_size;
TALLOC_CTX *ctx = p->mem_ctx;
ZERO_STRUCTP(sh502);
- pstrcpy(net_name, lp_servicename(snum));
- pstrcpy(remark, lp_comment(snum));
- standard_sub_conn(p->conn, remark,sizeof(remark));
- pstrcpy(path, "C:");
- pstrcat(path, lp_pathname(snum));
+ net_name = lp_servicename(params->service);
+ count = count_current_connections( net_name, False );
+
+ remark = talloc_sub_advanced(p->mem_ctx, lp_servicename(SNUM(conn)),
+ conn->user, conn->connectpath, conn->gid,
+ get_current_username(),
+ current_user_info.domain,
+ lp_comment(params->service));
+
+ path = talloc_asprintf(p->mem_ctx, "C:%s",
+ lp_pathname(params->service));
/*
- * Change / to \\ so that win2k will see it as a valid path. This was added to
- * enable use of browsing in win2k add share dialog.
+ * Change / to \\ so that win2k will see it as a valid path. This was
+ * added to enable use of browsing in win2k add share dialog.
*/
string_replace(path, '/', '\\');
- pstrcpy(passwd, "");
- len_net_name = strlen(net_name);
-
- sd = get_share_security(ctx, snum, &sd_size);
-
- init_srv_share_info502(&sh502->info_502, net_name, get_share_type(snum), remark, 0, 0xffffffff, 1, path, passwd, sd, sd_size);
- init_srv_share_info502_str(&sh502->info_502_str, net_name, remark, path, passwd, sd, sd_size);
+ sd = get_share_security(ctx, lp_servicename(params->service),
+ &sd_size);
+
+ sh502->name = net_name;
+ sh502->type = get_share_type(params);
+ sh502->comment = remark;
+ sh502->path = path;
+ sh502->password = "";
+ sh502->sd = sd;
+ sh502->permissions = 0;
+ sh502->max_users = max_uses;
+ sh502->current_users = count;
+ sh502->unknown = 1;
}
/***************************************************************************
Fill in a share info level 1004 structure.
***************************************************************************/
-static void init_srv_share_info_1004(pipes_struct *p, SRV_SHARE_INFO_1004* sh1004, int snum)
+static void init_srv_share_info_1004(pipes_struct *p,
+ struct srvsvc_NetShareInfo1004* sh1004,
+ const struct share_params *params)
{
- pstring remark;
+ connection_struct *conn = p->conn;
+ char *remark;
- pstrcpy(remark, lp_comment(snum));
- standard_sub_conn(p->conn, remark, sizeof(remark));
+ remark = talloc_sub_advanced(p->mem_ctx, lp_servicename(SNUM(conn)),
+ conn->user, conn->connectpath, conn->gid,
+ get_current_username(),
+ current_user_info.domain,
+ lp_comment(params->service));
ZERO_STRUCTP(sh1004);
-
- init_srv_share_info1004(&sh1004->info_1004, remark);
- init_srv_share_info1004_str(&sh1004->info_1004_str, remark);
+
+ sh1004->comment = remark;
}
/***************************************************************************
Fill in a share info level 1005 structure.
***************************************************************************/
-static void init_srv_share_info_1005(pipes_struct *p, SRV_SHARE_INFO_1005* sh1005, int snum)
+static void init_srv_share_info_1005(pipes_struct *p,
+ struct srvsvc_NetShareInfo1005* sh1005,
+ const struct share_params *params)
{
- sh1005->share_info_flags = 0;
+ sh1005->dfs_flags = 0;
- if(lp_host_msdfs() && lp_msdfs_root(snum))
- sh1005->share_info_flags |=
+ if(lp_host_msdfs() && lp_msdfs_root(params->service))
+ sh1005->dfs_flags |=
SHARE_1005_IN_DFS | SHARE_1005_DFS_ROOT;
- sh1005->share_info_flags |=
- lp_csc_policy(snum) << SHARE_1005_CSC_POLICY_SHIFT;
+ sh1005->dfs_flags |=
+ lp_csc_policy(params->service) << SHARE_1005_CSC_POLICY_SHIFT;
}
/***************************************************************************
Fill in a share info level 1006 structure.
***************************************************************************/
-static void init_srv_share_info_1006(pipes_struct *p, SRV_SHARE_INFO_1006* sh1006, int snum)
+static void init_srv_share_info_1006(pipes_struct *p,
+ struct srvsvc_NetShareInfo1006* sh1006,
+ const struct share_params *params)
{
- sh1006->max_uses = -1;
+ sh1006->max_users = -1;
}
/***************************************************************************
Fill in a share info level 1007 structure.
***************************************************************************/
-static void init_srv_share_info_1007(pipes_struct *p, SRV_SHARE_INFO_1007* sh1007, int snum)
+static void init_srv_share_info_1007(pipes_struct *p,
+ struct srvsvc_NetShareInfo1007* sh1007,
+ const struct share_params *params)
{
- pstring alternate_directory_name = "";
uint32 flags = 0;
ZERO_STRUCTP(sh1007);
- init_srv_share_info1007(&sh1007->info_1007, flags, alternate_directory_name);
- init_srv_share_info1007_str(&sh1007->info_1007_str, alternate_directory_name);
+ sh1007->flags = flags;
+ sh1007->alternate_directory_name = "";
}
/*******************************************************************
Fill in a share info level 1501 structure.
********************************************************************/
-static void init_srv_share_info_1501(pipes_struct *p, SRV_SHARE_INFO_1501 *sh1501, int snum)
+static void init_srv_share_info_1501(pipes_struct *p,
+ struct sec_desc_buf *sh1501,
+ const struct share_params *params)
{
SEC_DESC *sd;
size_t sd_size;
ZERO_STRUCTP(sh1501);
- sd = get_share_security(ctx, snum, &sd_size);
+ sd = get_share_security(ctx, lp_servicename(params->service),
+ &sd_size);
- sh1501->sdb = make_sec_desc_buf(p->mem_ctx, sd_size, sd);
+ sh1501->sd = sd;
}
/*******************************************************************
True if it ends in '$'.
********************************************************************/
-static BOOL is_hidden_share(int snum)
+static BOOL is_hidden_share(const struct share_params *params)
{
- const char *net_name = lp_servicename(snum);
+ const char *net_name = lp_servicename(params->service);
- return (net_name[strlen(net_name) - 1] == '$') ? True : False;
+ return (net_name[strlen(net_name) - 1] == '$');
}
/*******************************************************************
Fill in a share info structure.
********************************************************************/
-static BOOL init_srv_share_info_ctr(pipes_struct *p, SRV_SHARE_INFO_CTR *ctr,
- uint32 info_level, uint32 *resume_hnd, uint32 *total_entries, BOOL all_shares)
+static WERROR init_srv_share_info_ctr(pipes_struct *p,
+ union srvsvc_NetShareCtr *ctr,
+ uint32 info_level, uint32 *resume_hnd,
+ uint32 *total_entries, BOOL all_shares)
{
- int num_entries = 0;
- int num_services = lp_numservices();
- int snum;
TALLOC_CTX *ctx = p->mem_ctx;
+ struct share_iterator *shares;
+ struct share_params *share;
+ WERROR result = WERR_NOMEM;
DEBUG(5,("init_srv_share_info_ctr\n"));
- ZERO_STRUCTPN(ctr);
-
- ctr->info_level = ctr->switch_value = info_level;
- *resume_hnd = 0;
+ ZERO_STRUCTP(ctr);
- /* Count the number of entries. */
- for (snum = 0; snum < num_services; snum++) {
- if (lp_browseable(snum) && lp_snum_ok(snum) && (all_shares || !is_hidden_share(snum)) )
- num_entries++;
+ if (resume_hnd) {
+ *resume_hnd = 0;
}
- *total_entries = num_entries;
- ctr->num_entries2 = ctr->num_entries = num_entries;
- ctr->ptr_share_info = ctr->ptr_entries = 1;
+ /* Ensure all the usershares are loaded. */
+ become_root();
+ load_usershare_shares();
+ load_registry_shares();
+ unbecome_root();
- if (!num_entries)
- return True;
+ *total_entries = 0;
+
+ if (!(shares = share_list_all(ctx))) {
+ DEBUG(5, ("Could not list shares\n"));
+ return WERR_ACCESS_DENIED;
+ }
switch (info_level) {
case 0:
- {
- SRV_SHARE_INFO_0 *info0;
- int i = 0;
-
- info0 = talloc(ctx, num_entries * sizeof(SRV_SHARE_INFO_0));
-
- for (snum = *resume_hnd; snum < num_services; snum++) {
- if (lp_browseable(snum) && lp_snum_ok(snum) && (all_shares || !is_hidden_share(snum)) ) {
- init_srv_share_info_0(p, &info0[i++], snum);
- }
+ if (!(ctr->ctr0 = TALLOC_ZERO_P(
+ p->mem_ctx, struct srvsvc_NetShareCtr0))) {
+ goto done;
}
-
- ctr->share.info0 = info0;
break;
-
- }
-
case 1:
- {
- SRV_SHARE_INFO_1 *info1;
- int i = 0;
-
- info1 = talloc(ctx, num_entries * sizeof(SRV_SHARE_INFO_1));
-
- for (snum = *resume_hnd; snum < num_services; snum++) {
- if (lp_browseable(snum) && lp_snum_ok(snum) && (all_shares || !is_hidden_share(snum)) ) {
- init_srv_share_info_1(p, &info1[i++], snum);
- }
+ if (!(ctr->ctr1 = TALLOC_ZERO_P(
+ p->mem_ctx, struct srvsvc_NetShareCtr1))) {
+ goto done;
}
-
- ctr->share.info1 = info1;
break;
- }
-
case 2:
- {
- SRV_SHARE_INFO_2 *info2;
- int i = 0;
-
- info2 = talloc(ctx, num_entries * sizeof(SRV_SHARE_INFO_2));
-
- for (snum = *resume_hnd; snum < num_services; snum++) {
- if (lp_browseable(snum) && lp_snum_ok(snum) && (all_shares || !is_hidden_share(snum)) ) {
- init_srv_share_info_2(p, &info2[i++], snum);
- }
+ if (!(ctr->ctr2 = TALLOC_ZERO_P(
+ p->mem_ctx, struct srvsvc_NetShareCtr2))) {
+ goto done;
}
-
- ctr->share.info2 = info2;
break;
- }
-
case 501:
- {
- SRV_SHARE_INFO_501 *info501;
- int i = 0;
-
- info501 = talloc(ctx, num_entries * sizeof(SRV_SHARE_INFO_501));
-
- for (snum = *resume_hnd; snum < num_services; snum++) {
- if (lp_browseable(snum) && lp_snum_ok(snum) && (all_shares || !is_hidden_share(snum)) ) {
- init_srv_share_info_501(p, &info501[i++], snum);
- }
+ if (!(ctr->ctr501 = TALLOC_ZERO_P(
+ p->mem_ctx, struct srvsvc_NetShareCtr501))) {
+ goto done;
}
-
- ctr->share.info501 = info501;
break;
- }
-
case 502:
- {
- SRV_SHARE_INFO_502 *info502;
- int i = 0;
-
- info502 = talloc(ctx, num_entries * sizeof(SRV_SHARE_INFO_502));
-
- for (snum = *resume_hnd; snum < num_services; snum++) {
- if (lp_browseable(snum) && lp_snum_ok(snum) && (all_shares || !is_hidden_share(snum)) ) {
- init_srv_share_info_502(p, &info502[i++], snum);
- }
+ if (!(ctr->ctr502 = TALLOC_ZERO_P(
+ p->mem_ctx, struct srvsvc_NetShareCtr502))) {
+ goto done;
}
-
- ctr->share.info502 = info502;
break;
- }
-
- /* here for completeness but not currently used with enum (1004 - 1501)*/
-
case 1004:
- {
- SRV_SHARE_INFO_1004 *info1004;
- int i = 0;
-
- info1004 = talloc(ctx, num_entries * sizeof(SRV_SHARE_INFO_1004));
-
- for (snum = *resume_hnd; snum < num_services; snum++) {
- if (lp_browseable(snum) && lp_snum_ok(snum) && (all_shares || !is_hidden_share(snum)) ) {
- init_srv_share_info_1004(p, &info1004[i++], snum);
- }
+ if (!(ctr->ctr1004 = TALLOC_ZERO_P(
+ p->mem_ctx, struct srvsvc_NetShareCtr1004))) {
+ goto done;
}
-
- ctr->share.info1004 = info1004;
break;
- }
-
case 1005:
- {
- SRV_SHARE_INFO_1005 *info1005;
- int i = 0;
-
- info1005 = talloc(ctx, num_entries * sizeof(SRV_SHARE_INFO_1005));
-
- for (snum = *resume_hnd; snum < num_services; snum++) {
- if (lp_browseable(snum) && lp_snum_ok(snum) && (all_shares || !is_hidden_share(snum)) ) {
- init_srv_share_info_1005(p, &info1005[i++], snum);
- }
+ if (!(ctr->ctr1005 = TALLOC_ZERO_P(
+ p->mem_ctx, struct srvsvc_NetShareCtr1005))) {
+ goto done;
}
-
- ctr->share.info1005 = info1005;
break;
- }
-
case 1006:
- {
- SRV_SHARE_INFO_1006 *info1006;
- int i = 0;
-
- info1006 = talloc(ctx, num_entries * sizeof(SRV_SHARE_INFO_1006));
-
- for (snum = *resume_hnd; snum < num_services; snum++) {
- if (lp_browseable(snum) && lp_snum_ok(snum) && (all_shares || !is_hidden_share(snum)) ) {
- init_srv_share_info_1006(p, &info1006[i++], snum);
- }
+ if (!(ctr->ctr1006 = TALLOC_ZERO_P(
+ p->mem_ctx, struct srvsvc_NetShareCtr1006))) {
+ goto done;
}
-
- ctr->share.info1006 = info1006;
break;
- }
-
case 1007:
- {
- SRV_SHARE_INFO_1007 *info1007;
- int i = 0;
-
- info1007 = talloc(ctx, num_entries * sizeof(SRV_SHARE_INFO_1007));
-
- for (snum = *resume_hnd; snum < num_services; snum++) {
- if (lp_browseable(snum) && lp_snum_ok(snum) && (all_shares || !is_hidden_share(snum)) ) {
- init_srv_share_info_1007(p, &info1007[i++], snum);
- }
+ if (!(ctr->ctr1007 = TALLOC_ZERO_P(
+ p->mem_ctx, struct srvsvc_NetShareCtr1007))) {
+ goto done;
}
-
- ctr->share.info1007 = info1007;
break;
- }
-
case 1501:
- {
- SRV_SHARE_INFO_1501 *info1501;
- int i = 0;
-
- info1501 = talloc(ctx, num_entries * sizeof(SRV_SHARE_INFO_1501));
-
- for (snum = *resume_hnd; snum < num_services; snum++) {
- if (lp_browseable(snum) && lp_snum_ok(snum) && (all_shares || !is_hidden_share(snum)) ) {
- init_srv_share_info_1501(p, &info1501[i++], snum);
- }
+ if (!(ctr->ctr1501 = TALLOC_ZERO_P(
+ p->mem_ctx, struct srvsvc_NetShareCtr1501))) {
+ goto done;
}
-
- ctr->share.info1501 = info1501;
break;
- }
default:
- DEBUG(5,("init_srv_share_info_ctr: unsupported switch value %d\n", info_level));
- return False;
- }
-
- return True;
-}
-
-/*******************************************************************
- Inits a SRV_R_NET_SHARE_ENUM structure.
-********************************************************************/
-
-static void init_srv_r_net_share_enum(pipes_struct *p, SRV_R_NET_SHARE_ENUM *r_n,
- uint32 info_level, uint32 resume_hnd, BOOL all)
-{
- DEBUG(5,("init_srv_r_net_share_enum: %d\n", __LINE__));
-
- if (init_srv_share_info_ctr(p, &r_n->ctr, info_level,
- &resume_hnd, &r_n->total_entries, all)) {
- r_n->status = WERR_OK;
- } else {
- r_n->status = WERR_UNKNOWN_LEVEL;
+ DEBUG(5,("init_srv_share_info_ctr: unsupported switch "
+ "value %d\n", info_level));
+ return WERR_UNKNOWN_LEVEL;
}
- init_enum_hnd(&r_n->enum_hnd, resume_hnd);
-}
-
-/*******************************************************************
- Inits a SRV_R_NET_SHARE_GET_INFO structure.
-********************************************************************/
-
-static void init_srv_r_net_share_get_info(pipes_struct *p, SRV_R_NET_SHARE_GET_INFO *r_n,
- char *share_name, uint32 info_level)
-{
- WERROR status = WERR_OK;
- int snum;
-
- DEBUG(5,("init_srv_r_net_share_get_info: %d\n", __LINE__));
-
- r_n->info.switch_value = info_level;
-
- snum = find_service(share_name);
+ while ((share = next_share(shares)) != NULL) {
+ if (!lp_browseable(share->service)) {
+ continue;
+ }
+ if (!all_shares && is_hidden_share(share)) {
+ continue;
+ }
- if (snum >= 0) {
switch (info_level) {
case 0:
- init_srv_share_info_0(p, &r_n->info.share.info0, snum);
+ {
+ struct srvsvc_NetShareInfo0 i;
+ init_srv_share_info_0(p, &i, share);
+ ADD_TO_ARRAY(ctx, struct srvsvc_NetShareInfo0, i,
+ &ctr->ctr0->array, &ctr->ctr0->count);
+ if (ctr->ctr0->array == NULL) {
+ return WERR_NOMEM;
+ }
+ *total_entries = ctr->ctr0->count;
break;
+ }
+
case 1:
- init_srv_share_info_1(p, &r_n->info.share.info1, snum);
+ {
+ struct srvsvc_NetShareInfo1 i;
+ init_srv_share_info_1(p, &i, share);
+ ADD_TO_ARRAY(ctx, struct srvsvc_NetShareInfo1, i,
+ &ctr->ctr1->array, &ctr->ctr1->count);
+ if (ctr->ctr1->array == NULL) {
+ return WERR_NOMEM;
+ }
+ *total_entries = ctr->ctr1->count;
break;
+ }
+
case 2:
- init_srv_share_info_2(p, &r_n->info.share.info2, snum);
+ {
+ struct srvsvc_NetShareInfo2 i;
+ init_srv_share_info_2(p, &i, share);
+ ADD_TO_ARRAY(ctx, struct srvsvc_NetShareInfo2, i,
+ &ctr->ctr2->array, &ctr->ctr2->count);
+ if (ctr->ctr2->array == NULL) {
+ return WERR_NOMEM;
+ }
+ *total_entries = ctr->ctr2->count;
break;
+ }
+
case 501:
- init_srv_share_info_501(p, &r_n->info.share.info501, snum);
+ {
+ struct srvsvc_NetShareInfo501 i;
+ init_srv_share_info_501(p, &i, share);
+ ADD_TO_ARRAY(ctx, struct srvsvc_NetShareInfo501, i,
+ &ctr->ctr501->array, &ctr->ctr501->count);
+ if (ctr->ctr501->array == NULL) {
+ return WERR_NOMEM;
+ }
+ *total_entries = ctr->ctr501->count;
break;
+ }
+
case 502:
- init_srv_share_info_502(p, &r_n->info.share.info502, snum);
+ {
+ struct srvsvc_NetShareInfo502 i;
+ init_srv_share_info_502(p, &i, share);
+ ADD_TO_ARRAY(ctx, struct srvsvc_NetShareInfo502, i,
+ &ctr->ctr502->array, &ctr->ctr502->count);
+ if (ctr->ctr502->array == NULL) {
+ return WERR_NOMEM;
+ }
+ *total_entries = ctr->ctr502->count;
break;
+ }
- /* here for completeness */
+ /* here for completeness but not currently used with enum
+ * (1004 - 1501)*/
+
case 1004:
- init_srv_share_info_1004(p, &r_n->info.share.info1004, snum);
+ {
+ struct srvsvc_NetShareInfo1004 i;
+ init_srv_share_info_1004(p, &i, share);
+ ADD_TO_ARRAY(ctx, struct srvsvc_NetShareInfo1004, i,
+ &ctr->ctr1004->array, &ctr->ctr1004->count);
+ if (ctr->ctr1004->array == NULL) {
+ return WERR_NOMEM;
+ }
+ *total_entries = ctr->ctr1004->count;
break;
+ }
+
case 1005:
- init_srv_share_info_1005(p, &r_n->info.share.info1005, snum);
+ {
+ struct srvsvc_NetShareInfo1005 i;
+ init_srv_share_info_1005(p, &i, share);
+ ADD_TO_ARRAY(ctx, struct srvsvc_NetShareInfo1005, i,
+ &ctr->ctr1005->array, &ctr->ctr1005->count);
+ if (ctr->ctr1005->array == NULL) {
+ return WERR_NOMEM;
+ }
+ *total_entries = ctr->ctr1005->count;
break;
+ }
- /* here for completeness 1006 - 1501 */
case 1006:
- init_srv_share_info_1006(p, &r_n->info.share.info1006, snum);
+ {
+ struct srvsvc_NetShareInfo1006 i;
+ init_srv_share_info_1006(p, &i, share);
+ ADD_TO_ARRAY(ctx, struct srvsvc_NetShareInfo1006, i,
+ &ctr->ctr1006->array, &ctr->ctr1006->count);
+ if (ctr->ctr1006->array == NULL) {
+ return WERR_NOMEM;
+ }
+ *total_entries = ctr->ctr1006->count;
break;
+ }
+
case 1007:
- init_srv_share_info_1007(p, &r_n->info.share.info1007, snum);
+ {
+ struct srvsvc_NetShareInfo1007 i;
+ init_srv_share_info_1007(p, &i, share);
+ ADD_TO_ARRAY(ctx, struct srvsvc_NetShareInfo1007, i,
+ &ctr->ctr1007->array, &ctr->ctr1007->count);
+ if (ctr->ctr1007->array == NULL) {
+ return WERR_NOMEM;
+ }
+ *total_entries = ctr->ctr1007->count;
break;
+ }
+
case 1501:
- init_srv_share_info_1501(p, &r_n->info.share.info1501, snum);
- break;
- default:
- DEBUG(5,("init_srv_net_share_get_info: unsupported switch value %d\n", info_level));
- status = WERR_UNKNOWN_LEVEL;
+ {
+ struct sec_desc_buf i;
+ init_srv_share_info_1501(p, &i, share);
+ ADD_TO_ARRAY(ctx, struct sec_desc_buf, i,
+ &ctr->ctr1501->array, &ctr->ctr1501->count);
+ if (ctr->ctr1501->array == NULL) {
+ return WERR_NOMEM;
+ }
+ *total_entries = ctr->ctr1501->count;
break;
}
- } else {
- status = WERR_INVALID_NAME;
- }
-
- r_n->info.ptr_share_ctr = W_ERROR_IS_OK(status) ? 1 : 0;
- r_n->status = status;
-}
+ }
-/*******************************************************************
- fill in a sess info level 1 structure.
- ********************************************************************/
+ TALLOC_FREE(share);
+ }
-static void init_srv_sess_0_info(SESS_INFO_0 *se0, SESS_INFO_0_STR *str0, char *name)
-{
- init_srv_sess_info0(se0, name);
- init_srv_sess_info0_str(str0, name);
+ result = WERR_OK;
+ done:
+ TALLOC_FREE(shares);
+ return result;
}
/*******************************************************************
fill in a sess info level 0 structure.
********************************************************************/
-static void init_srv_sess_info_0(SRV_SESS_INFO_0 *ss0, uint32 *snum, uint32 *stot)
+static void init_srv_sess_info_0(pipes_struct *p, struct srvsvc_NetSessCtr0 *ss0, uint32 *snum, uint32 *stot)
{
struct sessionid *session_list;
uint32 num_entries = 0;
- (*stot) = list_sessions(&session_list);
+ (*stot) = list_sessions(p->mem_ctx, &session_list);
if (ss0 == NULL) {
- (*snum) = 0;
- SAFE_FREE(session_list);
+ if (snum) {
+ (*snum) = 0;
+ }
return;
}
DEBUG(5,("init_srv_sess_0_ss0\n"));
- if (snum) {
- for (; (*snum) < (*stot) && num_entries < MAX_SESS_ENTRIES; (*snum)++) {
- init_srv_sess_0_info(&ss0->info_0[num_entries],
- &ss0->info_0_str[num_entries], session_list[(*snum)].remote_machine);
+ ss0->array = TALLOC_ARRAY(p->mem_ctx, struct srvsvc_NetSessInfo0, *stot);
- /* move on to creating next session */
- /* move on to creating next sess */
+ if (snum) {
+ for (; (*snum) < (*stot); (*snum)++) {
+ ss0->array[num_entries].client = session_list[(*snum)].remote_machine;
num_entries++;
}
- ss0->num_entries_read = num_entries;
- ss0->ptr_sess_info = num_entries > 0 ? 1 : 0;
- ss0->num_entries_read2 = num_entries;
+ ss0->count = num_entries;
if ((*snum) >= (*stot)) {
(*snum) = 0;
}
} else {
- ss0->num_entries_read = 0;
- ss0->ptr_sess_info = 0;
- ss0->num_entries_read2 = 0;
+ ss0->array = NULL;
+ ss0->count = 0;
}
- SAFE_FREE(session_list);
}
/*******************************************************************
- fill in a sess info level 1 structure.
- ********************************************************************/
+********************************************************************/
+
+static void sess_file_fn( const struct share_mode_entry *e,
+ const char *sharepath, const char *fname,
+ void *private_data )
+{
+ struct sess_file_count *sess = (struct sess_file_count *)private_data;
+
+ if ( procid_equal(&e->pid, &sess->pid) && (sess->uid == e->uid) ) {
+ sess->count++;
+ }
+
+ return;
+}
-static void init_srv_sess_1_info(SESS_INFO_1 *se1, SESS_INFO_1_STR *str1,
- char *name, char *user,
- uint32 num_opens,
- uint32 open_time, uint32 idle_time,
- uint32 usr_flgs)
+/*******************************************************************
+********************************************************************/
+
+static int net_count_files( uid_t uid, struct server_id pid )
{
- init_srv_sess_info1(se1 , name, user, num_opens, open_time, idle_time, usr_flgs);
- init_srv_sess_info1_str(str1, name, user);
+ struct sess_file_count s_file_cnt;
+
+ s_file_cnt.count = 0;
+ s_file_cnt.uid = uid;
+ s_file_cnt.pid = pid;
+
+ share_mode_forall( sess_file_fn, (void *)&s_file_cnt );
+
+ return s_file_cnt.count;
}
/*******************************************************************
fill in a sess info level 1 structure.
********************************************************************/
-static void init_srv_sess_info_1(SRV_SESS_INFO_1 *ss1, uint32 *snum, uint32 *stot)
+static void init_srv_sess_info_1(pipes_struct *p, struct srvsvc_NetSessCtr1 *ss1, uint32 *snum, uint32 *stot)
{
struct sessionid *session_list;
uint32 num_entries = 0;
- (*stot) = list_sessions(&session_list);
+ time_t now = time(NULL);
+ if ( !snum ) {
+ ss1->count = 0;
+ ss1->array = NULL;
+
+ (*stot) = 0;
+
+ return;
+ }
+
if (ss1 == NULL) {
- (*snum) = 0;
- SAFE_FREE(session_list);
+ if (snum != NULL)
+ (*snum) = 0;
return;
}
- DEBUG(5,("init_srv_sess_1_ss1\n"));
+ (*stot) = list_sessions(p->mem_ctx, &session_list);
- if (snum) {
- for (; (*snum) < (*stot) && num_entries < MAX_SESS_ENTRIES; (*snum)++) {
- init_srv_sess_1_info(&ss1->info_1[num_entries],
- &ss1->info_1_str[num_entries],
- session_list[*snum].remote_machine,
- session_list[*snum].username,
- 1, 10, 5, 0);
-
- /* move on to creating next session */
- /* move on to creating next sess */
- num_entries++;
+ ss1->array = TALLOC_ARRAY(p->mem_ctx, struct srvsvc_NetSessInfo1, *stot);
+
+ for (; (*snum) < (*stot); (*snum)++) {
+ uint32 num_files;
+ uint32 connect_time;
+ struct passwd *pw = sys_getpwnam(session_list[*snum].username);
+ BOOL guest;
+
+ if ( !pw ) {
+ DEBUG(10,("init_srv_sess_info_1: failed to find owner: %s\n",
+ session_list[*snum].username));
+ continue;
}
-
- ss1->num_entries_read = num_entries;
- ss1->ptr_sess_info = num_entries > 0 ? 1 : 0;
- ss1->num_entries_read2 = num_entries;
-
- if ((*snum) >= (*stot)) {
- (*snum) = 0;
+
+ connect_time = (uint32)(now - session_list[*snum].connect_start);
+ num_files = net_count_files(pw->pw_uid, session_list[*snum].pid);
+ guest = strequal( session_list[*snum].username, lp_guestaccount() );
+
+ if (!(ss1->array[num_entries].client = talloc_strdup(
+ ss1->array, session_list[*snum].remote_machine))) {
+ ss1->array[num_entries].client = "";
}
+ if (!(ss1->array[num_entries].user = talloc_strdup(
+ ss1->array, session_list[*snum].username))) {
+ ss1->array[num_entries].user = "";
+ }
+ ss1->array[num_entries].num_open = num_files;
+ ss1->array[num_entries].time = connect_time;
+ ss1->array[num_entries].idle_time = 0;
+ ss1->array[num_entries].user_flags = guest;
- } else {
- ss1->num_entries_read = 0;
- ss1->ptr_sess_info = 0;
- ss1->num_entries_read2 = 0;
-
- (*stot) = 0;
+ num_entries++;
+ }
+
+ ss1->count = num_entries;
+
+ if ((*snum) >= (*stot)) {
+ (*snum) = 0;
}
}
makes a SRV_R_NET_SESS_ENUM structure.
********************************************************************/
-static WERROR init_srv_sess_info_ctr(SRV_SESS_INFO_CTR *ctr,
+static WERROR init_srv_sess_info_ctr(pipes_struct *p, union srvsvc_NetSessCtr *ctr,
int switch_value, uint32 *resume_hnd, uint32 *total_entries)
{
WERROR status = WERR_OK;
DEBUG(5,("init_srv_sess_info_ctr: %d\n", __LINE__));
- ctr->switch_value = switch_value;
-
switch (switch_value) {
case 0:
- init_srv_sess_info_0(&(ctr->sess.info0), resume_hnd, total_entries);
- ctr->ptr_sess_ctr = 1;
+ ctr->ctr0 = talloc(p->mem_ctx, struct srvsvc_NetSessCtr0);
+ init_srv_sess_info_0(p, ctr->ctr0, resume_hnd, total_entries);
break;
case 1:
- init_srv_sess_info_1(&(ctr->sess.info1), resume_hnd, total_entries);
- ctr->ptr_sess_ctr = 1;
+ ctr->ctr1 = talloc(p->mem_ctx, struct srvsvc_NetSessCtr1);
+ init_srv_sess_info_1(p, ctr->ctr1, resume_hnd, total_entries);
break;
default:
DEBUG(5,("init_srv_sess_info_ctr: unsupported switch value %d\n", switch_value));
- (*resume_hnd) = 0;
+ if (resume_hnd != NULL)
+ (*resume_hnd) = 0;
(*total_entries) = 0;
- ctr->ptr_sess_ctr = 0;
+ ctr->ctr0 = NULL;
status = WERR_UNKNOWN_LEVEL;
break;
}
return status;
}
-/*******************************************************************
- makes a SRV_R_NET_SESS_ENUM structure.
-********************************************************************/
-
-static void init_srv_r_net_sess_enum(SRV_R_NET_SESS_ENUM *r_n,
- uint32 resume_hnd, int sess_level, int switch_value)
-{
- DEBUG(5,("init_srv_r_net_sess_enum: %d\n", __LINE__));
-
- r_n->sess_level = sess_level;
-
- if (sess_level == -1)
- r_n->status = WERR_UNKNOWN_LEVEL;
- else
- r_n->status = init_srv_sess_info_ctr(r_n->ctr, switch_value, &resume_hnd, &r_n->total_entries);
-
- if (!W_ERROR_IS_OK(r_n->status))
- resume_hnd = 0;
-
- init_enum_hnd(&r_n->enum_hnd, resume_hnd);
-}
-
/*******************************************************************
fill in a conn info level 0 structure.
********************************************************************/
-static void init_srv_conn_info_0(SRV_CONN_INFO_0 *ss0, uint32 *snum, uint32 *stot)
+static void init_srv_conn_info_0(pipes_struct *p, struct srvsvc_NetConnCtr0 *ss0, uint32 *snum, uint32 *stot)
{
uint32 num_entries = 0;
(*stot) = 1;
if (ss0 == NULL) {
- (*snum) = 0;
+ if (snum != NULL)
+ (*snum) = 0;
return;
}
DEBUG(5,("init_srv_conn_0_ss0\n"));
if (snum) {
- for (; (*snum) < (*stot) && num_entries < MAX_CONN_ENTRIES; (*snum)++) {
+ ss0->array = TALLOC_ARRAY(p->mem_ctx, struct srvsvc_NetConnInfo0, *stot);
+ for (; (*snum) < (*stot); (*snum)++) {
- init_srv_conn_info0(&ss0->info_0[num_entries], (*stot));
+ ss0->array[num_entries].conn_id = (*stot);
/* move on to creating next connection */
/* move on to creating next conn */
num_entries++;
}
- ss0->num_entries_read = num_entries;
- ss0->ptr_conn_info = num_entries > 0 ? 1 : 0;
- ss0->num_entries_read2 = num_entries;
+ ss0->count = num_entries;
if ((*snum) >= (*stot)) {
(*snum) = 0;
}
} else {
- ss0->num_entries_read = 0;
- ss0->ptr_conn_info = 0;
- ss0->num_entries_read2 = 0;
+ ss0->array = NULL;
+ ss0->count = 0;
(*stot) = 0;
}
fill in a conn info level 1 structure.
********************************************************************/
-static void init_srv_conn_1_info(CONN_INFO_1 *se1, CONN_INFO_1_STR *str1,
- uint32 id, uint32 type,
- uint32 num_opens, uint32 num_users, uint32 open_time,
- const char *usr_name, const char *net_name)
-{
- init_srv_conn_info1(se1 , id, type, num_opens, num_users, open_time, usr_name, net_name);
- init_srv_conn_info1_str(str1, usr_name, net_name);
-}
-
-/*******************************************************************
- fill in a conn info level 1 structure.
- ********************************************************************/
-
-static void init_srv_conn_info_1(SRV_CONN_INFO_1 *ss1, uint32 *snum, uint32 *stot)
+static void init_srv_conn_info_1(pipes_struct *p, struct srvsvc_NetConnCtr1 *ss1, uint32 *snum, uint32 *stot)
{
uint32 num_entries = 0;
(*stot) = 1;
if (ss1 == NULL) {
- (*snum) = 0;
+ if (snum != NULL)
+ (*snum) = 0;
return;
}
DEBUG(5,("init_srv_conn_1_ss1\n"));
if (snum) {
- for (; (*snum) < (*stot) && num_entries < MAX_CONN_ENTRIES; (*snum)++) {
- init_srv_conn_1_info(&ss1->info_1[num_entries],
- &ss1->info_1_str[num_entries],
- (*stot), 0x3, 1, 1, 3,"dummy_user", "IPC$");
+ ss1->array = TALLOC_ARRAY(p->mem_ctx, struct srvsvc_NetConnInfo1, *stot);
+ for (; (*snum) < (*stot); (*snum)++) {
+ ss1->array[num_entries].conn_id = (*stot);
+ ss1->array[num_entries].conn_type = 0x3;
+ ss1->array[num_entries].num_open = 1;
+ ss1->array[num_entries].num_users = 1;
+ ss1->array[num_entries].conn_time = 3;
+ ss1->array[num_entries].user = "dummy_user";
+ ss1->array[num_entries].share = "IPC$";
/* move on to creating next connection */
/* move on to creating next conn */
num_entries++;
}
- ss1->num_entries_read = num_entries;
- ss1->ptr_conn_info = num_entries > 0 ? 1 : 0;
- ss1->num_entries_read2 = num_entries;
-
+ ss1->count = num_entries;
if ((*snum) >= (*stot)) {
(*snum) = 0;
}
} else {
- ss1->num_entries_read = 0;
- ss1->ptr_conn_info = 0;
- ss1->num_entries_read2 = 0;
+ ss1->count = 0;
+ ss1->array = NULL;
(*stot) = 0;
}
makes a SRV_R_NET_CONN_ENUM structure.
********************************************************************/
-static WERROR init_srv_conn_info_ctr(SRV_CONN_INFO_CTR *ctr,
+static WERROR init_srv_conn_info_ctr(pipes_struct *p, union srvsvc_NetConnCtr *ctr,
int switch_value, uint32 *resume_hnd, uint32 *total_entries)
{
WERROR status = WERR_OK;
DEBUG(5,("init_srv_conn_info_ctr: %d\n", __LINE__));
- ctr->switch_value = switch_value;
-
switch (switch_value) {
case 0:
- init_srv_conn_info_0(&ctr->conn.info0, resume_hnd, total_entries);
- ctr->ptr_conn_ctr = 1;
+ init_srv_conn_info_0(p, ctr->ctr0, resume_hnd, total_entries);
break;
case 1:
- init_srv_conn_info_1(&ctr->conn.info1, resume_hnd, total_entries);
- ctr->ptr_conn_ctr = 1;
+ init_srv_conn_info_1(p, ctr->ctr1, resume_hnd, total_entries);
break;
default:
DEBUG(5,("init_srv_conn_info_ctr: unsupported switch value %d\n", switch_value));
- (*resume_hnd = 0);
+ ctr->ctr0 = NULL;
+ (*resume_hnd) = 0;
(*total_entries) = 0;
- ctr->ptr_conn_ctr = 0;
status = WERR_UNKNOWN_LEVEL;
break;
}
}
/*******************************************************************
- makes a SRV_R_NET_CONN_ENUM structure.
+ makes a SRV_R_NET_FILE_ENUM structure.
********************************************************************/
-static void init_srv_r_net_conn_enum(SRV_R_NET_CONN_ENUM *r_n,
- uint32 resume_hnd, int conn_level, int switch_value)
+static WERROR net_file_enum_3(pipes_struct *p, union srvsvc_NetFileCtr *ctr, uint32 *resume_hnd, uint32 *num_entries )
{
- DEBUG(5,("init_srv_r_net_conn_enum: %d\n", __LINE__));
+ TALLOC_CTX *ctx = get_talloc_ctx();
+ WERROR status;
- r_n->conn_level = conn_level;
- if (conn_level == -1)
- r_n->status = WERR_UNKNOWN_LEVEL;
- else
- r_n->status = init_srv_conn_info_ctr(r_n->ctr, switch_value, &resume_hnd, &r_n->total_entries);
+ /* TODO -- Windows enumerates
+ (b) active pipes
+ (c) open directories and files */
- if (!W_ERROR_IS_OK(r_n->status))
- resume_hnd = 0;
+ ctr->ctr3 = TALLOC_ZERO_P(p->mem_ctx, struct srvsvc_NetFileCtr3);
+
+ status = net_enum_files( ctx, &ctr->ctr3->array, num_entries, resume_hnd );
+ if ( !W_ERROR_IS_OK(status))
+ return status;
+
+ status = net_enum_pipes( ctx, &ctr->ctr3->array, num_entries, resume_hnd );
+ if ( !W_ERROR_IS_OK(status))
+ return status;
- init_enum_hnd(&r_n->enum_hnd, resume_hnd);
+ ctr->ctr3->count = *num_entries;
+
+ return WERR_OK;
}
/*******************************************************************
- makes a SRV_R_NET_FILE_ENUM structure.
-********************************************************************/
+*******************************************************************/
-static WERROR init_srv_file_info_ctr(pipes_struct *p, SRV_FILE_INFO_CTR *ctr,
- int switch_value, uint32 *resume_hnd,
- uint32 *total_entries)
+WERROR _srvsvc_NetFileEnum(pipes_struct *p, struct srvsvc_NetFileEnum *r)
{
- WERROR status = WERR_OK;
- TALLOC_CTX *ctx = p->mem_ctx;
- DEBUG(5,("init_srv_file_info_ctr: %d\n", __LINE__));
- *total_entries = 1; /* dummy entries only, for */
-
- ctr->switch_value = switch_value;
- ctr->num_entries = *total_entries - *resume_hnd;
- ctr->num_entries2 = ctr->num_entries;
-
- switch (switch_value) {
- case 3: {
- int i;
- if (*total_entries > 0) {
- ctr->ptr_entries = 1;
- ctr->file.info3 = talloc(ctx, ctr->num_entries *
- sizeof(SRV_FILE_INFO_3));
- }
- for (i=0 ;i<ctr->num_entries;i++) {
- init_srv_file_info3(&ctr->file.info3[i].info_3, i+*resume_hnd, 0x35, 0, "\\PIPE\\samr", "dummy user");
- init_srv_file_info3_str(&ctr->file.info3[i].info_3_str, "\\PIPE\\samr", "dummy user");
-
- }
- ctr->ptr_file_info = 1;
- *resume_hnd = 0;
- break;
- }
+ switch ( *r->in.level ) {
+ case 3:
+ return net_file_enum_3(p, r->in.ctr, r->in.resume_handle, r->out.totalentries );
default:
- DEBUG(5,("init_srv_file_info_ctr: unsupported switch value %d\n", switch_value));
- (*resume_hnd = 0);
- (*total_entries) = 0;
- ctr->ptr_entries = 0;
- status = WERR_UNKNOWN_LEVEL;
- break;
+ return WERR_UNKNOWN_LEVEL;
}
-
- return status;
-}
-
-/*******************************************************************
- makes a SRV_R_NET_FILE_ENUM structure.
-********************************************************************/
-
-static void init_srv_r_net_file_enum(pipes_struct *p, SRV_R_NET_FILE_ENUM *r_n,
- uint32 resume_hnd, int file_level, int switch_value)
-{
- DEBUG(5,("init_srv_r_net_file_enum: %d\n", __LINE__));
-
- r_n->file_level = file_level;
- if (file_level == 0)
- r_n->status = WERR_UNKNOWN_LEVEL;
- else
- r_n->status = init_srv_file_info_ctr(p, &r_n->ctr, switch_value, &resume_hnd, &(r_n->total_entries));
-
- if (!W_ERROR_IS_OK(r_n->status))
- resume_hnd = 0;
-
- init_enum_hnd(&r_n->enum_hnd, resume_hnd);
+
+ return WERR_OK;
}
/*******************************************************************
net server get info
********************************************************************/
-WERROR _srv_net_srv_get_info(pipes_struct *p, SRV_Q_NET_SRV_GET_INFO *q_u, SRV_R_NET_SRV_GET_INFO *r_u)
+WERROR _srvsvc_NetSrvGetInfo(pipes_struct *p, struct srvsvc_NetSrvGetInfo *r)
{
WERROR status = WERR_OK;
- SRV_INFO_CTR *ctr = (SRV_INFO_CTR *)talloc(p->mem_ctx, sizeof(SRV_INFO_CTR));
-
- if (!ctr)
- return WERR_NOMEM;
- ZERO_STRUCTP(ctr);
+ ZERO_STRUCTP(r->out.info);
DEBUG(5,("srv_net_srv_get_info: %d\n", __LINE__));
return WERR_ACCESS_DENIED;
}
- switch (q_u->switch_value) {
+ switch (r->in.level) {
/* Technically level 102 should only be available to
Administrators but there isn't anything super-secret
here, as most of it is made up. */
case 102:
- init_srv_info_102(&ctr->srv.sv102,
- 500, global_myname(),
- string_truncate(lp_serverstring(), MAX_SERVER_STRING_LENGTH),
- lp_major_announce_version(), lp_minor_announce_version(),
- lp_default_server_announce(),
- 0xffffffff, /* users */
- 0xf, /* disc */
- 0, /* hidden */
- 240, /* announce */
- 3000, /* announce delta */
- 100000, /* licenses */
- "c:\\"); /* user path */
+ r->out.info->info102 = TALLOC_ZERO_P(p->mem_ctx, struct srvsvc_NetSrvInfo102);
+
+ r->out.info->info102->platform_id = 500;
+ r->out.info->info102->version_major = lp_major_announce_version();
+ r->out.info->info102->version_minor = lp_minor_announce_version();
+ r->out.info->info102->server_name = global_myname();
+ r->out.info->info102->server_type = lp_default_server_announce();
+ r->out.info->info102->userpath = "C:\\";
+ r->out.info->info102->licenses = 10000;
+ r->out.info->info102->anndelta = 3000;
+ r->out.info->info102->disc = 0xf;
+ r->out.info->info102->users = 0xffffffff;
+ r->out.info->info102->hidden = 0;
+ r->out.info->info102->announce = 240;
+ r->out.info->info102->comment = lp_serverstring();
break;
case 101:
- init_srv_info_101(&ctr->srv.sv101,
- 500, global_myname(),
- lp_major_announce_version(), lp_minor_announce_version(),
- lp_default_server_announce(),
- string_truncate(lp_serverstring(), MAX_SERVER_STRING_LENGTH));
+ r->out.info->info101 = TALLOC_ZERO_P(p->mem_ctx, struct srvsvc_NetSrvInfo101);
+ r->out.info->info101->platform_id = 500;
+ r->out.info->info101->server_name = global_myname();
+ r->out.info->info101->version_major = lp_major_announce_version();
+ r->out.info->info101->version_minor = lp_minor_announce_version();
+ r->out.info->info101->server_type = lp_default_server_announce();
+ r->out.info->info101->comment = lp_serverstring();
break;
case 100:
- init_srv_info_100(&ctr->srv.sv100, 500, global_myname());
+ r->out.info->info100 = TALLOC_ZERO_P(p->mem_ctx, struct srvsvc_NetSrvInfo100);
+ r->out.info->info100->platform_id = 500;
+ r->out.info->info100->server_name = global_myname();
break;
default:
- status = WERR_UNKNOWN_LEVEL;
+ return WERR_UNKNOWN_LEVEL;
break;
}
- /* set up the net server get info structure */
- init_srv_r_net_srv_get_info(r_u, q_u->switch_value, ctr, status);
-
DEBUG(5,("srv_net_srv_get_info: %d\n", __LINE__));
- return r_u->status;
+ return status;
}
/*******************************************************************
net server set info
********************************************************************/
-WERROR _srv_net_srv_set_info(pipes_struct *p, SRV_Q_NET_SRV_SET_INFO *q_u, SRV_R_NET_SRV_SET_INFO *r_u)
+WERROR _srvsvc_NetSrvSetInfo(pipes_struct *p, struct srvsvc_NetSrvSetInfo *r)
{
- WERROR status = WERR_OK;
-
- DEBUG(5,("srv_net_srv_set_info: %d\n", __LINE__));
-
/* Set up the net server set info structure. */
+ if (r->out.parm_error) {
+ *r->out.parm_error = 0;
+ }
+ return WERR_OK;
+}
- init_srv_r_net_srv_set_info(r_u, 0x0, status);
+/*******************************************************************
+net conn enum
+********************************************************************/
+
+WERROR _srvsvc_NetConnEnum(pipes_struct *p, struct srvsvc_NetConnEnum *r)
+{
+ DEBUG(5,("srv_net_conn_enum: %d\n", __LINE__));
- DEBUG(5,("srv_net_srv_set_info: %d\n", __LINE__));
+ ZERO_STRUCTP(r->out.ctr);
- return r_u->status;
+ /* set up the */
+ return init_srv_conn_info_ctr(p, r->out.ctr, *r->in.level, r->in.resume_handle, r->out.totalentries);
}
/*******************************************************************
-net file enum
+net sess enum
********************************************************************/
-WERROR _srv_net_file_enum(pipes_struct *p, SRV_Q_NET_FILE_ENUM *q_u, SRV_R_NET_FILE_ENUM *r_u)
+WERROR _srvsvc_NetSessEnum(pipes_struct *p, struct srvsvc_NetSessEnum *r)
{
- DEBUG(5,("srv_net_file_enum: %d\n", __LINE__));
-
- /* set up the */
- init_srv_r_net_file_enum(p, r_u,
- get_enum_hnd(&q_u->enum_hnd),
- q_u->file_level,
- q_u->ctr.switch_value);
+ DEBUG(5,("_srv_net_sess_enum: %d\n", __LINE__));
- DEBUG(5,("srv_net_file_enum: %d\n", __LINE__));
+ ZERO_STRUCTP(r->out.ctr);
- return r_u->status;
+ /* set up the */
+ return init_srv_sess_info_ctr(p, r->out.ctr,
+ *r->in.level,
+ r->in.resume_handle,
+ r->out.totalentries);
}
/*******************************************************************
-net conn enum
+net sess del
********************************************************************/
-WERROR _srv_net_conn_enum(pipes_struct *p, SRV_Q_NET_CONN_ENUM *q_u, SRV_R_NET_CONN_ENUM *r_u)
+WERROR _srvsvc_NetSessDel(pipes_struct *p, struct srvsvc_NetSessDel *r)
{
- DEBUG(5,("srv_net_conn_enum: %d\n", __LINE__));
+ struct sessionid *session_list;
+ int num_sessions, snum;
+ WERROR status;
- r_u->ctr = (SRV_CONN_INFO_CTR *)talloc(p->mem_ctx, sizeof(SRV_CONN_INFO_CTR));
- if (!r_u->ctr)
- return WERR_NOMEM;
+ char *machine = talloc_strdup(p->mem_ctx, r->in.server_unc);
- ZERO_STRUCTP(r_u->ctr);
+ /* strip leading backslashes if any */
+ while (machine[0] == '\\') {
+ memmove(machine, &machine[1], strlen(machine));
+ }
- /* set up the */
- init_srv_r_net_conn_enum(r_u,
- get_enum_hnd(&q_u->enum_hnd),
- q_u->conn_level,
- q_u->ctr->switch_value);
+ num_sessions = list_sessions(p->mem_ctx, &session_list);
- DEBUG(5,("srv_net_conn_enum: %d\n", __LINE__));
+ DEBUG(5,("_srv_net_sess_del: %d\n", __LINE__));
- return r_u->status;
-}
+ status = WERR_ACCESS_DENIED;
-/*******************************************************************
-net sess enum
-********************************************************************/
+ /* fail out now if you are not root or not a domain admin */
-WERROR _srv_net_sess_enum(pipes_struct *p, SRV_Q_NET_SESS_ENUM *q_u, SRV_R_NET_SESS_ENUM *r_u)
-{
- DEBUG(5,("_srv_net_sess_enum: %d\n", __LINE__));
+ if ((p->pipe_user.ut.uid != sec_initial_uid()) &&
+ ( ! nt_token_check_domain_rid(p->pipe_user.nt_user_token, DOMAIN_GROUP_RID_ADMINS))) {
- r_u->ctr = (SRV_SESS_INFO_CTR *)talloc(p->mem_ctx, sizeof(SRV_SESS_INFO_CTR));
- if (!r_u->ctr)
- return WERR_NOMEM;
+ goto done;
+ }
- ZERO_STRUCTP(r_u->ctr);
+ for (snum = 0; snum < num_sessions; snum++) {
- /* set up the */
- init_srv_r_net_sess_enum(r_u,
- get_enum_hnd(&q_u->enum_hnd),
- q_u->sess_level,
- q_u->ctr->switch_value);
+ if ((strequal(session_list[snum].username, r->in.user) || r->in.user[0] == '\0' ) &&
+ strequal(session_list[snum].remote_machine, machine)) {
+ NTSTATUS ntstat;
- DEBUG(5,("_srv_net_sess_enum: %d\n", __LINE__));
+ ntstat = messaging_send(smbd_messaging_context(),
+ session_list[snum].pid,
+ MSG_SHUTDOWN, &data_blob_null);
+
+ if (NT_STATUS_IS_OK(ntstat))
+ status = WERR_OK;
+ }
+ }
- return r_u->status;
+ DEBUG(5,("_srv_net_sess_del: %d\n", __LINE__));
+
+done:
+ return status;
}
/*******************************************************************
Net share enum all.
********************************************************************/
-WERROR _srv_net_share_enum_all(pipes_struct *p, SRV_Q_NET_SHARE_ENUM *q_u, SRV_R_NET_SHARE_ENUM *r_u)
+WERROR _srvsvc_NetShareEnumAll(pipes_struct *p, struct srvsvc_NetShareEnumAll *r)
{
DEBUG(5,("_srv_net_share_enum: %d\n", __LINE__));
}
/* Create the list of shares for the response. */
- init_srv_r_net_share_enum(p, r_u,
- q_u->ctr.info_level,
- get_enum_hnd(&q_u->enum_hnd), True);
-
- DEBUG(5,("_srv_net_share_enum: %d\n", __LINE__));
-
- return r_u->status;
+ return init_srv_share_info_ctr(p, r->out.ctr, *r->in.level,
+ r->in.resume_handle, r->out.totalentries, True);
}
/*******************************************************************
Net share enum.
********************************************************************/
-WERROR _srv_net_share_enum(pipes_struct *p, SRV_Q_NET_SHARE_ENUM *q_u, SRV_R_NET_SHARE_ENUM *r_u)
+WERROR _srvsvc_NetShareEnum(pipes_struct *p, struct srvsvc_NetShareEnum *r)
{
DEBUG(5,("_srv_net_share_enum: %d\n", __LINE__));
}
/* Create the list of shares for the response. */
- init_srv_r_net_share_enum(p, r_u,
- q_u->ctr.info_level,
- get_enum_hnd(&q_u->enum_hnd), False);
-
- DEBUG(5,("_srv_net_share_enum: %d\n", __LINE__));
-
- return r_u->status;
+ return init_srv_share_info_ctr(p, r->out.ctr, *r->in.level,
+ r->in.resume_handle, r->out.totalentries, False);
}
/*******************************************************************
Net share get info.
********************************************************************/
-WERROR _srv_net_share_get_info(pipes_struct *p, SRV_Q_NET_SHARE_GET_INFO *q_u, SRV_R_NET_SHARE_GET_INFO *r_u)
+WERROR _srvsvc_NetShareGetInfo(pipes_struct *p, struct srvsvc_NetShareGetInfo *r)
{
- fstring share_name;
+ const struct share_params *params;
- DEBUG(5,("_srv_net_share_get_info: %d\n", __LINE__));
+ params = get_share_params(p->mem_ctx, r->in.share_name);
- /* Create the list of shares for the response. */
- unistr2_to_ascii(share_name, &q_u->uni_share_name, sizeof(share_name));
- init_srv_r_net_share_get_info(p, r_u, share_name, q_u->info_level);
+ if (params != NULL) {
+ switch (r->in.level) {
+ case 0:
+ r->out.info->info0 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo0);
+ init_srv_share_info_0(p, r->out.info->info0, params);
+ break;
+ case 1:
+ r->out.info->info1 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo1);
+ init_srv_share_info_1(p, r->out.info->info1, params);
+ break;
+ case 2:
+ r->out.info->info2 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo2);
+ init_srv_share_info_2(p, r->out.info->info2, params);
+ break;
+ case 501:
+ r->out.info->info501 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo501);
+ init_srv_share_info_501(p, r->out.info->info501, params);
+ break;
+ case 502:
+ r->out.info->info502 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo502);
+ init_srv_share_info_502(p, r->out.info->info502, params);
+ break;
+
+ /* here for completeness */
+ case 1004:
+ r->out.info->info1004 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo1004);
+ init_srv_share_info_1004(p, r->out.info->info1004, params);
+ break;
+ case 1005:
+ r->out.info->info1005 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo1005);
+ init_srv_share_info_1005(p, r->out.info->info1005, params);
+ break;
- DEBUG(5,("_srv_net_share_get_info: %d\n", __LINE__));
+ /* here for completeness 1006 - 1501 */
+ case 1006:
+ r->out.info->info1006 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo1006);
+ init_srv_share_info_1006(p, r->out.info->info1006,
+ params);
+ break;
+ case 1007:
+ r->out.info->info1007 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo1007);
+ init_srv_share_info_1007(p, r->out.info->info1007,
+ params);
+ break;
+ case 1501:
+ r->out.info->info1501 = talloc(p->mem_ctx, struct sec_desc_buf);
+ init_srv_share_info_1501(p, r->out.info->info1501,
+ params);
+ break;
+ default:
+ DEBUG(5,("init_srv_net_share_get_info: unsupported "
+ "switch value %d\n", r->in.level));
+ return WERR_UNKNOWN_LEVEL;
+ break;
+ }
+ } else {
+ return WERR_INVALID_NAME;
+ }
- return r_u->status;
+ return WERR_OK;
}
/*******************************************************************
Check a given DOS pathname is valid for a share.
********************************************************************/
-static char *valid_share_pathname(char *dos_pathname)
+char *valid_share_pathname(char *dos_pathname)
{
char *ptr;
- /* Convert any '\' paths to '/' */
- unix_format(dos_pathname);
- unix_clean_name(dos_pathname);
+ /* Convert any '\' paths to '/' */
+ unix_format(dos_pathname);
+ unix_clean_name(dos_pathname);
+
+ /* NT is braindead - it wants a C: prefix to a pathname ! So strip it. */
+ ptr = dos_pathname;
+ if (strlen(dos_pathname) > 2 && ptr[1] == ':' && ptr[0] != '/')
+ ptr += 2;
+
+ /* Only absolute paths allowed. */
+ if (*ptr != '/')
+ return NULL;
+
+ return ptr;
+}
+
+static void setval_helper(struct registry_key *key, const char *name,
+ const char *value, WERROR *err)
+{
+ struct registry_value val;
+
+ if (!W_ERROR_IS_OK(*err)) {
+ return;
+ }
+
+ ZERO_STRUCT(val);
+ val.type = REG_SZ;
+ val.v.sz.str = CONST_DISCARD(char *, value);
+ val.v.sz.len = strlen(value)+1;
+
+ *err = reg_setvalue(key, name, &val);
+}
+
+static WERROR add_share(const char *share_name, const char *path,
+ const char *comment, uint32 max_connections,
+ const struct nt_user_token *token,
+ BOOL is_disk_op)
+{
+ if (lp_add_share_cmd() && *lp_add_share_cmd()) {
+ char *command;
+ int ret;
+
+ if (asprintf(&command, "%s \"%s\" \"%s\" \"%s\" \"%s\" %d",
+ lp_add_share_cmd(), dyn_CONFIGFILE, share_name,
+ path, comment, max_connections) == -1) {
+ return WERR_NOMEM;
+ }
+
+ DEBUG(10,("add_share: Running [%s]\n", command ));
+
+ /********* BEGIN SeDiskOperatorPrivilege BLOCK *********/
+
+ if ( is_disk_op )
+ become_root();
+
+ if ( (ret = smbrun(command, NULL)) == 0 ) {
+ /* Tell everyone we updated smb.conf. */
+ message_send_all(smbd_messaging_context(),
+ MSG_SMB_CONF_UPDATED,
+ NULL, 0, NULL);
+ }
+
+ if ( is_disk_op )
+ unbecome_root();
+
+ /********* END SeDiskOperatorPrivilege BLOCK *********/
+
+ DEBUG(3,("_srv_net_share_add: Running [%s] returned (%d)\n",
+ command, ret ));
+
+ /*
+ * No fallback to registry shares, the user did define a add
+ * share command, so fail here.
+ */
+
+ SAFE_FREE(command);
+ return (ret == 0) ? WERR_OK : WERR_ACCESS_DENIED;
+ }
+
+ if (lp_registry_shares()) {
+ char *keyname;
+ struct registry_key *key;
+ enum winreg_CreateAction action;
+ WERROR err;
+ TALLOC_CTX *mem_ctx;
+
+ if (!(keyname = talloc_asprintf(NULL, "%s\\%s", KEY_SMBCONF,
+ share_name))) {
+ return WERR_NOMEM;
+ }
+
+ mem_ctx = (TALLOC_CTX *)keyname;
+
+ err = reg_create_path(mem_ctx, keyname, REG_KEY_WRITE,
+ is_disk_op ? get_root_nt_token():token,
+ &action, &key);
+
+ if (action != REG_CREATED_NEW_KEY) {
+ err = WERR_ALREADY_EXISTS;
+ }
+
+ if (!W_ERROR_IS_OK(err)) {
+ TALLOC_FREE(mem_ctx);
+ return err;
+ }
+
+ setval_helper(key, "path", path, &err);
+ if ((comment != NULL) && (comment[0] != '\0')) {
+ setval_helper(key, "comment", comment, &err);
+ }
+ if (max_connections != 0) {
+ char tmp[16];
+ snprintf(tmp, sizeof(tmp), "%d", max_connections);
+ setval_helper(key, "max connections", tmp, &err);
+ }
+
+ if (!W_ERROR_IS_OK(err)) {
+ /*
+ * Hmmmm. We'd need transactions on the registry to
+ * get this right....
+ */
+ reg_delete_path(is_disk_op ? get_root_nt_token():token,
+ keyname);
+ }
+ TALLOC_FREE(mem_ctx);
+ return err;
+ }
+
+ return WERR_ACCESS_DENIED;
+}
+
+static WERROR delete_share(const char *sharename,
+ const struct nt_user_token *token,
+ BOOL is_disk_op)
+{
+ if (lp_delete_share_cmd() && *lp_delete_share_cmd()) {
+ char *command;
+ int ret;
+
+ if (asprintf(&command, "%s \"%s\" \"%s\"",
+ lp_delete_share_cmd(), dyn_CONFIGFILE,
+ sharename)) {
+ return WERR_NOMEM;
+ }
+
+ DEBUG(10,("delete_share: Running [%s]\n", command ));
+
+ /********* BEGIN SeDiskOperatorPrivilege BLOCK *********/
+
+ if ( is_disk_op )
+ become_root();
+
+ if ( (ret = smbrun(command, NULL)) == 0 ) {
+ /* Tell everyone we updated smb.conf. */
+ message_send_all(smbd_messaging_context(),
+ MSG_SMB_CONF_UPDATED,
+ NULL, 0, NULL);
+ }
+
+ if ( is_disk_op )
+ unbecome_root();
+
+ /********* END SeDiskOperatorPrivilege BLOCK *********/
+
+ SAFE_FREE(command);
+
+ DEBUG(3,("_srv_net_share_del: Running [%s] returned (%d)\n",
+ command, ret ));
+ return (ret == 0) ? WERR_OK : WERR_ACCESS_DENIED;
+ }
+
+ if (lp_registry_shares()) {
+ char *keyname;
+ WERROR err;
+
+ if (asprintf(&keyname, "%s\\%s", KEY_SMBCONF,
+ sharename) == -1) {
+ return WERR_NOMEM;
+ }
+
+ err = reg_delete_path(is_disk_op ? get_root_nt_token():token,
+ keyname);
+ SAFE_FREE(keyname);
+ return err;
+ }
+
+ return WERR_ACCESS_DENIED;
+}
+
+static WERROR change_share(const char *share_name, const char *path,
+ const char *comment, uint32 max_connections,
+ const struct nt_user_token *token,
+ BOOL is_disk_op)
+{
+ if (lp_change_share_cmd() && *lp_change_share_cmd()) {
+ char *command;
+ int ret;
+
+ if (asprintf(&command, "%s \"%s\" \"%s\" \"%s\" \"%s\" %d",
+ lp_change_share_cmd(), dyn_CONFIGFILE, share_name,
+ path, comment, max_connections) == -1) {
+ return WERR_NOMEM;
+ }
+
+ DEBUG(10,("_srv_net_share_set_info: Running [%s]\n", command));
+
+ /********* BEGIN SeDiskOperatorPrivilege BLOCK *********/
+
+ if ( is_disk_op )
+ become_root();
+
+ if ( (ret = smbrun(command, NULL)) == 0 ) {
+ /* Tell everyone we updated smb.conf. */
+ message_send_all(smbd_messaging_context(),
+ MSG_SMB_CONF_UPDATED,
+ NULL, 0, NULL);
+ }
+
+ if ( is_disk_op )
+ unbecome_root();
+
+ /********* END SeDiskOperatorPrivilege BLOCK *********/
+
+ DEBUG(3,("_srv_net_share_set_info: Running [%s] returned "
+ "(%d)\n", command, ret ));
- /* NT is braindead - it wants a C: prefix to a pathname ! So strip it. */
- ptr = dos_pathname;
- if (strlen(dos_pathname) > 2 && ptr[1] == ':' && ptr[0] != '/')
- ptr += 2;
+ SAFE_FREE(command);
- /* Only abolute paths allowed. */
- if (*ptr != '/')
- return NULL;
+ return (ret == 0) ? WERR_OK : WERR_ACCESS_DENIED;
+ }
- return ptr;
-}
+ if (lp_registry_shares()) {
+ char *keyname;
+ struct registry_key *key;
+ WERROR err;
+ TALLOC_CTX *mem_ctx;
-static BOOL exist_share_pathname(char *unix_pathname)
-{
- pstring saved_pathname;
- int ret;
+ if (!(keyname = talloc_asprintf(NULL, "%s\\%s", KEY_SMBCONF,
+ share_name))) {
+ return WERR_NOMEM;
+ }
+
+ mem_ctx = (TALLOC_CTX *)keyname;
- /* Can we cd to it ? */
+ err = reg_open_path(mem_ctx, keyname, REG_KEY_WRITE,
+ is_disk_op ? get_root_nt_token():token,
+ &key);
+ if (!W_ERROR_IS_OK(err)) {
+ TALLOC_FREE(mem_ctx);
+ return err;
+ }
- /* First save our current directory. */
- if (getcwd(saved_pathname, sizeof(saved_pathname)) == NULL)
- return False;
+ setval_helper(key, "path", path, &err);
- ret = chdir(unix_pathname);
+ reg_deletevalue(key, "comment");
+ if ((comment != NULL) && (comment[0] != '\0')) {
+ setval_helper(key, "comment", comment, &err);
+ }
- /* We *MUST* be able to chdir back. Abort if we can't. */
- if (chdir(saved_pathname) == -1)
- smb_panic("valid_share_pathname: Unable to restore current directory.\n");
+ reg_deletevalue(key, "max connections");
+ if (max_connections != 0) {
+ char tmp[16];
+ snprintf(tmp, sizeof(tmp), "%d", max_connections);
+ setval_helper(key, "max connections", tmp, &err);
+ }
- if (ret == -1) return False;
+ TALLOC_FREE(mem_ctx);
+ return err;
+ }
- return True;
+ return WERR_ACCESS_DENIED;
}
/*******************************************************************
Net share set info. Modify share details.
********************************************************************/
-WERROR _srv_net_share_set_info(pipes_struct *p, SRV_Q_NET_SHARE_SET_INFO *q_u, SRV_R_NET_SHARE_SET_INFO *r_u)
+WERROR _srvsvc_NetShareSetInfo(pipes_struct *p, struct srvsvc_NetShareSetInfo *r)
{
- struct current_user user;
- pstring command;
- fstring share_name;
- fstring comment;
+ pstring comment;
pstring pathname;
int type;
int snum;
- int ret;
char *path;
SEC_DESC *psd = NULL;
+ SE_PRIV se_diskop = SE_DISK_OPERATOR;
+ BOOL is_disk_op = False;
+ int max_connections = 0;
+ fstring tmp_share_name;
DEBUG(5,("_srv_net_share_set_info: %d\n", __LINE__));
- unistr2_to_ascii(share_name, &q_u->uni_share_name, sizeof(share_name));
-
- r_u->parm_error = 0;
+ if (r->out.parm_error) {
+ *r->out.parm_error = 0;
+ }
- if (strequal(share_name,"IPC$") || strequal(share_name,"ADMIN$") || strequal(share_name,"global"))
+ if ( strequal(r->in.share_name,"IPC$")
+ || ( lp_enable_asu_support() && strequal(r->in.share_name,"ADMIN$") )
+ || strequal(r->in.share_name,"global") )
+ {
return WERR_ACCESS_DENIED;
+ }
- snum = find_service(share_name);
+ fstrcpy(tmp_share_name, r->in.share_name);
+ snum = find_service(tmp_share_name);
/* Does this share exist ? */
if (snum < 0)
- return WERR_INVALID_NAME;
+ return WERR_NET_NAME_NOT_FOUND;
/* No change to printer shares. */
if (lp_print_ok(snum))
return WERR_ACCESS_DENIED;
- get_current_user(&user,p);
-
- if (user.uid != sec_initial_uid())
+ is_disk_op = user_has_privileges( p->pipe_user.nt_user_token,
+ &se_diskop );
+
+ /* fail out now if you are not root and not a disk op */
+
+ if ( p->pipe_user.ut.uid != sec_initial_uid() && !is_disk_op )
return WERR_ACCESS_DENIED;
- switch (q_u->info_level) {
+ switch (r->in.level) {
case 1:
pstrcpy(pathname, lp_pathname(snum));
- unistr2_to_ascii(comment, &q_u->info.share.info2.info_2_str.uni_remark, sizeof(comment));
- type = q_u->info.share.info2.info_2.type;
+ pstrcpy(comment, r->in.info.info1->comment);
+ type = r->in.info.info1->type;
psd = NULL;
break;
case 2:
- unistr2_to_ascii(comment, &q_u->info.share.info2.info_2_str.uni_remark, sizeof(comment));
- unistr2_to_ascii(pathname, &q_u->info.share.info2.info_2_str.uni_path, sizeof(pathname));
- type = q_u->info.share.info2.info_2.type;
- psd = NULL;
- break;
-#if 0
- /* not supported on set but here for completeness */
- case 501:
- unistr2_to_ascii(comment, &q_u->info.share.info501.info_501_str.uni_remark, sizeof(comment));
- type = q_u->info.share.info501.info_501.type;
+ pstrcpy(comment, r->in.info.info2->comment);
+ pstrcpy(pathname, r->in.info.info2->path);
+ type = r->in.info.info2->type;
+ max_connections = (r->in.info.info2->max_users == 0xffffffff) ?
+ 0 : r->in.info.info2->max_users;
psd = NULL;
break;
-#endif
case 502:
- unistr2_to_ascii(comment, &q_u->info.share.info502.info_502_str.uni_remark, sizeof(comment));
- unistr2_to_ascii(pathname, &q_u->info.share.info502.info_502_str.uni_path, sizeof(pathname));
- type = q_u->info.share.info502.info_502.type;
- psd = q_u->info.share.info502.info_502_str.sd;
+ pstrcpy(comment, r->in.info.info502->comment);
+ pstrcpy(pathname, r->in.info.info502->path);
+ type = r->in.info.info502->type;
+ psd = r->in.info.info502->sd;
map_generic_share_sd_bits(psd);
break;
case 1004:
pstrcpy(pathname, lp_pathname(snum));
- unistr2_to_ascii(comment, &q_u->info.share.info1004.info_1004_str.uni_remark, sizeof(comment));
+ pstrcpy(comment, r->in.info.info1004->comment);
type = STYPE_DISKTREE;
break;
case 1005:
user, so we must compare it to see if it's what is set in
smb.conf, so that we can contine other ops like setting
ACLs on a share */
- if (((q_u->info.share.info1005.share_info_flags &
+ if (((r->in.info.info1005->dfs_flags &
SHARE_1005_CSC_POLICY_MASK) >>
SHARE_1005_CSC_POLICY_SHIFT) == lp_csc_policy(snum))
return WERR_OK;
else {
- DEBUG(3, ("_srv_net_share_set_info: client is trying to change csc policy from the network; must be done with smb.conf\n"));
+ DEBUG(3, ("_srv_net_share_set_info: client is trying "
+ "to change csc policy from the network; "
+ "must be done with smb.conf\n"));
return WERR_ACCESS_DENIED;
}
- break;
case 1006:
case 1007:
return WERR_ACCESS_DENIED;
- break;
case 1501:
pstrcpy(pathname, lp_pathname(snum));
- fstrcpy(comment, lp_comment(snum));
- psd = q_u->info.share.info1501.sdb->sec;
+ pstrcpy(comment, lp_comment(snum));
+ psd = r->in.info.info1501->sd;
map_generic_share_sd_bits(psd);
type = STYPE_DISKTREE;
break;
default:
- DEBUG(5,("_srv_net_share_set_info: unsupported switch value %d\n", q_u->info_level));
+ DEBUG(5,("_srv_net_share_set_info: unsupported switch value "
+ "%d\n", r->in.level));
return WERR_UNKNOWN_LEVEL;
}
if (!(path = valid_share_pathname( pathname )))
return WERR_OBJECT_PATH_INVALID;
- /* Ensure share name, pathname and comment don't contain '"' characters. */
- string_replace(share_name, '"', ' ');
+ /* Ensure share name, pathname and comment don't contain '"'
+ * characters. */
+ string_replace(tmp_share_name, '"', ' ');
string_replace(path, '"', ' ');
string_replace(comment, '"', ' ');
DEBUG(10,("_srv_net_share_set_info: change share command = %s\n",
- lp_change_share_cmd() ? lp_change_share_cmd() : "NULL" ));
+ lp_change_share_cmd() ? lp_change_share_cmd() : "NULL" ));
/* Only call modify function if something changed. */
+
+ if (strcmp(path, lp_pathname(snum))
+ || strcmp(comment, lp_comment(snum))
+ || (lp_max_connections(snum) != max_connections) ) {
+ WERROR err;
- if (strcmp(path, lp_pathname(snum)) || strcmp(comment, lp_comment(snum)) ) {
- if (!lp_change_share_cmd() || !*lp_change_share_cmd())
- return WERR_ACCESS_DENIED;
-
- slprintf(command, sizeof(command)-1, "%s \"%s\" \"%s\" \"%s\" \"%s\"",
- lp_change_share_cmd(), dyn_CONFIGFILE, share_name, path, comment);
-
- DEBUG(10,("_srv_net_share_set_info: Running [%s]\n", command ));
- if ((ret = smbrun(command, NULL)) != 0) {
- DEBUG(0,("_srv_net_share_set_info: Running [%s] returned (%d)\n", command, ret ));
- return WERR_ACCESS_DENIED;
- }
+ err = change_share(tmp_share_name, path, comment,
+ max_connections, p->pipe_user.nt_user_token,
+ is_disk_op);
- /* Check if the new share pathname exist, if not return an error */
- if (!exist_share_pathname(path)) {
- DEBUG(1, ("_srv_net_share_set_info: change share command was ok but path (%s) has not been created!\n", path));
- return WERR_OBJECT_PATH_INVALID;
+ if (!W_ERROR_IS_OK(err)) {
+ return err;
}
-
- /* Tell everyone we updated smb.conf. */
- message_send_all(conn_tdb_ctx(), MSG_SMB_CONF_UPDATED, NULL, 0, False, NULL);
-
- } else {
- DEBUG(10,("_srv_net_share_set_info: No change to share name (%s)\n", share_name ));
}
/* Replace SD if changed. */
SEC_DESC *old_sd;
size_t sd_size;
- old_sd = get_share_security(p->mem_ctx, snum, &sd_size);
+ old_sd = get_share_security(p->mem_ctx, lp_servicename(snum),
+ &sd_size);
if (old_sd && !sec_desc_equal(old_sd, psd)) {
- if (!set_share_security(p->mem_ctx, share_name, psd))
- DEBUG(0,("_srv_net_share_set_info: Failed to change security info in share %s.\n",
- share_name ));
+ if (!set_share_security(r->in.share_name, psd)) {
+ DEBUG(0,("_srv_net_share_set_info: Failed to "
+ "change security info in share %s.\n",
+ r->in.share_name ));
+ }
}
}
-
+
DEBUG(5,("_srv_net_share_set_info: %d\n", __LINE__));
return WERR_OK;
}
+
/*******************************************************************
- Net share add. Call 'add_share_command "sharename" "pathname" "comment" "read only = xxx"'
+ Net share add. Call 'add_share_command "sharename" "pathname"
+ "comment" "max connections = "
********************************************************************/
-WERROR _srv_net_share_add(pipes_struct *p, SRV_Q_NET_SHARE_ADD *q_u, SRV_R_NET_SHARE_ADD *r_u)
+WERROR _srvsvc_NetShareAdd(pipes_struct *p, struct srvsvc_NetShareAdd *r)
{
- struct current_user user;
- pstring command;
- fstring share_name;
- fstring comment;
+ pstring share_name;
+ pstring comment;
pstring pathname;
- int type;
- int snum;
- int ret;
char *path;
+ int type;
SEC_DESC *psd = NULL;
+ SE_PRIV se_diskop = SE_DISK_OPERATOR;
+ BOOL is_disk_op;
+ uint32 max_connections = 0;
+ WERROR err;
DEBUG(5,("_srv_net_share_add: %d\n", __LINE__));
- r_u->parm_error = 0;
-
- get_current_user(&user,p);
-
- if (user.uid != sec_initial_uid()) {
- DEBUG(10,("_srv_net_share_add: uid != sec_initial_uid(). Access denied.\n"));
- return WERR_ACCESS_DENIED;
+ if (r->out.parm_error) {
+ *r->out.parm_error = 0;
}
- if (!lp_add_share_cmd() || !*lp_add_share_cmd()) {
- DEBUG(10,("_srv_net_share_add: No add share command\n"));
+ is_disk_op = user_has_privileges( p->pipe_user.nt_user_token,
+ &se_diskop );
+
+ if (p->pipe_user.ut.uid != sec_initial_uid() && !is_disk_op )
return WERR_ACCESS_DENIED;
- }
- switch (q_u->info_level) {
+ switch (r->in.level) {
case 0:
/* No path. Not enough info in a level 0 to do anything. */
return WERR_ACCESS_DENIED;
/* Not enough info in a level 1 to do anything. */
return WERR_ACCESS_DENIED;
case 2:
- unistr2_to_ascii(share_name, &q_u->info.share.info2.info_2_str.uni_netname, sizeof(share_name));
- unistr2_to_ascii(comment, &q_u->info.share.info2.info_2_str.uni_remark, sizeof(share_name));
- unistr2_to_ascii(pathname, &q_u->info.share.info2.info_2_str.uni_path, sizeof(share_name));
- type = q_u->info.share.info2.info_2.type;
+ pstrcpy(share_name, r->in.info.info2->name);
+ pstrcpy(comment, r->in.info.info2->comment);
+ pstrcpy(pathname, r->in.info.info2->path);
+ max_connections = (r->in.info.info2->max_users == 0xffffffff) ?
+ 0 : r->in.info.info2->max_users;
+ type = r->in.info.info2->type;
break;
case 501:
/* No path. Not enough info in a level 501 to do anything. */
return WERR_ACCESS_DENIED;
case 502:
- unistr2_to_ascii(share_name, &q_u->info.share.info502.info_502_str.uni_netname, sizeof(share_name));
- unistr2_to_ascii(comment, &q_u->info.share.info502.info_502_str.uni_remark, sizeof(share_name));
- unistr2_to_ascii(pathname, &q_u->info.share.info502.info_502_str.uni_path, sizeof(share_name));
- type = q_u->info.share.info502.info_502.type;
- psd = q_u->info.share.info502.info_502_str.sd;
+ pstrcpy(share_name, r->in.info.info502->name);
+ pstrcpy(comment, r->in.info.info502->comment);
+ pstrcpy(pathname, r->in.info.info502->path);
+ type = r->in.info.info502->type;
+ psd = r->in.info.info502->sd;
map_generic_share_sd_bits(psd);
break;
- /* none of the following contain share names. NetShareAdd does not have a separate parameter for the share name */
+ /* none of the following contain share names. NetShareAdd
+ * does not have a separate parameter for the share name */
case 1004:
case 1005:
case 1006:
case 1007:
return WERR_ACCESS_DENIED;
- break;
case 1501:
/* DFS only level. */
return WERR_ACCESS_DENIED;
default:
- DEBUG(5,("_srv_net_share_add: unsupported switch value %d\n", q_u->info_level));
+ DEBUG(5,("_srv_net_share_add: unsupported switch value %d\n",
+ r->in.level));
return WERR_UNKNOWN_LEVEL;
}
- if (strequal(share_name,"IPC$") || strequal(share_name,"ADMIN$") || strequal(share_name,"global"))
- return WERR_ACCESS_DENIED;
+ /* check for invalid share names */
- snum = find_service(share_name);
+ if ( !validate_net_name( share_name, INVALID_SHARENAME_CHARS,
+ sizeof(share_name) ) ) {
+ DEBUG(5,("_srv_net_name_validate: Bad sharename \"%s\"\n",
+ share_name));
+ return WERR_INVALID_NAME;
+ }
+
+ if ( strequal(share_name,"IPC$") || strequal(share_name,"global")
+ || ( lp_enable_asu_support() && strequal(share_name,"ADMIN$") ) )
+ {
+ return WERR_ACCESS_DENIED;
+ }
- /* Share already exists. */
- if (snum >= 0)
+ if (get_share_params(p->mem_ctx, share_name) != NULL) {
+ /* Share already exists. */
return WERR_ALREADY_EXISTS;
+ }
/* We can only add disk shares. */
if (type != STYPE_DISKTREE)
if (!(path = valid_share_pathname( pathname )))
return WERR_OBJECT_PATH_INVALID;
- /* Ensure share name, pathname and comment don't contain '"' characters. */
+ /* Ensure share name, pathname and comment don't contain '"'
+ * characters. */
+
string_replace(share_name, '"', ' ');
string_replace(path, '"', ' ');
string_replace(comment, '"', ' ');
- slprintf(command, sizeof(command)-1, "%s \"%s\" \"%s\" \"%s\" \"%s\"",
- lp_add_share_cmd(), dyn_CONFIGFILE, share_name, path, comment);
-
- DEBUG(10,("_srv_net_share_add: Running [%s]\n", command ));
- if ((ret = smbrun(command, NULL)) != 0) {
- DEBUG(0,("_srv_net_share_add: Running [%s] returned (%d)\n", command, ret ));
- return WERR_ACCESS_DENIED;
- }
-
- /* Check if the new share pathname exist, if not try to delete the
- * share and return an error */
- if (!exist_share_pathname(path)) {
- DEBUG(1, ("_srv_net_share_add: add share command was ok but path (%s) has not been created!\n", path));
- DEBUG(1, ("_srv_net_share_add: trying to rollback and delete the share\n"));
-
- if (!lp_delete_share_cmd() || !*lp_delete_share_cmd()) {
- DEBUG(1, ("_srv_net_share_add: Error! delete share command is not defined! Please check share (%s) in the config file\n", share_name));
- return WERR_OBJECT_PATH_INVALID;
- }
-
- slprintf(command, sizeof(command)-1, "%s \"%s\" \"%s\"",
- lp_delete_share_cmd(), dyn_CONFIGFILE, share_name);
+ err = add_share(share_name, path, comment, max_connections,
+ p->pipe_user.nt_user_token, is_disk_op);
- DEBUG(10,("_srv_net_share_add: Running [%s]\n", command ));
- if ((ret = smbrun(command, NULL)) != 0) {
- DEBUG(0,("_srv_net_share_add: Running [%s] returned (%d)\n", command, ret ));
- DEBUG(1, ("_srv_net_share_add: Error! delete share command failed! Please check share (%s) in the config file\n", share_name));
- }
-
- return WERR_OBJECT_PATH_INVALID;
+ if (!W_ERROR_IS_OK(err)) {
+ return err;
}
if (psd) {
- if (!set_share_security(p->mem_ctx, share_name, psd)) {
- DEBUG(0,("_srv_net_share_add: Failed to add security info to share %s.\n", share_name ));
+ if (!set_share_security(share_name, psd)) {
+ DEBUG(0,("_srv_net_share_add: Failed to add security "
+ "info to share %s.\n", share_name ));
}
}
- /* Tell everyone we updated smb.conf. */
- message_send_all(conn_tdb_ctx(), MSG_SMB_CONF_UPDATED, NULL, 0, False, NULL);
-
/*
* We don't call reload_services() here, the message will
* cause this to be done before the next packet is read
a parameter.
********************************************************************/
-WERROR _srv_net_share_del(pipes_struct *p, SRV_Q_NET_SHARE_DEL *q_u, SRV_R_NET_SHARE_DEL *r_u)
+WERROR _srvsvc_NetShareDel(pipes_struct *p, struct srvsvc_NetShareDel *r)
{
- struct current_user user;
- pstring command;
- fstring share_name;
- int ret;
- int snum;
+ struct share_params *params;
+ SE_PRIV se_diskop = SE_DISK_OPERATOR;
+ BOOL is_disk_op;
+ WERROR err;
DEBUG(5,("_srv_net_share_del: %d\n", __LINE__));
- unistr2_to_ascii(share_name, &q_u->uni_share_name, sizeof(share_name));
-
- if (strequal(share_name,"IPC$") || strequal(share_name,"ADMIN$") || strequal(share_name,"global"))
+ if ( strequal(r->in.share_name, "IPC$")
+ || ( lp_enable_asu_support() && strequal(r->in.share_name,"ADMIN$") )
+ || strequal(r->in.share_name, "global") )
+ {
return WERR_ACCESS_DENIED;
+ }
- snum = find_service(share_name);
-
- if (snum < 0)
+ if (!(params = get_share_params(p->mem_ctx, r->in.share_name))) {
return WERR_NO_SUCH_SHARE;
+ }
/* No change to printer shares. */
- if (lp_print_ok(snum))
+ if (lp_print_ok(params->service))
return WERR_ACCESS_DENIED;
- get_current_user(&user,p);
+ is_disk_op = user_has_privileges( p->pipe_user.nt_user_token,
+ &se_diskop );
- if (user.uid != sec_initial_uid())
+ if (p->pipe_user.ut.uid != sec_initial_uid() && !is_disk_op )
return WERR_ACCESS_DENIED;
- if (!lp_delete_share_cmd() || !*lp_delete_share_cmd())
- return WERR_ACCESS_DENIED;
-
- slprintf(command, sizeof(command)-1, "%s \"%s\" \"%s\"",
- lp_delete_share_cmd(), dyn_CONFIGFILE, lp_servicename(snum));
+ err = delete_share(lp_servicename(params->service),
+ p->pipe_user.nt_user_token, is_disk_op);
- DEBUG(10,("_srv_net_share_del: Running [%s]\n", command ));
- if ((ret = smbrun(command, NULL)) != 0) {
- DEBUG(0,("_srv_net_share_del: Running [%s] returned (%d)\n", command, ret ));
- return WERR_ACCESS_DENIED;
+ if (!W_ERROR_IS_OK(err)) {
+ return err;
}
/* Delete the SD in the database. */
- delete_share_security(snum);
-
- /* Tell everyone we updated smb.conf. */
- message_send_all(conn_tdb_ctx(), MSG_SMB_CONF_UPDATED, NULL, 0, False, NULL);
+ delete_share_security(params);
- lp_killservice(snum);
+ lp_killservice(params->service);
return WERR_OK;
}
-WERROR _srv_net_share_del_sticky(pipes_struct *p, SRV_Q_NET_SHARE_DEL *q_u, SRV_R_NET_SHARE_DEL *r_u)
+WERROR _srvsvc_NetShareDelSticky(pipes_struct *p, struct srvsvc_NetShareDelSticky *r)
{
+ struct srvsvc_NetShareDel s;
+
DEBUG(5,("_srv_net_share_del_stick: %d\n", __LINE__));
- return _srv_net_share_del(p, q_u, r_u);
+ s.in.server_unc = r->in.server_unc;
+ s.in.share_name = r->in.share_name;
+ s.in.reserved = r->in.reserved;
+
+ return _srvsvc_NetShareDel(p, &s);
}
/*******************************************************************
time of day
********************************************************************/
-WERROR _srv_net_remote_tod(pipes_struct *p, SRV_Q_NET_REMOTE_TOD *q_u, SRV_R_NET_REMOTE_TOD *r_u)
+WERROR _srvsvc_NetRemoteTOD(pipes_struct *p, struct srvsvc_NetRemoteTOD *r)
{
- TIME_OF_DAY_INFO *tod;
struct tm *t;
time_t unixdate = time(NULL);
+ WERROR status = WERR_OK;
- tod = (TIME_OF_DAY_INFO *)talloc(p->mem_ctx, sizeof(TIME_OF_DAY_INFO));
- if (!tod)
- return WERR_NOMEM;
+ /* We do this call first as if we do it *after* the gmtime call
+ it overwrites the pointed-to values. JRA */
- ZERO_STRUCTP(tod);
-
- r_u->tod = tod;
- r_u->ptr_srv_tod = 0x1;
- r_u->status = WERR_OK;
+ uint32 zone = get_time_zone(unixdate)/60;
DEBUG(5,("_srv_net_remote_tod: %d\n", __LINE__));
t = gmtime(&unixdate);
/* set up the */
- init_time_of_day_info(tod,
- unixdate,
- 0,
- t->tm_hour,
- t->tm_min,
- t->tm_sec,
- 0,
- TimeDiff(unixdate)/60,
- 10000,
- t->tm_mday,
- t->tm_mon + 1,
- 1900+t->tm_year,
- t->tm_wday);
+ r->out.info->elapsed = unixdate;
+ r->out.info->msecs = 0;
+ r->out.info->hours = t->tm_hour;
+ r->out.info->mins = t->tm_min;
+ r->out.info->secs = t->tm_sec;
+ r->out.info->hunds = 0;
+ r->out.info->timezone = zone;
+ r->out.info->tinterval = 10000;
+ r->out.info->day = t->tm_mday;
+ r->out.info->month = t->tm_mon + 1;
+ r->out.info->year = 1900+t->tm_year;
+ r->out.info->weekday = t->tm_wday;
DEBUG(5,("_srv_net_remote_tod: %d\n", __LINE__));
- return r_u->status;
+ return status;
}
/***********************************************************************************
Win9x NT tools get security descriptor.
***********************************************************************************/
-WERROR _srv_net_file_query_secdesc(pipes_struct *p, SRV_Q_NET_FILE_QUERY_SECDESC *q_u,
- SRV_R_NET_FILE_QUERY_SECDESC *r_u)
+WERROR _srvsvc_NetGetFileSecurity(pipes_struct *p, struct srvsvc_NetGetFileSecurity *r)
{
SEC_DESC *psd = NULL;
size_t sd_size;
DATA_BLOB null_pw;
- pstring filename;
- pstring qualname;
files_struct *fsp = NULL;
SMB_STRUCT_STAT st;
- BOOL bad_path;
- int access_mode;
- int action;
NTSTATUS nt_status;
- struct current_user user;
connection_struct *conn = NULL;
BOOL became_user = False;
+ WERROR status = WERR_OK;
+ pstring tmp_file;
ZERO_STRUCT(st);
- r_u->status = WERR_OK;
-
- unistr2_to_ascii(qualname, &q_u->uni_qual_name, sizeof(qualname));
/* Null password is ok - we are already an authenticated user... */
- null_pw = data_blob(NULL, 0);
-
- get_current_user(&user, p);
+ null_pw = data_blob_null;
become_root();
- conn = make_connection(qualname, null_pw, "A:", user.vuid, &nt_status);
+ conn = make_connection(r->in.share, null_pw, "A:", p->pipe_user.vuid, &nt_status);
unbecome_root();
if (conn == NULL) {
- DEBUG(3,("_srv_net_file_query_secdesc: Unable to connect to %s\n", qualname));
- r_u->status = ntstatus_to_werror(nt_status);
+ DEBUG(3,("_srv_net_file_query_secdesc: Unable to connect to %s\n", r->in.share));
+ status = ntstatus_to_werror(nt_status);
goto error_exit;
}
if (!become_user(conn, conn->vuid)) {
DEBUG(0,("_srv_net_file_query_secdesc: Can't become connected user!\n"));
- r_u->status = WERR_ACCESS_DENIED;
+ status = WERR_ACCESS_DENIED;
goto error_exit;
}
became_user = True;
- unistr2_to_ascii(filename, &q_u->uni_file_name, sizeof(filename));
- unix_convert(filename, conn, NULL, &bad_path, &st);
- fsp = open_file_shared(conn, filename, &st, SET_OPEN_MODE(DOS_OPEN_RDONLY),
- (FILE_FAIL_IF_NOT_EXIST|FILE_EXISTS_OPEN), FILE_ATTRIBUTE_NORMAL, 0, &access_mode, &action);
+ pstrcpy(tmp_file, r->in.file);
+ nt_status = unix_convert(conn, tmp_file, False, NULL, &st);
+ if (!NT_STATUS_IS_OK(nt_status)) {
+ DEBUG(3,("_srv_net_file_query_secdesc: bad pathname %s\n", r->in.file));
+ status = WERR_ACCESS_DENIED;
+ goto error_exit;
+ }
- if (!fsp) {
- /* Perhaps it is a directory */
- if (errno == EISDIR)
- fsp = open_directory(conn, filename, &st,FILE_READ_ATTRIBUTES,0,
- (FILE_FAIL_IF_NOT_EXIST|FILE_EXISTS_OPEN), &action);
+ nt_status = check_name(conn, r->in.file);
+ if (!NT_STATUS_IS_OK(nt_status)) {
+ DEBUG(3,("_srv_net_file_query_secdesc: can't access %s\n", r->in.file));
+ status = WERR_ACCESS_DENIED;
+ goto error_exit;
+ }
- if (!fsp) {
- DEBUG(3,("_srv_net_file_query_secdesc: Unable to open file %s\n", filename));
- r_u->status = WERR_ACCESS_DENIED;
+ nt_status = open_file_stat(conn, NULL, r->in.file, &st, &fsp);
+ if (!NT_STATUS_IS_OK(nt_status)) {
+ /* Perhaps it is a directory */
+ if (NT_STATUS_EQUAL(nt_status, NT_STATUS_FILE_IS_A_DIRECTORY))
+ nt_status = open_directory(conn, NULL, r->in.file, &st,
+ READ_CONTROL_ACCESS,
+ FILE_SHARE_READ|FILE_SHARE_WRITE,
+ FILE_OPEN,
+ 0,
+ FILE_ATTRIBUTE_DIRECTORY,
+ NULL, &fsp);
+
+ if (!NT_STATUS_IS_OK(nt_status)) {
+ DEBUG(3,("_srv_net_file_query_secdesc: Unable to open file %s\n", r->in.file));
+ status = WERR_ACCESS_DENIED;
goto error_exit;
}
}
sd_size = SMB_VFS_GET_NT_ACL(fsp, fsp->fsp_name, (OWNER_SECURITY_INFORMATION|GROUP_SECURITY_INFORMATION|DACL_SECURITY_INFORMATION), &psd);
if (sd_size == 0) {
- DEBUG(3,("_srv_net_file_query_secdesc: Unable to get NT ACL for file %s\n", filename));
- r_u->status = WERR_ACCESS_DENIED;
+ DEBUG(3,("_srv_net_file_query_secdesc: Unable to get NT ACL for file %s\n", r->in.file));
+ status = WERR_ACCESS_DENIED;
goto error_exit;
}
- r_u->ptr_response = 1;
- r_u->size_response = sd_size;
- r_u->ptr_secdesc = 1;
- r_u->size_secdesc = sd_size;
- r_u->sec_desc = psd;
+ r->out.sd_buf->sd_size= sd_size;
+ r->out.sd_buf->sd = psd;
psd->dacl->revision = (uint16) NT4_ACL_REVISION;
- close_file(fsp, True);
+ close_file(fsp, NORMAL_CLOSE);
unbecome_user();
- close_cnum(conn, user.vuid);
- return r_u->status;
+ close_cnum(conn, p->pipe_user.vuid);
+ return status;
error_exit:
if(fsp) {
- close_file(fsp, True);
+ close_file(fsp, NORMAL_CLOSE);
}
if (became_user)
unbecome_user();
if (conn)
- close_cnum(conn, user.vuid);
+ close_cnum(conn, p->pipe_user.vuid);
- return r_u->status;
+ return status;
}
/***********************************************************************************
Win9x NT tools set security descriptor.
***********************************************************************************/
-WERROR _srv_net_file_set_secdesc(pipes_struct *p, SRV_Q_NET_FILE_SET_SECDESC *q_u,
- SRV_R_NET_FILE_SET_SECDESC *r_u)
+WERROR _srvsvc_NetSetFileSecurity(pipes_struct *p, struct srvsvc_NetSetFileSecurity *r)
{
- BOOL ret;
- pstring filename;
- pstring qualname;
DATA_BLOB null_pw;
files_struct *fsp = NULL;
SMB_STRUCT_STAT st;
- BOOL bad_path;
- int access_mode;
- int action;
NTSTATUS nt_status;
- struct current_user user;
connection_struct *conn = NULL;
BOOL became_user = False;
+ WERROR status = WERR_OK;
+ pstring tmp_file;
ZERO_STRUCT(st);
- r_u->status = WERR_OK;
-
- unistr2_to_ascii(qualname, &q_u->uni_qual_name, sizeof(qualname));
-
/* Null password is ok - we are already an authenticated user... */
- null_pw = data_blob(NULL, 0);
-
- get_current_user(&user, p);
+ null_pw = data_blob_null;
become_root();
- conn = make_connection(qualname, null_pw, "A:", user.vuid, &nt_status);
+ conn = make_connection(r->in.share, null_pw, "A:", p->pipe_user.vuid, &nt_status);
unbecome_root();
if (conn == NULL) {
- DEBUG(3,("_srv_net_file_set_secdesc: Unable to connect to %s\n", qualname));
- r_u->status = ntstatus_to_werror(nt_status);
+ DEBUG(3,("_srv_net_file_set_secdesc: Unable to connect to %s\n", r->in.share));
+ status = ntstatus_to_werror(nt_status);
goto error_exit;
}
if (!become_user(conn, conn->vuid)) {
DEBUG(0,("_srv_net_file_set_secdesc: Can't become connected user!\n"));
- r_u->status = WERR_ACCESS_DENIED;
+ status = WERR_ACCESS_DENIED;
goto error_exit;
}
became_user = True;
- unistr2_to_ascii(filename, &q_u->uni_file_name, sizeof(filename));
- unix_convert(filename, conn, NULL, &bad_path, &st);
+ pstrcpy(tmp_file, r->in.file);
+ nt_status = unix_convert(conn, tmp_file, False, NULL, &st);
+ if (!NT_STATUS_IS_OK(nt_status)) {
+ DEBUG(3,("_srv_net_file_set_secdesc: bad pathname %s\n", r->in.file));
+ status = WERR_ACCESS_DENIED;
+ goto error_exit;
+ }
+
+ nt_status = check_name(conn, r->in.file);
+ if (!NT_STATUS_IS_OK(nt_status)) {
+ DEBUG(3,("_srv_net_file_set_secdesc: can't access %s\n", r->in.file));
+ status = WERR_ACCESS_DENIED;
+ goto error_exit;
+ }
- fsp = open_file_shared(conn, filename, &st, SET_OPEN_MODE(DOS_OPEN_RDWR),
- (FILE_FAIL_IF_NOT_EXIST|FILE_EXISTS_OPEN), FILE_ATTRIBUTE_NORMAL, 0, &access_mode, &action);
- if (!fsp) {
- /* Perhaps it is a directory */
- if (errno == EISDIR)
- fsp = open_directory(conn, filename, &st,FILE_READ_ATTRIBUTES,0,
- (FILE_FAIL_IF_NOT_EXIST|FILE_EXISTS_OPEN), &action);
+ nt_status = open_file_stat(conn, NULL, r->in.file, &st, &fsp);
- if (!fsp) {
- DEBUG(3,("_srv_net_file_set_secdesc: Unable to open file %s\n", filename));
- r_u->status = WERR_ACCESS_DENIED;
+ if (!NT_STATUS_IS_OK(nt_status)) {
+ /* Perhaps it is a directory */
+ if (NT_STATUS_EQUAL(nt_status, NT_STATUS_FILE_IS_A_DIRECTORY))
+ nt_status = open_directory(conn, NULL, r->in.file, &st,
+ FILE_READ_ATTRIBUTES,
+ FILE_SHARE_READ|FILE_SHARE_WRITE,
+ FILE_OPEN,
+ 0,
+ FILE_ATTRIBUTE_DIRECTORY,
+ NULL, &fsp);
+
+ if (!NT_STATUS_IS_OK(nt_status)) {
+ DEBUG(3,("_srv_net_file_set_secdesc: Unable to open file %s\n", r->in.file));
+ status = WERR_ACCESS_DENIED;
goto error_exit;
}
}
- ret = SMB_VFS_SET_NT_ACL(fsp, fsp->fsp_name, q_u->sec_info, q_u->sec_desc);
+ nt_status = SMB_VFS_SET_NT_ACL(fsp, fsp->fsp_name, r->in.securityinformation, r->in.sd_buf.sd);
- if (ret == False) {
- DEBUG(3,("_srv_net_file_set_secdesc: Unable to set NT ACL on file %s\n", filename));
- r_u->status = WERR_ACCESS_DENIED;
+ if (!NT_STATUS_IS_OK(nt_status)) {
+ DEBUG(3,("_srv_net_file_set_secdesc: Unable to set NT ACL on file %s\n", r->in.file));
+ status = WERR_ACCESS_DENIED;
goto error_exit;
}
- close_file(fsp, True);
+ close_file(fsp, NORMAL_CLOSE);
unbecome_user();
- close_cnum(conn, user.vuid);
- return r_u->status;
+ close_cnum(conn, p->pipe_user.vuid);
+ return status;
error_exit:
if(fsp) {
- close_file(fsp, True);
+ close_file(fsp, NORMAL_CLOSE);
}
- if (became_user)
+ if (became_user) {
unbecome_user();
+ }
- if (conn)
- close_cnum(conn, user.vuid);
+ if (conn) {
+ close_cnum(conn, p->pipe_user.vuid);
+ }
- return r_u->status;
+ return status;
}
/***********************************************************************************
return disk;
}
-WERROR _srv_net_disk_enum(pipes_struct *p, SRV_Q_NET_DISK_ENUM *q_u, SRV_R_NET_DISK_ENUM *r_u)
+WERROR _srvsvc_NetDiskEnum(pipes_struct *p, struct srvsvc_NetDiskEnum *r)
{
uint32 i;
const char *disk_name;
- TALLOC_CTX *ctx = p->mem_ctx;
- uint32 resume=get_enum_hnd(&q_u->enum_hnd);
- r_u->status=WERR_OK;
+ WERROR status = WERR_OK;
- r_u->total_entries = init_server_disk_enum(&resume);
+ *r->out.totalentries = init_server_disk_enum(r->in.resume_handle);
+ r->out.info->count = 0;
- r_u->disk_enum_ctr.unknown = 0;
+ if(!(r->out.info->disks = TALLOC_ARRAY(p->mem_ctx, struct srvsvc_NetDiskInfo0, MAX_SERVER_DISK_ENTRIES))) {
+ return WERR_NOMEM;
+ }
- {
- DISK_INFO *dinfo;
+ /*allow one struct srvsvc_NetDiskInfo0 for null terminator*/
- int dinfo_size = MAX_SERVER_DISK_ENTRIES * sizeof(*dinfo);
-
- if(!(dinfo = talloc(ctx, dinfo_size))) {
- return WERR_NOMEM;
- }
+ for(i = 0; i < MAX_SERVER_DISK_ENTRIES -1 && (disk_name = next_server_disk_enum(r->in.resume_handle)); i++) {
+
+ r->out.info->count++;
+ (*r->out.totalentries)++;
+
+ /*copy disk name into a unicode string*/
- r_u->disk_enum_ctr.disk_info = dinfo;
+ r->out.info->disks[i].disk = disk_name;
}
- r_u->disk_enum_ctr.disk_info_ptr = r_u->disk_enum_ctr.disk_info ? 1 : 0;
+ /* add a terminating null string. Is this there if there is more data to come? */
- /*allow one DISK_INFO for null terminator*/
+ r->out.info->count++;
+ (*r->out.totalentries)++;
- for(i = 0; i < MAX_SERVER_DISK_ENTRIES -1 && (disk_name = next_server_disk_enum(&resume)); i++) {
+ r->out.info->disks[i].disk = "";
- r_u->disk_enum_ctr.entries_read++;
+ return status;
+}
- /*copy disk name into a unicode string*/
+/********************************************************************
+********************************************************************/
+
+WERROR _srvsvc_NetNameValidate(pipes_struct *p, struct srvsvc_NetNameValidate *r)
+{
+ int len;
- init_unistr3(&r_u->disk_enum_ctr.disk_info[i].disk_name, disk_name);
+ if ((r->in.flags != 0x0) && (r->in.flags != 0x80000000)) {
+ return WERR_INVALID_PARAM;
}
- /* add a terminating null string. Is this there if there is more data to come? */
+ switch ( r->in.name_type ) {
+ case 0x9:
+ len = strlen_m(r->in.name);
- r_u->disk_enum_ctr.entries_read++;
+ if ((r->in.flags == 0x0) && (len > 81)) {
+ DEBUG(5,("_srv_net_name_validate: share name too long (%s > 81 chars)\n", r->in.name));
+ return WERR_INVALID_NAME;
+ }
+ if ((r->in.flags == 0x80000000) && (len > 13)) {
+ DEBUG(5,("_srv_net_name_validate: share name too long (%s > 13 chars)\n", r->in.name));
+ return WERR_INVALID_NAME;
+ }
- init_unistr3(&r_u->disk_enum_ctr.disk_info[i].disk_name, "");
+ if ( ! validate_net_name( r->in.name, INVALID_SHARENAME_CHARS, sizeof(r->in.name) ) ) {
+ DEBUG(5,("_srv_net_name_validate: Bad sharename \"%s\"\n", r->in.name));
+ return WERR_INVALID_NAME;
+ }
+ break;
- init_enum_hnd(&r_u->enum_hnd, resume);
+ default:
+ return WERR_UNKNOWN_LEVEL;
+ }
- return r_u->status;
+ return WERR_OK;
}
-WERROR _srv_net_name_validate(pipes_struct *p, SRV_Q_NET_NAME_VALIDATE *q_u, SRV_R_NET_NAME_VALIDATE *r_u)
+
+/********************************************************************
+********************************************************************/
+
+WERROR _srvsvc_NetFileClose(pipes_struct *p, struct srvsvc_NetFileClose *r)
{
- int snum;
- fstring share_name;
+ return WERR_ACCESS_DENIED;
+}
- r_u->status=WERR_OK;
+WERROR _srvsvc_NetCharDevEnum(pipes_struct *p, struct srvsvc_NetCharDevEnum *r)
+{
+ p->rng_fault_state = True;
+ return WERR_NOT_SUPPORTED;
+}
- switch(q_u->type) {
+WERROR _srvsvc_NetCharDevGetInfo(pipes_struct *p, struct srvsvc_NetCharDevGetInfo *r)
+{
+ p->rng_fault_state = True;
+ return WERR_NOT_SUPPORTED;
+}
- case 0x9:
+WERROR _srvsvc_NetCharDevControl(pipes_struct *p, struct srvsvc_NetCharDevControl *r)
+{
+ p->rng_fault_state = True;
+ return WERR_NOT_SUPPORTED;
+}
- /*check if share name is ok*/
- /*also check if we already have a share with this name*/
+WERROR _srvsvc_NetCharDevQEnum(pipes_struct *p, struct srvsvc_NetCharDevQEnum *r)
+{
+ p->rng_fault_state = True;
+ return WERR_NOT_SUPPORTED;
+}
- unistr2_to_ascii(share_name, &q_u->uni_name, sizeof(share_name));
- snum = find_service(share_name);
+WERROR _srvsvc_NetCharDevQGetInfo(pipes_struct *p, struct srvsvc_NetCharDevQGetInfo *r)
+{
+ p->rng_fault_state = True;
+ return WERR_NOT_SUPPORTED;
+}
- /* Share already exists. */
- if (snum >= 0)
- r_u->status = WERR_ALREADY_EXISTS;
- break;
+WERROR _srvsvc_NetCharDevQSetInfo(pipes_struct *p, struct srvsvc_NetCharDevQSetInfo *r)
+{
+ p->rng_fault_state = True;
+ return WERR_NOT_SUPPORTED;
+}
- default:
- /*unsupported type*/
- r_u->status = WERR_UNKNOWN_LEVEL;
- break;
- }
+WERROR _srvsvc_NetCharDevQPurge(pipes_struct *p, struct srvsvc_NetCharDevQPurge *r)
+{
+ p->rng_fault_state = True;
+ return WERR_NOT_SUPPORTED;
+}
+
+WERROR _srvsvc_NetCharDevQPurgeSelf(pipes_struct *p, struct srvsvc_NetCharDevQPurgeSelf *r)
+{
+ p->rng_fault_state = True;
+ return WERR_NOT_SUPPORTED;
+}
+
+WERROR _srvsvc_NetFileGetInfo(pipes_struct *p, struct srvsvc_NetFileGetInfo *r)
+{
+ p->rng_fault_state = True;
+ return WERR_NOT_SUPPORTED;
+}
+
+WERROR _srvsvc_NetShareCheck(pipes_struct *p, struct srvsvc_NetShareCheck *r)
+{
+ p->rng_fault_state = True;
+ return WERR_NOT_SUPPORTED;
+}
+
+WERROR _srvsvc_NetServerStatisticsGet(pipes_struct *p, struct srvsvc_NetServerStatisticsGet *r)
+{
+ p->rng_fault_state = True;
+ return WERR_NOT_SUPPORTED;
+}
+
+WERROR _srvsvc_NetTransportAdd(pipes_struct *p, struct srvsvc_NetTransportAdd *r)
+{
+ p->rng_fault_state = True;
+ return WERR_NOT_SUPPORTED;
+}
+
+WERROR _srvsvc_NetTransportEnum(pipes_struct *p, struct srvsvc_NetTransportEnum *r)
+{
+ p->rng_fault_state = True;
+ return WERR_NOT_SUPPORTED;
+}
- return r_u->status;
+WERROR _srvsvc_NetTransportDel(pipes_struct *p, struct srvsvc_NetTransportDel *r)
+{
+ p->rng_fault_state = True;
+ return WERR_NOT_SUPPORTED;
+}
+
+WERROR _srvsvc_NetSetServiceBits(pipes_struct *p, struct srvsvc_NetSetServiceBits *r)
+{
+ p->rng_fault_state = True;
+ return WERR_NOT_SUPPORTED;
+}
+
+WERROR _srvsvc_NetPathType(pipes_struct *p, struct srvsvc_NetPathType *r)
+{
+ p->rng_fault_state = True;
+ return WERR_NOT_SUPPORTED;
+}
+
+WERROR _srvsvc_NetPathCanonicalize(pipes_struct *p, struct srvsvc_NetPathCanonicalize *r)
+{
+ p->rng_fault_state = True;
+ return WERR_NOT_SUPPORTED;
+}
+
+WERROR _srvsvc_NetPathCompare(pipes_struct *p, struct srvsvc_NetPathCompare *r)
+{
+ p->rng_fault_state = True;
+ return WERR_NOT_SUPPORTED;
+}
+
+WERROR _srvsvc_NETRPRNAMECANONICALIZE(pipes_struct *p, struct srvsvc_NETRPRNAMECANONICALIZE *r)
+{
+ p->rng_fault_state = True;
+ return WERR_NOT_SUPPORTED;
+}
+
+WERROR _srvsvc_NetPRNameCompare(pipes_struct *p, struct srvsvc_NetPRNameCompare *r)
+{
+ p->rng_fault_state = True;
+ return WERR_NOT_SUPPORTED;
+}
+
+WERROR _srvsvc_NetShareDelStart(pipes_struct *p, struct srvsvc_NetShareDelStart *r)
+{
+ p->rng_fault_state = True;
+ return WERR_NOT_SUPPORTED;
+}
+
+WERROR _srvsvc_NetShareDelCommit(pipes_struct *p, struct srvsvc_NetShareDelCommit *r)
+{
+ p->rng_fault_state = True;
+ return WERR_NOT_SUPPORTED;
+}
+
+WERROR _srvsvc_NetServerTransportAddEx(pipes_struct *p, struct srvsvc_NetServerTransportAddEx *r)
+{
+ p->rng_fault_state = True;
+ return WERR_NOT_SUPPORTED;
+}
+
+WERROR _srvsvc_NetServerSetServiceBitsEx(pipes_struct *p, struct srvsvc_NetServerSetServiceBitsEx *r)
+{
+ p->rng_fault_state = True;
+ return WERR_NOT_SUPPORTED;
+}
+
+WERROR _srvsvc_NETRDFSGETVERSION(pipes_struct *p, struct srvsvc_NETRDFSGETVERSION *r)
+{
+ p->rng_fault_state = True;
+ return WERR_NOT_SUPPORTED;
+}
+
+WERROR _srvsvc_NETRDFSCREATELOCALPARTITION(pipes_struct *p, struct srvsvc_NETRDFSCREATELOCALPARTITION *r)
+{
+ p->rng_fault_state = True;
+ return WERR_NOT_SUPPORTED;
+}
+
+WERROR _srvsvc_NETRDFSDELETELOCALPARTITION(pipes_struct *p, struct srvsvc_NETRDFSDELETELOCALPARTITION *r)
+{
+ p->rng_fault_state = True;
+ return WERR_NOT_SUPPORTED;
+}
+
+WERROR _srvsvc_NETRDFSSETLOCALVOLUMESTATE(pipes_struct *p, struct srvsvc_NETRDFSSETLOCALVOLUMESTATE *R)
+{
+ p->rng_fault_state = True;
+ return WERR_NOT_SUPPORTED;
+}
+
+WERROR _srvsvc_NETRDFSSETSERVERINFO(pipes_struct *p, struct srvsvc_NETRDFSSETSERVERINFO *r)
+{
+ p->rng_fault_state = True;
+ return WERR_NOT_SUPPORTED;
+}
+
+WERROR _srvsvc_NETRDFSCREATEEXITPOINT(pipes_struct *p, struct srvsvc_NETRDFSCREATEEXITPOINT *r)
+{
+ p->rng_fault_state = True;
+ return WERR_NOT_SUPPORTED;
+}
+
+WERROR _srvsvc_NETRDFSDELETEEXITPOINT(pipes_struct *p, struct srvsvc_NETRDFSDELETEEXITPOINT *r)
+{
+ p->rng_fault_state = True;
+ return WERR_NOT_SUPPORTED;
+}
+
+WERROR _srvsvc_NETRSERVERTRANSPORTDELEX(pipes_struct *p, struct srvsvc_NETRSERVERTRANSPORTDELEX *r)
+{
+ p->rng_fault_state = True;
+ return WERR_NOT_SUPPORTED;
+}
+
+WERROR _srvsvc_NETRDFSMANAGERREPORTSITEINFO(pipes_struct *p, struct srvsvc_NETRDFSMANAGERREPORTSITEINFO *r)
+{
+ p->rng_fault_state = True;
+ return WERR_NOT_SUPPORTED;
+}
+
+WERROR _srvsvc_NETRDFSMODIFYPREFIX(pipes_struct *p, struct srvsvc_NETRDFSMODIFYPREFIX *r)
+{
+ p->rng_fault_state = True;
+ return WERR_NOT_SUPPORTED;
+}
+
+WERROR _srvsvc_NETRDFSFIXLOCALVOLUME(pipes_struct *p, struct srvsvc_NETRDFSFIXLOCALVOLUME *r)
+{
+ p->rng_fault_state = True;
+ return WERR_NOT_SUPPORTED;
}
git.samba.org / metze / old / v3-2-winbind-ndr.git / blobdiff