r21856: Re-merge svn r16619 from trunk that was lost when adding PIDL

and then not merging PIDL to SAMBA_3_0_25.

* Rework parsing for NetFileEnum() and NetSessionEnum()
* Add server stub for NetFileClose()
* Return correct information for sessions and open files
  including session duration, number of open files, and open pipes.

9 files changed, 642 insertions, 630 deletions

diff --git a/source/include/rpc_srvsvc.h b/source/include/rpc_srvsvc.h
index 5d32d65c3df..62acce58050 100644
--- a/source/include/rpc_srvsvc.h
+++ b/source/include/rpc_srvsvc.h
@@ -5,6 +5,8 @@
    Copyright (C) Luke Kenneth Casson Leighton 1996-1997
    Copyright (C) Paul Ashton 1997
    Copyright (C) Nigel Williams 2001
+   Copyright (C) Gerald (Jerry) Carter 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
@@ -72,128 +74,84 @@ typedef struct net_srv_disk_enum {
 	WERROR status;               /* return status */
 } SRV_Q_NET_DISK_ENUM, SRV_R_NET_DISK_ENUM;
 
-typedef struct net_name_validate {
-	uint32 ptr_srv_name;
-	UNISTR2 uni_srv_name;
-	UNISTR2 uni_name; /*name to validate*/
+/***************************/
+
+typedef struct  {
+	UNISTR2 *servername;
+	UNISTR2 sharename;
 	uint32 type;
 	uint32 flags;
 	WERROR status;
-} SRV_Q_NET_NAME_VALIDATE, SRV_R_NET_NAME_VALIDATE;
-
-/* SESS_INFO_0 (pointers to level 0 session info strings) */
-typedef struct ptr_sess_info0
-{
-	uint32 ptr_name; /* pointer to name. */
-
-} SESS_INFO_0;
+} SRV_Q_NET_NAME_VALIDATE;
 
-/* SESS_INFO_0_STR (level 0 session info strings) */
-typedef struct str_sess_info0
-{
-	UNISTR2 uni_name; /* unicode string of name */
+typedef struct  {
+	WERROR status;
+} SRV_R_NET_NAME_VALIDATE;
 
-} SESS_INFO_0_STR;
+/***************************/
 
 /* oops - this is going to take up a *massive* amount of stack. */
 /* the UNISTR2s already have 1024 uint16 chars in them... */
-#define MAX_SESS_ENTRIES 32
 
-/* SRV_SESS_INFO_0 */
-typedef struct srv_sess_info_0_info
-{
-	uint32 num_entries_read;                     /* EntriesRead */
-	uint32 ptr_sess_info;                       /* Buffer */
-	uint32 num_entries_read2;                    /* EntriesRead */
+#define MAX_SESS_ENTRIES 32
 
-	SESS_INFO_0     info_0    [MAX_SESS_ENTRIES]; /* session entry pointers */
-	SESS_INFO_0_STR info_0_str[MAX_SESS_ENTRIES]; /* session entry strings */
+typedef struct {
+	UNISTR2 *sharename;
+} SESS_INFO_0;
 
+typedef struct {
+	uint32 num_entries_read;
+	uint32 ptr_sess_info;
+	uint32 num_entries_read2;
+	SESS_INFO_0 info_0[MAX_SESS_ENTRIES];
 } SRV_SESS_INFO_0;
 
-/* SESS_INFO_1 (pointers to level 1 session info strings) */
-typedef struct ptr_sess_info1
-{
-	uint32 ptr_name; /* pointer to name. */
-	uint32 ptr_user; /* pointer to user name. */
-
+typedef struct {
+	UNISTR2 *sharename;
+	UNISTR2 *username;
 	uint32 num_opens;
 	uint32 open_time;
 	uint32 idle_time;
 	uint32 user_flags;
-
 } SESS_INFO_1;
 
-/* SESS_INFO_1_STR (level 1 session info strings) */
-typedef struct str_sess_info1
-{
-	UNISTR2 uni_name; /* unicode string of name */
-	UNISTR2 uni_user; /* unicode string of user */
-
-} SESS_INFO_1_STR;
-
-/* SRV_SESS_INFO_1 */
-typedef struct srv_sess_info_1_info
-{
-	uint32 num_entries_read;                     /* EntriesRead */
-	uint32 ptr_sess_info;                       /* Buffer */
-	uint32 num_entries_read2;                    /* EntriesRead */
-
-	SESS_INFO_1     info_1    [MAX_SESS_ENTRIES]; /* session entry pointers */
-	SESS_INFO_1_STR info_1_str[MAX_SESS_ENTRIES]; /* session entry strings */
-
+typedef struct {
+	uint32 num_entries_read;
+	uint32 ptr_sess_info;
+	uint32 num_entries_read2;
+	SESS_INFO_1 info_1[MAX_SESS_ENTRIES];
 } SRV_SESS_INFO_1;
 
-/* SRV_SESS_INFO_CTR */
-typedef struct srv_sess_info_ctr_info
-{
-	uint32 switch_value;         /* switch value */
-	uint32 ptr_sess_ctr;       /* pointer to sess info union */
-	union
-    {
-		SRV_SESS_INFO_0 info0; /* session info level 0 */
-		SRV_SESS_INFO_1 info1; /* session info level 1 */
-
-    } sess;
+typedef struct {
+	uint32 switch_value;
+	uint32 ptr_sess_ctr;
+	union {
+		SRV_SESS_INFO_0 info0; 
+		SRV_SESS_INFO_1 info1; 
+	} sess;
 
 } SRV_SESS_INFO_CTR;
 
-
-/* SRV_Q_NET_SESS_ENUM */
-typedef struct q_net_sess_enum_info
-{
-	uint32 ptr_srv_name;         /* pointer (to server name?) */
-	UNISTR2 uni_srv_name;        /* server name */
-
-	uint32 ptr_qual_name;         /* pointer (to qualifier name) */
-	UNISTR2 uni_qual_name;        /* qualifier name "\\qualifier" */
-
-	uint32 ptr_user_name;         /* pointer (to user name */
-	UNISTR2 uni_user_name;        /* user name */
-
-	uint32 sess_level;          /* session level */
-
+typedef struct {
+	UNISTR2 *servername;
+	UNISTR2 *qualifier;
+	UNISTR2 *username;
+	uint32 sess_level;
 	SRV_SESS_INFO_CTR *ctr;
-
-	uint32 preferred_len;        /* preferred maximum length (0xffff ffff) */
+	uint32 preferred_len;
 	ENUM_HND enum_hnd;
-
 } SRV_Q_NET_SESS_ENUM;
 
-/* SRV_R_NET_SESS_ENUM */
-typedef struct r_net_sess_enum_info
-{
-	uint32 sess_level;          /* share level */
-
+typedef struct {
+	uint32 sess_level; 
 	SRV_SESS_INFO_CTR *ctr;
-
-	uint32 total_entries;                    /* total number of entries */
+	uint32 total_entries;
 	ENUM_HND enum_hnd;
-
-	WERROR status;               /* return status */
-
+	WERROR status;
 } SRV_R_NET_SESS_ENUM;
 
+/***************************/
+
 /* SRV_Q_NET_SESS_DEL */
 typedef struct q_net_sess_del
 {
@@ -685,104 +643,47 @@ typedef struct r_net_share_del
 
 } SRV_R_NET_SHARE_DEL;
 
-/* FILE_INFO_3 (level 3 file info strings) */
-typedef struct file_info3_info
-{
+/***************************/
+
+typedef struct {
 	uint32 id;            /* file index */
 	uint32 perms;         /* file permissions. don't know what format */
 	uint32 num_locks;     /* file locks */
-	uint32 ptr_path_name; /* file name */
-	uint32 ptr_user_name; /* file owner */
-
+	UNISTR2 *path;        /* file name */
+	UNISTR2 *user;        /* file owner */
 } FILE_INFO_3;
 
-/* FILE_INFO_3_STR (level 3 file info strings) */
-typedef struct str_file_info3_info
-{
-	UNISTR2 uni_path_name; /* unicode string of file name */
-	UNISTR2 uni_user_name; /* unicode string of file owner. */
-
-} FILE_INFO_3_STR;
-
-/* SRV_FILE_INFO_3 */
-typedef struct srv_file_info_3
-{
-	uint32 num_entries_read;                     /* EntriesRead */
-	uint32 ptr_file_info;                        /* Buffer */
-
-	uint32 num_entries_read2;                    /* EntriesRead */
-	FILE_INFO_3     info_3;     /* file entry details */
-	FILE_INFO_3_STR info_3_str; /* file entry strings */
-} SRV_FILE_INFO_3;
-
-/* SRV_FILE_INFO_CTR */
-typedef struct srv_file_info_3_info
-{
-	uint32 switch_value;         /* switch value */
+typedef struct {
+	uint32 level;                /* switch value */
 	uint32 ptr_file_info;        /* pointer to file info union */
 
 	uint32 num_entries;
 	uint32 ptr_entries;
 	uint32 num_entries2;
-	union
-	{
-		SRV_FILE_INFO_3 *info3;
+	union {
+		FILE_INFO_3 *info3;
 	} file;
 
 } SRV_FILE_INFO_CTR;
 
-
-/* SRV_Q_NET_FILE_ENUM */
-typedef struct q_net_file_enum_info
-{
-	uint32 ptr_srv_name;         /* pointer (to server name?) */
-	UNISTR2 uni_srv_name;        /* server name */
-
-	uint32 ptr_qual_name;         /* pointer (to qualifier name) */
-	UNISTR2 uni_qual_name;        /* qualifier name "\\qualifier" */
-
-	uint32 ptr_user_name;         /* pointer (to user name) */
-	UNISTR2 uni_user_name;        /* user name */
-
-	uint32 file_level;          /* file level */
-
+typedef struct {
+	UNISTR2 *servername;
+	UNISTR2 *qualifier;
+	UNISTR2 *username;
+	uint32 level;
 	SRV_FILE_INFO_CTR ctr;
-
-	uint32 preferred_len; /* preferred maximum length (0xffff ffff) */
+	uint32 preferred_len;     /* preferred maximum length (0xffff ffff) */
 	ENUM_HND enum_hnd;
-
 } SRV_Q_NET_FILE_ENUM;
 
-
-/* SRV_R_NET_FILE_ENUM */
-typedef struct r_net_file_enum_info
-{
-	uint32 file_level;          /* file level */
-
+typedef struct {
+	uint32 level;   
 	SRV_FILE_INFO_CTR ctr;
-
-	uint32 total_entries;                    /* total number of files */
+	uint32 total_entries;
 	ENUM_HND enum_hnd;
-
-	WERROR status;        /* return status */
-
+	WERROR status;      
 } SRV_R_NET_FILE_ENUM;
 
-/* SRV_Q_NET_FILE_CLOSE */
-typedef struct q_net_file_close
-{
-	uint32 ptr_srv_name;         /* pointer to server name */
-	UNISTR2 uni_srv_name;        /* server name */
-	
-	uint32 file_id;
-} SRV_Q_NET_FILE_CLOSE;
-
-/* SRV_R_NET_FILE_CLOSE */
-typedef struct r_net_file_close
-{
-	WERROR status;               /* return status */
-} SRV_R_NET_FILE_CLOSE;
-
 /* SRV_INFO_100 */
 typedef struct srv_info_100_info
 {
@@ -967,4 +868,17 @@ typedef struct r_net_file_set_secdesc
 	WERROR status;
 } SRV_R_NET_FILE_SET_SECDESC;
 
+/***************************/
+
+typedef struct {
+	UNISTR2 *servername;
+	uint32 file_id;
+} SRV_Q_NET_FILE_CLOSE;
+
+typedef struct {
+	WERROR status;
+} SRV_R_NET_FILE_CLOSE;
+
+/***************************/
+
 #endif /* _RPC_SRVSVC_H */
diff --git a/source/rpc_client/cli_srvsvc.c b/source/rpc_client/cli_srvsvc.c
index 0d50e94d577..7b4818b4b06 100644
--- a/source/rpc_client/cli_srvsvc.c
+++ b/source/rpc_client/cli_srvsvc.c
@@ -5,6 +5,8 @@
    Copyright (C) Tim Potter 2001
    Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2002
    Copyright (C) Jeremy Allison  2005.
+   Copyright (C) Gerald (Jerry) Carter        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
@@ -537,38 +539,37 @@ WERROR rpccli_srvsvc_net_file_enum(struct rpc_pipe_client *cli, TALLOC_CTX *mem_
 
 	ZERO_STRUCTP(ctr);
 
-	ctr->switch_value = file_level;
+	ctr->level = file_level;
 
 	ctr->num_entries = ctr->num_entries2 = r.ctr.num_entries;
 	
 	switch(file_level) {
 	case 3:
-		ctr->file.info3 = TALLOC_ARRAY(mem_ctx, SRV_FILE_INFO_3, ctr->num_entries);
-		if (ctr->file.info3 == NULL) {
+		if ( (ctr->file.info3 = TALLOC_ARRAY(mem_ctx, FILE_INFO_3, ctr->num_entries)) == NULL ) {
 			return WERR_NOMEM;
 		}
 
-		memset(ctr->file.info3, 0, 
-		       sizeof(SRV_FILE_INFO_3) * ctr->num_entries);
+		memset(ctr->file.info3, 0, sizeof(FILE_INFO_3) * ctr->num_entries);
 
 		for (i = 0; i < r.ctr.num_entries; i++) {
-			SRV_FILE_INFO_3 *info3 = &ctr->file.info3[i];
+			FILE_INFO_3 *info3 = &ctr->file.info3[i];
 			char *s;
 			
 			/* Copy pointer crap */
 
-			memcpy(&info3->info_3, &r.ctr.file.info3[i].info_3, 
-			       sizeof(FILE_INFO_3));
+			memcpy(info3, &r.ctr.file.info3[i], sizeof(FILE_INFO_3));
 
 			/* Duplicate strings */
 
-			s = unistr2_tdup(mem_ctx, &r.ctr.file.info3[i].info_3_str.uni_path_name);
-			if (s)
-				init_unistr2(&info3->info_3_str.uni_path_name, s, UNI_STR_TERMINATE);
+			if ( (s = unistr2_tdup(mem_ctx, r.ctr.file.info3[i].path)) != NULL ) {
+				info3->path = TALLOC_P( mem_ctx, UNISTR2 );
+				init_unistr2(info3->path, s, UNI_STR_TERMINATE);
+			}
 		
-			s = unistr2_tdup(mem_ctx, &r.ctr.file.info3[i].info_3_str.uni_user_name);
-			if (s)
-				init_unistr2(&info3->info_3_str.uni_user_name, s, UNI_STR_TERMINATE);
+			if ( (s = unistr2_tdup(mem_ctx, r.ctr.file.info3[i].user)) != NULL ) {
+				info3->user = TALLOC_P( mem_ctx, UNISTR2 );
+				init_unistr2(info3->user, s, UNI_STR_TERMINATE);
+			}
 
 		}		
 
diff --git a/source/rpc_parse/parse_srv.c b/source/rpc_parse/parse_srv.c
index 7d15eda630f..8ed67872430 100644
--- a/source/rpc_parse/parse_srv.c
+++ b/source/rpc_parse/parse_srv.c
@@ -7,6 +7,7 @@
  *  Copyright (C) Jeremy Allison		    1999,
  *  Copyright (C) Nigel Williams		    2001,
  *  Copyright (C) Jim McDonough (jmcd@us.ibm.com)   2002.
+ *  Copyright (C) Gerald (Jerry) Carter             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
@@ -1588,64 +1589,17 @@ BOOL srv_io_r_net_share_del(const char *desc, SRV_R_NET_SHARE_DEL *q_n, prs_stru
  Inits a SESS_INFO_0_STR structure
 ********************************************************************/
 
-void init_srv_sess_info0_str(SESS_INFO_0_STR *ss0, const char *name)
+void init_srv_sess_info0( SESS_INFO_0 *ss0, const char *name )
 {
-	DEBUG(5,("init_srv_sess_info0_str\n"));
+	ZERO_STRUCTP( ss0 );
 
-	init_unistr2(&ss0->uni_name, name, UNI_STR_TERMINATE);
-}
-
-/*******************************************************************
- Reads or writes a structure.
-********************************************************************/
-
-static BOOL srv_io_sess_info0_str(const char *desc,  SESS_INFO_0_STR *ss0, prs_struct *ps, int depth)
-{
-	if (ss0 == NULL)
-		return False;
-
-	prs_debug(ps, depth, desc, "srv_io_sess_info0_str");
-	depth++;
-
-	if(!prs_align(ps))
-		return False;
-
-	if(!smb_io_unistr2("", &ss0->uni_name, True, ps, depth))
-		return False;
-
-	return True;
-}
-
-/*******************************************************************
- Inits a SESS_INFO_0 structure
-********************************************************************/
-
-void init_srv_sess_info0(SESS_INFO_0 *ss0, const char *name)
-{
-	DEBUG(5,("init_srv_sess_info0: %s\n", name));
-
-	ss0->ptr_name = (name != NULL) ? 1 : 0;
-}
-
-/*******************************************************************
- Reads or writes a structure.
-********************************************************************/
-
-static BOOL srv_io_sess_info0(const char *desc, SESS_INFO_0 *ss0, prs_struct *ps, int depth)
-{
-	if (ss0 == NULL)
-		return False;
-
-	prs_debug(ps, depth, desc, "srv_io_sess_info0");
-	depth++;
-
-	if(!prs_align(ps))
-		return False;
-
-	if(!prs_uint32("ptr_name", ps, depth, &ss0->ptr_name))
-		return False;
-
-	return True;
+	if ( name ) {
+		if ( (ss0->sharename = TALLOC_P( get_talloc_ctx(), UNISTR2 )) == NULL ) {
+			DEBUG(0,("init_srv_sess_info0: talloc failed!\n"));
+			return;
+		}
+		init_unistr2( ss0->sharename, name, UNI_STR_TERMINATE );
+	}
 }
 
 /*******************************************************************
@@ -1681,13 +1635,15 @@ static BOOL srv_io_srv_sess_info_0(const char *desc, SRV_SESS_INFO_0 *ss0, prs_s
 
 		SMB_ASSERT_ARRAY(ss0->info_0, num_entries);
 
+		/* first the pointers */
 		for (i = 0; i < num_entries; i++) {
-			if(!srv_io_sess_info0("", &ss0->info_0[i], ps, depth))
+			if ( !prs_io_unistr2_p("", ps, depth, &ss0->info_0[i].sharename ) )
 				return False;
 		}
 
+		/* now the strings */
 		for (i = 0; i < num_entries; i++) {
-			if(!srv_io_sess_info0_str("", &ss0->info_0_str[i], ps, depth))
+			if ( !prs_io_unistr2("sharename", ps, depth, ss0->info_0[i].sharename ))
 				return False;
 		}
 
@@ -1699,53 +1655,32 @@ static BOOL srv_io_srv_sess_info_0(const char *desc, SRV_SESS_INFO_0 *ss0, prs_s
 }
 
 /*******************************************************************
- Inits a SESS_INFO_1_STR structure
-********************************************************************/
-
-void init_srv_sess_info1_str(SESS_INFO_1_STR *ss1, const char *name, const char *user)
-{
-	DEBUG(5,("init_srv_sess_info1_str\n"));
-
-	init_unistr2(&ss1->uni_name, name, UNI_STR_TERMINATE);
-	init_unistr2(&ss1->uni_user, user, UNI_STR_TERMINATE);
-}
-
-/*******************************************************************
- Reads or writes a structure.
-********************************************************************/
-
-static BOOL srv_io_sess_info1_str(const char *desc, SESS_INFO_1_STR *ss1, prs_struct *ps, int depth)
-{
-	if (ss1 == NULL)
-		return False;
-
-	prs_debug(ps, depth, desc, "srv_io_sess_info1_str");
-	depth++;
-
-	if(!prs_align(ps))
-		return False;
-
-	if(!smb_io_unistr2("", &ss1->uni_name, True, ps, depth))
-		return False;
-	if(!smb_io_unistr2("", &(ss1->uni_user), True, ps, depth))
-		return False;
-
-	return True;
-}
-
-/*******************************************************************
  Inits a SESS_INFO_1 structure
 ********************************************************************/
 
-void init_srv_sess_info1(SESS_INFO_1 *ss1, 
-				const char *name, const char *user,
-				uint32 num_opens, uint32 open_time, uint32 idle_time,
-				uint32 user_flags)
+void init_srv_sess_info1( SESS_INFO_1 *ss1, const char *name, const char *user,
+                          uint32 num_opens, uint32 open_time, uint32 idle_time,
+                          uint32 user_flags)
 {
 	DEBUG(5,("init_srv_sess_info1: %s\n", name));
 
-	ss1->ptr_name = (name != NULL) ? 1 : 0;
-	ss1->ptr_user = (user != NULL) ? 1 : 0;
+	ZERO_STRUCTP( ss1 );
+
+	if ( name ) {
+		if ( (ss1->sharename = TALLOC_P( get_talloc_ctx(), UNISTR2 )) == NULL ) {
+			DEBUG(0,("init_srv_sess_info0: talloc failed!\n"));
+			return;
+		}
+		init_unistr2( ss1->sharename, name, UNI_STR_TERMINATE );
+	}
+
+	if ( user ) {
+		if ( (ss1->username = TALLOC_P( get_talloc_ctx(), UNISTR2 )) == NULL ) {
+			DEBUG(0,("init_srv_sess_info0: talloc failed!\n"));
+			return;
+		}
+		init_unistr2( ss1->username, user, UNI_STR_TERMINATE );
+	}
 
 	ss1->num_opens  = num_opens;
 	ss1->open_time  = open_time;
@@ -1753,37 +1688,6 @@ void init_srv_sess_info1(SESS_INFO_1 *ss1,
 	ss1->user_flags = user_flags;
 }
 
-/*******************************************************************
-reads or writes a structure.
-********************************************************************/
-
-static BOOL srv_io_sess_info1(const char *desc, SESS_INFO_1 *ss1, prs_struct *ps, int depth)
-{
-	if (ss1 == NULL)
-		return False;
-
-	prs_debug(ps, depth, desc, "srv_io_sess_info1");
-	depth++;
-
-	if(!prs_align(ps))
-		return False;
-
-	if(!prs_uint32("ptr_name  ", ps, depth, &ss1->ptr_name))
-		return False;
-	if(!prs_uint32("ptr_user  ", ps, depth, &ss1->ptr_user))
-		return False;
-
-	if(!prs_uint32("num_opens ", ps, depth, &ss1->num_opens))
-		return False;
-	if(!prs_uint32("open_time ", ps, depth, &ss1->open_time))
-		return False;
-	if(!prs_uint32("idle_time ", ps, depth, &ss1->idle_time))
-		return False;
-	if(!prs_uint32("user_flags", ps, depth, &ss1->user_flags))
-		return False;
-
-	return True;
-}
 
 /*******************************************************************
  Reads or writes a structure.
@@ -1818,13 +1722,31 @@ static BOOL srv_io_srv_sess_info_1(const char *desc, SRV_SESS_INFO_1 *ss1, prs_s
 
 		SMB_ASSERT_ARRAY(ss1->info_1, num_entries);
 
+		/* first the pointers and flags */
+
 		for (i = 0; i < num_entries; i++) {
-			if(!srv_io_sess_info1("", &ss1->info_1[i], ps, depth))
+
+			if ( !prs_io_unistr2_p("", ps, depth, &ss1->info_1[i].sharename ))
+				return False;
+			if ( !prs_io_unistr2_p("", ps, depth, &ss1->info_1[i].username ))
+				return False;
+
+			if(!prs_uint32("num_opens ", ps, depth, &ss1->info_1[i].num_opens))
+				return False;
+			if(!prs_uint32("open_time ", ps, depth, &ss1->info_1[i].open_time))
+				return False;
+			if(!prs_uint32("idle_time ", ps, depth, &ss1->info_1[i].idle_time))
+				return False;
+			if(!prs_uint32("user_flags", ps, depth, &ss1->info_1[i].user_flags))
 				return False;
 		}
 
+		/* now the strings */
+
 		for (i = 0; i < num_entries; i++) {
-			if(!srv_io_sess_info1_str("", &ss1->info_1_str[i], ps, depth))
+			if ( !prs_io_unistr2("", ps, depth, ss1->info_1[i].sharename ))
+				return False;
+			if ( !prs_io_unistr2("", ps, depth, ss1->info_1[i].username ))
 				return False;
 		}
 
@@ -1884,36 +1806,12 @@ static BOOL srv_io_srv_sess_ctr(const char *desc, SRV_SESS_INFO_CTR **pp_ctr, pr
 }
 
 /*******************************************************************
- Inits a SRV_Q_NET_SESS_ENUM structure.
-********************************************************************/
-
-void init_srv_q_net_sess_enum(SRV_Q_NET_SESS_ENUM *q_n, 
-			      const char *srv_name, const char *qual_name,
-			      const char *user_name, uint32 sess_level, 
-			      SRV_SESS_INFO_CTR *ctr, uint32 preferred_len,
-			      ENUM_HND *hnd)
-{
-	q_n->ctr = ctr;
-
-	DEBUG(5,("init_q_net_sess_enum\n"));
-
-	init_buf_unistr2(&q_n->uni_srv_name, &q_n->ptr_srv_name, srv_name);
-	init_buf_unistr2(&q_n->uni_qual_name, &q_n->ptr_qual_name, qual_name);
-	init_buf_unistr2(&q_n->uni_user_name, &q_n->ptr_user_name, user_name);
-
-	q_n->sess_level    = sess_level;
-	q_n->preferred_len = preferred_len;
-
-	memcpy(&q_n->enum_hnd, hnd, sizeof(*hnd));
-}
-
-/*******************************************************************
  Reads or writes a structure.
 ********************************************************************/
 
-BOOL srv_io_q_net_sess_enum(const char *desc, SRV_Q_NET_SESS_ENUM *q_n, prs_struct *ps, int depth)
+BOOL srv_io_q_net_sess_enum(const char *desc, SRV_Q_NET_SESS_ENUM *q_u, prs_struct *ps, int depth)
 {
-	if (q_n == NULL)
+	if (q_u == NULL)
 		return False;
 
 	prs_debug(ps, depth, desc, "srv_io_q_net_sess_enum");
@@ -1922,41 +1820,36 @@ BOOL srv_io_q_net_sess_enum(const char *desc, SRV_Q_NET_SESS_ENUM *q_n, prs_stru
 	if(!prs_align(ps))
 		return False;
 
-	if(!prs_uint32("ptr_srv_name", ps, depth, &q_n->ptr_srv_name))
-		return False;
-	if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
+	if(!prs_pointer("servername", ps, depth, (void**)&q_u->servername, sizeof(UNISTR2), (PRS_POINTER_CAST)prs_io_unistr2))
 		return False;
 
 	if(!prs_align(ps))
 		return False;
 
-	if(!prs_uint32("ptr_qual_name", ps, depth, &q_n->ptr_qual_name))
-		return False;
-	if(!smb_io_unistr2("", &q_n->uni_qual_name, q_n->ptr_qual_name, ps, depth))
+	if(!prs_pointer("qualifier", ps, depth, (void**)&q_u->qualifier, sizeof(UNISTR2), (PRS_POINTER_CAST)prs_io_unistr2))
 		return False;
 
 	if(!prs_align(ps))
 		return False;
-	if(!prs_uint32("ptr_user_name", ps, depth, &q_n->ptr_user_name))
-		return False;
-	if(!smb_io_unistr2("", &q_n->uni_user_name, q_n->ptr_user_name, ps, depth))
+
+	if(!prs_pointer("username", ps, depth, (void**)&q_u->username, sizeof(UNISTR2), (PRS_POINTER_CAST)prs_io_unistr2))
 		return False;
 
 	if(!prs_align(ps))
 		return False;
 
-	if(!prs_uint32("sess_level", ps, depth, &q_n->sess_level))
+	if(!prs_uint32("sess_level", ps, depth, &q_u->sess_level))
 		return False;
 	
-	if (q_n->sess_level != (uint32)-1) {
-		if(!srv_io_srv_sess_ctr("sess_ctr", &q_n->ctr, ps, depth))
+	if (q_u->sess_level != (uint32)-1) {
+		if(!srv_io_srv_sess_ctr("sess_ctr", &q_u->ctr, ps, depth))
 			return False;
 	}
 
-	if(!prs_uint32("preferred_len", ps, depth, &q_n->preferred_len))
+	if(!prs_uint32("preferred_len", ps, depth, &q_u->preferred_len))
 		return False;
 
-	if(!smb_io_enum_hnd("enum_hnd", &q_n->enum_hnd, ps, depth))
+	if(!smb_io_enum_hnd("enum_hnd", &q_u->enum_hnd, ps, depth))
 		return False;
 
 	return True;
@@ -2434,22 +2327,10 @@ BOOL srv_io_r_net_conn_enum(const char *desc,  SRV_R_NET_CONN_ENUM *r_n, prs_str
 }
 
 /*******************************************************************
- Inits a FILE_INFO_3_STR structure
-********************************************************************/
-
-void init_srv_file_info3_str(FILE_INFO_3_STR *fi3, const char *user_name, const char *path_name)
-{
-	DEBUG(5,("init_srv_file_info3_str\n"));
-
-	init_unistr2(&fi3->uni_path_name, path_name, UNI_STR_TERMINATE);
-	init_unistr2(&fi3->uni_user_name, user_name, UNI_STR_TERMINATE);
-}
-
-/*******************************************************************
  Reads or writes a structure.
 ********************************************************************/
 
-static BOOL srv_io_file_info3_str(const char *desc, FILE_INFO_3_STR *sh1, prs_struct *ps, int depth)
+static BOOL srv_io_file_info3_str(const char *desc, FILE_INFO_3 *sh1, prs_struct *ps, int depth)
 {
 	if (sh1 == NULL)
 		return False;
@@ -2460,10 +2341,15 @@ static BOOL srv_io_file_info3_str(const char *desc, FILE_INFO_3_STR *sh1, prs_st
 	if(!prs_align(ps))
 		return False;
 
-	if(!smb_io_unistr2("", &sh1->uni_path_name, True, ps, depth))
-		return False;
-	if(!smb_io_unistr2("", &sh1->uni_user_name, True, ps, depth))
-		return False;
+	if ( sh1->path ) {
+		if(!smb_io_unistr2("", sh1->path, True, ps, depth))
+			return False;
+	}
+
+	if ( sh1->user ) {
+		if(!smb_io_unistr2("", sh1->user, True, ps, depth))
+			return False;
+	}
 
 	return True;
 }
@@ -2472,18 +2358,26 @@ static BOOL srv_io_file_info3_str(const char *desc, FILE_INFO_3_STR *sh1, prs_st
  Inits a FILE_INFO_3 structure
 ********************************************************************/
 
-void init_srv_file_info3(FILE_INFO_3 *fl3,
-			 uint32 id, uint32 perms, uint32 num_locks,
-			 const char *path_name, const char *user_name)
+void init_srv_file_info3( FILE_INFO_3 *fl3, uint32 id, uint32 perms, uint32 num_locks,
+                          const char *user_name, const char *path_name )
 {
-	DEBUG(5,("init_srv_file_info3: %s %s\n", path_name, user_name));
-
 	fl3->id        = id;	
 	fl3->perms     = perms;
 	fl3->num_locks = num_locks;
 
-	fl3->ptr_path_name = (path_name != NULL) ? 1 : 0;
-	fl3->ptr_user_name = (user_name != NULL) ? 1 : 0;
+        if ( path_name ) {
+                if ( (fl3->path = TALLOC_P( get_talloc_ctx(), UNISTR2 )) == NULL )
+                        return;
+                init_unistr2(fl3->path, path_name, UNI_STR_TERMINATE);
+        }
+
+        if ( user_name ) {
+                if ( (fl3->user = TALLOC_P( get_talloc_ctx(), UNISTR2 )) == NULL )
+                        return;
+                init_unistr2(fl3->user, user_name, UNI_STR_TERMINATE);
+        }
+
+	return;
 }
 
 /*******************************************************************
@@ -2492,6 +2386,8 @@ void init_srv_file_info3(FILE_INFO_3 *fl3,
 
 static BOOL srv_io_file_info3(const char *desc, FILE_INFO_3 *fl3, prs_struct *ps, int depth)
 {
+	uint32 uni_p;
+
 	if (fl3 == NULL)
 		return False;
 
@@ -2507,10 +2403,24 @@ static BOOL srv_io_file_info3(const char *desc, FILE_INFO_3 *fl3, prs_struct *ps
 		return False;
 	if(!prs_uint32("num_locks    ", ps, depth, &fl3->num_locks))
 		return False;
-	if(!prs_uint32("ptr_path_name", ps, depth, &fl3->ptr_path_name))
+
+	uni_p = fl3->path ? (uint32)fl3->path : 0;
+	if(!prs_uint32("ptr", ps, depth, &uni_p))
 		return False;
-	if(!prs_uint32("ptr_user_name", ps, depth, &fl3->ptr_user_name))
+	if (UNMARSHALLING(ps)) {
+		if ( (fl3->path = PRS_ALLOC_MEM( ps, UNISTR2, 1)) == NULL ) {
+			return False;
+		}
+	}
+
+	uni_p = fl3->user ? (uint32)fl3->user : 0;
+	if(!prs_uint32("ptr", ps, depth, &uni_p))
 		return False;
+	if (UNMARSHALLING(ps)) {
+		if ( (fl3->user = PRS_ALLOC_MEM( ps, UNISTR2, 1)) == NULL ) {
+			return False;
+		}
+	}
 
 	return True;
 }
@@ -2528,55 +2438,53 @@ static BOOL srv_io_srv_file_ctr(const char *desc, SRV_FILE_INFO_CTR *ctr, prs_st
 	depth++;
 
 	if (UNMARSHALLING(ps)) {
-		memset(ctr, '\0', sizeof(SRV_FILE_INFO_CTR));
+		ZERO_STRUCTP(ctr);
 	}
 
 	if(!prs_align(ps))
 		return False;
 
-	if(!prs_uint32("switch_value", ps, depth, &ctr->switch_value))
+	if(!prs_uint32("level", ps, depth, &ctr->level))
 		return False;
-	if (ctr->switch_value != 3) {
-		DEBUG(5,("%s File info %d level not supported\n",
-			 tab_depth(depth), ctr->switch_value));
-	}
+
 	if(!prs_uint32("ptr_file_info", ps, depth, &ctr->ptr_file_info))
 		return False;
 	if(!prs_uint32("num_entries", ps, depth, &ctr->num_entries))
 		return False;
 	if(!prs_uint32("ptr_entries", ps, depth, &ctr->ptr_entries))
 		return False;
+
 	if (ctr->ptr_entries == 0)
 		return True;
-	if(!prs_uint32("num_entries2", ps, depth, 
-		       &ctr->num_entries2))
+
+	if(!prs_uint32("num_entries2", ps, depth, &ctr->num_entries2))
 		return False;
 
-	switch (ctr->switch_value) {
+	switch (ctr->level) {
 	case 3: {
-		SRV_FILE_INFO_3 *info3 = ctr->file.info3;
+		FILE_INFO_3 *info3 = ctr->file.info3;
 		int num_entries = ctr->num_entries;
 		int i;
 
 		if (UNMARSHALLING(ps)) {
-			if (!(info3 = PRS_ALLOC_MEM(ps, SRV_FILE_INFO_3, num_entries)))
+			if (!(info3 = PRS_ALLOC_MEM(ps, FILE_INFO_3, num_entries)))
 				return False;
 			ctr->file.info3 = info3;
 		}
 
 		for (i = 0; i < num_entries; i++) {
-			if(!srv_io_file_info3("", &ctr->file.info3[i].info_3, ps, depth))
+			if(!srv_io_file_info3("", &ctr->file.info3[i], ps, depth)) 
 				return False;
 		}
+
 		for (i = 0; i < num_entries; i++) {
-			if(!srv_io_file_info3_str("", &ctr->file.info3[i].info_3_str, ps, depth))
+			if(!srv_io_file_info3_str("", &ctr->file.info3[i], ps, depth))
 				return False;
 		}
 		break;
 	}
 	default:
-		DEBUG(5,("%s no file info at switch_value %d\n",
-			 tab_depth(depth), ctr->switch_value));
+		DEBUG(5,("%s no file info at switch_value %d\n", tab_depth(depth), ctr->level));
 		break;
 	}
 			
@@ -2594,13 +2502,28 @@ void init_srv_q_net_file_enum(SRV_Q_NET_FILE_ENUM *q_n,
 			      uint32 preferred_len,
 			      ENUM_HND *hnd)
 {
-	DEBUG(5,("init_q_net_file_enum\n"));
+	uint32 ptr;
 
-	init_buf_unistr2(&q_n->uni_srv_name, &q_n->ptr_srv_name, srv_name);
-	init_buf_unistr2(&q_n->uni_qual_name, &q_n->ptr_qual_name, qual_name);
-	init_buf_unistr2(&q_n->uni_user_name, &q_n->ptr_user_name, user_name);
+	if ( srv_name ) {
+		if ( (q_n->servername = TALLOC_P( get_talloc_ctx(), UNISTR2 )) == NULL )
+			return;
+		init_buf_unistr2(q_n->servername, &ptr, srv_name);
+	}
+
+	if ( qual_name ) {
+		if ( (q_n->qualifier = TALLOC_P( get_talloc_ctx(), UNISTR2 )) == NULL )
+			return;
+		init_buf_unistr2(q_n->qualifier,  &ptr, qual_name);
+	}
+
+	if ( user_name ) {
+		if ( (q_n->username = TALLOC_P( get_talloc_ctx(), UNISTR2 )) == NULL )
+			return;
+		init_buf_unistr2(q_n->username,   &ptr, user_name);
+	}
+
+	q_n->level = q_n->ctr.level = file_level;
 
-	q_n->file_level    = q_n->ctr.switch_value = file_level;
 	q_n->preferred_len = preferred_len;
 	q_n->ctr.ptr_file_info = 1;
 	q_n->ctr.num_entries = 0;
@@ -2613,9 +2536,9 @@ void init_srv_q_net_file_enum(SRV_Q_NET_FILE_ENUM *q_n,
  Reads or writes a structure.
 ********************************************************************/
 
-BOOL srv_io_q_net_file_enum(const char *desc, SRV_Q_NET_FILE_ENUM *q_n, prs_struct *ps, int depth)
+BOOL srv_io_q_net_file_enum(const char *desc, SRV_Q_NET_FILE_ENUM *q_u, prs_struct *ps, int depth)
 {
-	if (q_n == NULL)
+	if (q_u == NULL)
 		return False;
 
 	prs_debug(ps, depth, desc, "srv_io_q_net_file_enum");
@@ -2624,41 +2547,33 @@ BOOL srv_io_q_net_file_enum(const char *desc, SRV_Q_NET_FILE_ENUM *q_n, prs_stru
 	if(!prs_align(ps))
 		return False;
 
-	if(!prs_uint32("ptr_srv_name", ps, depth, &q_n->ptr_srv_name))
+	if(!prs_pointer("servername", ps, depth, (void**)&q_u->servername, sizeof(UNISTR2), (PRS_POINTER_CAST)prs_io_unistr2))
 		return False;
-	if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
-		return False;
-
 	if(!prs_align(ps))
 		return False;
 
-	if(!prs_uint32("ptr_qual_name", ps, depth, &q_n->ptr_qual_name))
-		return False;
-	if(!smb_io_unistr2("", &q_n->uni_qual_name, q_n->ptr_qual_name, ps, depth))
+	if(!prs_pointer("qualifier", ps, depth, (void**)&q_u->qualifier, sizeof(UNISTR2), (PRS_POINTER_CAST)prs_io_unistr2))
 		return False;
-
 	if(!prs_align(ps))
 		return False;
 
-	if(!prs_uint32("ptr_user_name", ps, depth, &q_n->ptr_user_name))
-		return False;
-	if(!smb_io_unistr2("", &q_n->uni_user_name, q_n->ptr_user_name, ps, depth))
+	if(!prs_pointer("username", ps, depth, (void**)&q_u->username, sizeof(UNISTR2), (PRS_POINTER_CAST)prs_io_unistr2))
 		return False;
-
 	if(!prs_align(ps))
 		return False;
-	if(!prs_uint32("file_level", ps, depth, &q_n->file_level))
+
+	if(!prs_uint32("level", ps, depth, &q_u->level))
 		return False;
 
-	if (q_n->file_level != (uint32)-1) {
-		if(!srv_io_srv_file_ctr("file_ctr", &q_n->ctr, ps, depth))
+	if (q_u->level != (uint32)-1) {
+		if(!srv_io_srv_file_ctr("file_ctr", &q_u->ctr, ps, depth))
 			return False;
 	}
 
-	if(!prs_uint32("preferred_len", ps, depth, &q_n->preferred_len))
+	if(!prs_uint32("preferred_len", ps, depth, &q_u->preferred_len))
 		return False;
 
-	if(!smb_io_enum_hnd("enum_hnd", &q_n->enum_hnd, ps, depth))
+	if(!smb_io_enum_hnd("enum_hnd", &q_u->enum_hnd, ps, depth))
 		return False;
 
 	return True;
@@ -2679,10 +2594,10 @@ BOOL srv_io_r_net_file_enum(const char *desc, SRV_R_NET_FILE_ENUM *r_n, prs_stru
 	if(!prs_align(ps))
 		return False;
 
-	if(!prs_uint32("file_level", ps, depth, &r_n->file_level))
+	if(!prs_uint32("level", ps, depth, &r_n->level))
 		return False;
 
-	if (r_n->file_level != 0) {
+	if (r_n->level != 0) {
 		if(!srv_io_srv_file_ctr("file_ctr", &r_n->ctr, ps, depth))
 			return False;
 	}
@@ -2703,63 +2618,17 @@ BOOL srv_io_r_net_file_enum(const char *desc, SRV_R_NET_FILE_ENUM *r_n, prs_stru
 void init_srv_q_net_file_close(SRV_Q_NET_FILE_CLOSE *q_n, const char *server,
 			       uint32 file_id)
 {
-	q_n->ptr_srv_name = 1;
-	init_unistr2(&q_n->uni_srv_name, server, UNI_STR_TERMINATE);
-	q_n->file_id = file_id;
-}
-
-/*******************************************************************
- Reads or writes a structure.
-********************************************************************/
-BOOL srv_io_q_net_file_close(const char *desc, SRV_Q_NET_FILE_CLOSE *q_n,
-			     prs_struct *ps, int depth)
-{
-	if (q_n == NULL)
-		return False;
-
-	prs_debug(ps, depth, desc, "srv_io_q_net_file_close");
-	depth++;
-
-	if(!prs_align(ps))
-		return False;
-
-	if(!prs_uint32("ptr_srv_name", ps, depth, &q_n->ptr_srv_name))
-		return False;
-	if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
-		return False;
-
-	if(!prs_align(ps))
-		return False;
-
-	if(!prs_uint32("file_id", ps, depth, &q_n->file_id))
-		return False;
+	if ( server ) {
+		if ( (q_n->servername = TALLOC_P( get_talloc_ctx(), UNISTR2 )) == NULL ) {
+			return;
+		}
+		init_unistr2(q_n->servername, server, UNI_STR_TERMINATE);
+	}
 
-	return True;
+	q_n->file_id = file_id;
 }
 
 /*******************************************************************
- Reads or writes a structure.
-********************************************************************/
-
-BOOL srv_io_r_net_file_close(const char *desc, SRV_R_NET_FILE_CLOSE *q_n, 
-			     prs_struct *ps, int depth)
-{
-	if (q_n == NULL)
-		return False;
-
-	prs_debug(ps, depth, desc, "srv_io_r_net_file_close");
-	depth++;
-
-	if(!prs_align(ps))
-		return False;
-
-	if(!prs_werror("status", ps, depth, &q_n->status))
-		return False;
-
-	return True;
-}	
-
-/*******************************************************************
  Inits a SRV_INFO_100 structure.
  ********************************************************************/
 
@@ -3411,25 +3280,6 @@ BOOL srv_io_r_net_disk_enum(const char *desc, SRV_R_NET_DISK_ENUM *r_n, prs_stru
 }
 
 /*******************************************************************
- initialises a structure.
- ********************************************************************/
-
-BOOL init_srv_q_net_name_validate(SRV_Q_NET_NAME_VALIDATE *q_n, const char *srv_name, const char *share_name, int type) 
-{
-	uint32 ptr_share_name;
-
-	DEBUG(5,("init_srv_q_net_name_validate\n"));
-  
-	init_buf_unistr2(&q_n->uni_srv_name, &q_n->ptr_srv_name, srv_name);
-	init_buf_unistr2(&q_n->uni_name,     &ptr_share_name,    share_name);
-
-	q_n->type  = type;
-	q_n->flags = 0;
-
-	return True;
-}
-
-/*******************************************************************
  Reads or writes a structure.
  ********************************************************************/
 
@@ -3444,16 +3294,13 @@ BOOL srv_io_q_net_name_validate(const char *desc, SRV_Q_NET_NAME_VALIDATE *q_n,
 	if(!prs_align(ps))
 		return False;
 
-	if(!prs_uint32("ptr_srv_name", ps, depth, &q_n->ptr_srv_name))
-		return False;
-
-	if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
+	if(!prs_pointer("servername", ps, depth, (void**)&q_n->servername, sizeof(UNISTR2), (PRS_POINTER_CAST)prs_io_unistr2))
 		return False;
 
 	if(!prs_align(ps))
 		return False;
 
-	if(!smb_io_unistr2("", &q_n->uni_name, True, ps, depth))
+	if(!smb_io_unistr2("", &q_n->sharename, True, ps, depth))
 		return False;
 
 	if(!prs_align(ps))
@@ -3663,3 +3510,48 @@ void init_srv_q_net_remote_tod(SRV_Q_NET_REMOTE_TOD *q_u, const char *server)
 	q_u->ptr_srv_name = 1;
 	init_unistr2(&q_u->uni_srv_name, server, UNI_STR_TERMINATE);
 }
+
+
+/*******************************************************************
+ Reads or writes a structure.
+********************************************************************/
+
+BOOL srv_io_q_net_file_close(const char *desc, SRV_Q_NET_FILE_CLOSE *q_u, prs_struct *ps, int depth)
+{
+	if (q_u == NULL)
+		return False;
+
+	prs_debug(ps, depth, desc, "srv_io_q_net_file_close");
+	depth++;
+
+	if(!prs_align(ps))
+		return False;
+
+	if(!prs_pointer("servername", ps, depth, (void**)&q_u->servername, sizeof(UNISTR2), (PRS_POINTER_CAST)prs_io_unistr2))
+		return False;
+	if(!prs_align(ps))
+		return False;
+
+	if(!prs_uint32("file_id", ps, depth, &q_u->file_id))
+		return False;
+		
+	return True;
+}
+
+/*******************************************************************
+ ********************************************************************/
+
+BOOL srv_io_r_net_file_close(const char *desc, SRV_R_NET_FILE_CLOSE *r_n, 
+			       prs_struct *ps, int depth)
+{
+	prs_debug(ps, depth, desc, "srv_io_r_net_file_close");
+	depth++;
+
+	if(!prs_align(ps))
+		return False;
+
+	if(!prs_werror("status", ps, depth, &r_n->status))
+		return False;
+
+	return True;
+}
diff --git a/source/rpc_server/srv_pipe_hnd.c b/source/rpc_server/srv_pipe_hnd.c
index 9cc8b72546f..26e06f60a17 100644
--- a/source/rpc_server/srv_pipe_hnd.c
+++ b/source/rpc_server/srv_pipe_hnd.c
@@ -1169,6 +1169,13 @@ BOOL close_rpc_pipe_hnd(smb_np_struct *p)
 		 p->name, p->pnum, pipes_open));  
 
 	DLIST_REMOVE(Pipes, p);
+	
+	/* Remove from pipe open db */
+	
+	if ( !delete_pipe_opendb( p ) ) {
+		DEBUG(3,("close_rpc_pipe_hnd: failed to delete %s "
+			"pipe from open db.\n", p->name));
+	}
 
 	ZERO_STRUCTP(p);
 
diff --git a/source/rpc_server/srv_srvsvc.c b/source/rpc_server/srv_srvsvc.c
index 0b4eac5cc73..e4f85d0bdb4 100644
--- a/source/rpc_server/srv_srvsvc.c
+++ b/source/rpc_server/srv_srvsvc.c
@@ -6,6 +6,7 @@
  *  Copyright (C) Paul Ashton                       1997,
  *  Copyright (C) Jeremy Allison                    2001,
  *  Copyright (C) Jim McDonough <jmcd@us.ibm.com>   2003.
+ *  Copyright (C) Gera;d (Jerry) Carter             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
@@ -551,6 +552,35 @@ static BOOL api_srv_net_file_set_secdesc(pipes_struct *p)
 }
 
 /*******************************************************************
+*******************************************************************/
+
+static BOOL api_srv_net_file_close(pipes_struct *p)
+{
+	SRV_Q_NET_FILE_CLOSE q_u;
+	SRV_R_NET_FILE_CLOSE r_u;
+	prs_struct *data = &p->in_data.data;
+	prs_struct *rdata = &p->out_data.rdata;
+
+	ZERO_STRUCT(q_u);
+	ZERO_STRUCT(r_u);
+
+	/* Unmarshall the net file set info from Win9x */
+	if(!srv_io_q_net_file_close("", &q_u, data, 0)) {
+		DEBUG(0,("api_srv_net_file_close: Failed to unmarshall SRV_Q_NET_FILE_SET_SECDESC.\n"));
+		return False;
+	}
+
+	r_u.status = _srv_net_file_close(p, &q_u, &r_u);
+
+	if(!srv_io_r_net_file_close("", &r_u, rdata, 0)) {
+		DEBUG(0,("api_srv_net_file_close: Failed to marshall SRV_R_NET_FILE_SET_SECDESC.\n"));
+		return False;
+	}
+
+	return True;
+}
+
+/*******************************************************************
 \PIPE\srvsvc commands
 ********************************************************************/
 
@@ -573,7 +603,8 @@ static struct api_struct api_srv_cmds[] =
       { "SRV_NET_DISK_ENUM"         , SRV_NET_DISK_ENUM         , api_srv_net_disk_enum          },
       { "SRV_NET_NAME_VALIDATE"     , SRV_NET_NAME_VALIDATE     , api_srv_net_name_validate      },
       { "SRV_NET_FILE_QUERY_SECDESC", SRV_NET_FILE_QUERY_SECDESC, api_srv_net_file_query_secdesc },
-      { "SRV_NET_FILE_SET_SECDESC"  , SRV_NET_FILE_SET_SECDESC  , api_srv_net_file_set_secdesc   }
+      { "SRV_NET_FILE_SET_SECDESC"  , SRV_NET_FILE_SET_SECDESC  , api_srv_net_file_set_secdesc   },
+      { "SRV_NET_FILE_CLOSE"        , SRV_NET_FILE_CLOSE        , api_srv_net_file_close         }
 };
 
 void srvsvc_get_pipe_fns( struct api_struct **fns, int *n_fns )
diff --git a/source/rpc_server/srv_srvsvc_nt.c b/source/rpc_server/srv_srvsvc_nt.c
index 06a8c77098d..d03ab66b50d 100644
--- a/source/rpc_server/srv_srvsvc_nt.c
+++ b/source/rpc_server/srv_srvsvc_nt.c
@@ -4,6 +4,7 @@
  *  Copyright (C) Andrew Tridgell              1992-1997,
  *  Copyright (C) Jeremy Allison               2001.
  *  Copyright (C) Nigel Williams               2001.
+ *  Copyright (C) Gerald (Jerry) Carter        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
@@ -29,6 +30,174 @@ extern struct generic_mapping file_generic_mapping;
 #undef DBGC_CLASS
 #define DBGC_CLASS DBGC_RPC_SRV
 
+/* Use for enumerating connections, pipes, & files */
+
+struct file_enum_count {
+	TALLOC_CTX *ctx;
+	int count;
+	FILE_INFO_3 *info;
+};
+
+struct sess_file_count {
+	pid_t pid;
+	uid_t uid;
+	int count;
+};
+
+/****************************************************************************
+ Count the entries belonging to a service in the connection db.
+****************************************************************************/
+
+static int pipe_enum_fn( TDB_CONTEXT *the_tdb, TDB_DATA kbuf, TDB_DATA dbuf, void *p)
+{
+	struct pipe_open_rec prec;
+	struct file_enum_count *fenum = (struct file_enum_count *)p;
+ 
+	if (dbuf.dsize != sizeof(struct pipe_open_rec))
+		return 0;
+
+	memcpy(&prec, dbuf.dptr, sizeof(struct pipe_open_rec));
+ 
+	if ( process_exists(prec.pid) ) {
+		FILE_INFO_3 *f;
+		int i = fenum->count;
+		pstring fullpath;
+		
+		snprintf( fullpath, sizeof(fullpath), "\\PIPE\\%s", prec.name );
+		
+		f = TALLOC_REALLOC_ARRAY( fenum->ctx, fenum->info, FILE_INFO_3, i+1 );
+		if ( !f ) {
+			DEBUG(0,("conn_enum_fn: realloc failed for %d items\n", i+1));
+			return 1;
+		}
+		fenum->info = f;
+		
+		
+		init_srv_file_info3( &fenum->info[i], 
+			(uint32)((procid_to_pid(&prec.pid)<<16) & prec.pnum),
+			(FILE_READ_DATA|FILE_WRITE_DATA), 
+			0,
+			uidtoname( prec.uid ),
+			fullpath );
+			
+		fenum->count++;
+	}
+
+	return 0;
+}
+
+/*******************************************************************
+********************************************************************/
+
+static WERROR net_enum_pipes( TALLOC_CTX *ctx, FILE_INFO_3 **info, 
+                              uint32 *count, uint32 resume )
+{
+	struct file_enum_count fenum;
+	TDB_CONTEXT *conn_tdb = conn_tdb_ctx();
+
+	if ( !conn_tdb ) {
+		DEBUG(0,("net_enum_pipes: Failed to retrieve the connections tdb handle!\n"));
+		return WERR_ACCESS_DENIED;
+	}
+	
+	fenum.ctx = ctx;
+	fenum.count = *count;
+	fenum.info = *info;
+
+	if (tdb_traverse(conn_tdb, pipe_enum_fn, &fenum) == -1) {
+		DEBUG(0,("net_enum_pipes: traverse of connections.tdb failed with error %s.\n",
+			tdb_errorstr(conn_tdb) ));
+		return WERR_NOMEM;
+	}
+	
+	*info  = fenum.info;
+	*count = fenum.count;
+	
+	return WERR_OK;}
+
+/*******************************************************************
+********************************************************************/
+
+/* global needed to make use of the share_mode_forall() callback */
+static struct file_enum_count f_enum_cnt;
+
+static void enum_file_fn( const struct share_mode_entry *e, 
+                          const char *sharepath, const char *fname, void *state )
+{
+	struct file_enum_count *fenum = &f_enum_cnt;
+ 
+	/* If the pid was not found delete the entry from connections.tdb */
+
+	if ( process_exists(e->pid) ) {
+		FILE_INFO_3 *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, FILE_INFO_3, i+1 );			
+		if ( !f ) {
+			DEBUG(0,("conn_enum_fn: realloc failed for %d items\n", i+1));
+			return;
+		}
+		fenum->info = f;
+
+		/* need to count the number of locks on a file */
+		
+		ZERO_STRUCT( fsp );		
+		fsp.dev   = e->dev;
+		fsp.inode = e->inode;
+		
+		if ( (brl = brl_get_locks(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);
+
+		/* now fill in the FILE_INFO_3 struct */
+		init_srv_file_info3( &fenum->info[i], 
+			e->share_file_id,
+			permissions,
+			num_locks,
+			uidtoname(e->uid),
+			fullpath );
+			
+		fenum->count++;
+	}
+
+	return;
+
+}
+
+/*******************************************************************
+********************************************************************/
+
+static WERROR net_enum_files( TALLOC_CTX *ctx, FILE_INFO_3 **info, 
+                              uint32 *count, uint32 resume )
+{
+	f_enum_cnt.ctx = ctx;
+	f_enum_cnt.count = *count;
+	f_enum_cnt.info = *info;
+	
+	share_mode_forall( enum_file_fn, NULL );
+	
+	*info  = f_enum_cnt.info;
+	*count = f_enum_cnt.count;
+	
+	return WERR_OK;
+}
+
 /*******************************************************************
  Utility function to get the 'type' of a share from an snum.
  ********************************************************************/
@@ -91,8 +260,9 @@ static void init_srv_share_info_2(pipes_struct *p, SRV_SHARE_INFO_2 *sh2, int sn
 	pstring passwd;
 	int max_connections = lp_max_connections(snum);
 	uint32 max_uses = max_connections!=0 ? max_connections : 0xffffffff;
-
+	int count = 0;
 	char *net_name = lp_servicename(snum);
+	
 	pstrcpy(remark, lp_comment(snum));
 	standard_sub_conn(p->conn, remark,sizeof(remark));
 	pstrcpy(path, "C:");
@@ -107,7 +277,10 @@ static void init_srv_share_info_2(pipes_struct *p, SRV_SHARE_INFO_2 *sh2, int sn
 
 	pstrcpy(passwd, "");
 
-	init_srv_share_info2(&sh2->info_2, net_name, get_share_type(snum), remark, 0, max_uses, 1, path, passwd);
+	count = count_current_connections( net_name, False  );
+	init_srv_share_info2(&sh2->info_2, net_name, get_share_type(snum), 
+		remark, 0, max_uses, count, path, passwd);
+
 	init_srv_share_info2_str(&sh2->info_2_str, net_name, remark, path, passwd);
 }
 
@@ -596,16 +769,6 @@ static void init_srv_r_net_share_get_info(pipes_struct *p, SRV_R_NET_SHARE_GET_I
 }
 
 /*******************************************************************
- fill in a sess info level 1 structure.
- ********************************************************************/
-
-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);
-}
-
-/*******************************************************************
  fill in a sess info level 0 structure.
  ********************************************************************/
 
@@ -627,11 +790,7 @@ static void init_srv_sess_info_0(SRV_SESS_INFO_0 *ss0, uint32 *snum, uint32 *sto
 
 	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);
-
-			/* move on to creating next session */
-			/* move on to creating next sess */
+			init_srv_sess_info0( &ss0->info_0[num_entries], session_list[(*snum)].remote_machine);
 			num_entries++;
 		}
 
@@ -652,17 +811,35 @@ static void init_srv_sess_info_0(SRV_SESS_INFO_0 *ss0, uint32 *snum, uint32 *sto
 }
 
 /*******************************************************************
- fill in a sess info level 1 structure.
- ********************************************************************/
+********************************************************************/
+
+/* global needed to make use of the share_mode_forall() callback */
+static struct sess_file_count s_file_cnt;
+
+static void sess_file_fn( const struct share_mode_entry *e, 
+                          const char *sharepath, const char *fname, void *state )
+{
+	struct sess_file_count *sess = &s_file_cnt;
+ 
+	if ( (procid_to_pid(&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, pid_t pid )
 {
-	init_srv_sess_info1(se1 , name, user, num_opens, open_time, idle_time, usr_flgs);
-	init_srv_sess_info1_str(str1, name, user);
+	s_file_cnt.count = 0;
+	s_file_cnt.uid = uid;
+	s_file_cnt.pid = pid;
+	
+	share_mode_forall( sess_file_fn, NULL );
+	
+	return s_file_cnt.count;
 }
 
 /*******************************************************************
@@ -673,43 +850,58 @@ static void init_srv_sess_info_1(SRV_SESS_INFO_1 *ss1, uint32 *snum, uint32 *sto
 {
 	struct sessionid *session_list;
 	uint32 num_entries = 0;
-	(*stot) = list_sessions(&session_list);
+	time_t now = time(NULL);
 
+	if ( !snum ) {
+		ss1->num_entries_read = 0;
+		ss1->ptr_sess_info = 0;
+		ss1->num_entries_read2 = 0;
+		
+		(*stot) = 0;
+
+		return;
+	}
+	
 	if (ss1 == NULL) {
 		(*snum) = 0;
-		SAFE_FREE(session_list);
 		return;
 	}
 
-	DEBUG(5,("init_srv_sess_1_ss1\n"));
-
-	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++;
-		}
+	(*stot) = list_sessions(&session_list);
+	
 
-		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;
+	for (; (*snum) < (*stot) && num_entries < MAX_SESS_ENTRIES; (*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;
 		}
-
-	} else {
-		ss1->num_entries_read = 0;
-		ss1->ptr_sess_info = 0;
-		ss1->num_entries_read2 = 0;
-		
-		(*stot) = 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() );
+					
+		init_srv_sess_info1( &ss1->info_1[num_entries], 
+		                     session_list[*snum].remote_machine,
+				     session_list[*snum].username, 
+				     num_files,
+				     connect_time,
+				     0, 
+				     guest);
+		num_entries++;
+	}
+
+	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;
 	}
 
 	SAFE_FREE(session_list);
@@ -929,66 +1121,53 @@ static void init_srv_r_net_conn_enum(SRV_R_NET_CONN_ENUM *r_n,
  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)  
+static WERROR net_file_enum_3( SRV_R_NET_FILE_ENUM *r, uint32 resume_hnd )
 {
-	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 */
+	TALLOC_CTX *ctx = get_talloc_ctx();
+	SRV_FILE_INFO_CTR *ctr = &r->ctr;
 
-	ctr->switch_value = switch_value;
-	ctr->num_entries = *total_entries - *resume_hnd;
+	/* TODO -- Windows enumerates 
+	   (b) active pipes
+	   (c) open directories and files */
+
+	r->status = net_enum_files( ctx, &ctr->file.info3, &ctr->num_entries, resume_hnd );
+	if ( !W_ERROR_IS_OK(r->status))
+		goto done;
+		
+	r->status = net_enum_pipes( ctx, &ctr->file.info3, &ctr->num_entries, resume_hnd );
+	if ( !W_ERROR_IS_OK(r->status))
+		goto done;
+	
+	r->level = ctr->level = 3;
+	r->total_entries = ctr->num_entries;
+	/* ctr->num_entries = r->total_entries - resume_hnd; */
 	ctr->num_entries2 = ctr->num_entries;
+	ctr->ptr_file_info = 1;
 
-	switch (switch_value) {
-	case 3: {
-		int i;
-		if (*total_entries > 0) {
-			ctr->ptr_entries = 1;
-			ctr->file.info3 = TALLOC_ARRAY(ctx, SRV_FILE_INFO_3, ctr->num_entries);
-		}
-		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;
-	}
-	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;
-	}
+	r->status = WERR_OK;
 
-	return status;
+done:
+	if ( ctr->num_entries > 0 ) 
+		ctr->ptr_entries = 1;
+
+	init_enum_hnd(&r->enum_hnd, 0);
+
+	return r->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)  
+WERROR _srv_net_file_enum(pipes_struct *p, SRV_Q_NET_FILE_ENUM *q_u, SRV_R_NET_FILE_ENUM *r_u)
 {
-	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);
+	switch ( q_u->level ) {
+	case 3:
+		return net_file_enum_3( r_u, get_enum_hnd(&q_u->enum_hnd) );	
+	default:
+		return WERR_UNKNOWN_LEVEL;
+	}
+	
+	return WERR_OK;
 }
 
 /*******************************************************************
@@ -1075,25 +1254,6 @@ WERROR _srv_net_srv_set_info(pipes_struct *p, SRV_Q_NET_SRV_SET_INFO *q_u, SRV_R
 }
 
 /*******************************************************************
-net file enum
-********************************************************************/
-
-WERROR _srv_net_file_enum(pipes_struct *p, SRV_Q_NET_FILE_ENUM *q_u, SRV_R_NET_FILE_ENUM *r_u)
-{
-	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_file_enum: %d\n", __LINE__));
-
-	return r_u->status;
-}
-
-/*******************************************************************
 net conn enum
 ********************************************************************/
 
@@ -2102,7 +2262,7 @@ WERROR _srv_net_name_validate(pipes_struct *p, SRV_Q_NET_NAME_VALIDATE *q_u, SRV
 
 	switch ( q_u->type ) {
 	case 0x9:
-		rpcstr_pull(sharename, q_u->uni_name.buffer, sizeof(sharename), q_u->uni_name.uni_str_len*2, 0);
+		rpcstr_pull(sharename, q_u->sharename.buffer, sizeof(sharename), q_u->sharename.uni_str_len*2, 0);
 		if ( !validate_net_name( sharename, INVALID_SHARENAME_CHARS, sizeof(sharename) ) ) {
 			DEBUG(5,("_srv_net_name_validate: Bad sharename \"%s\"\n", sharename));
 			return WERR_INVALID_NAME;
@@ -2115,3 +2275,13 @@ WERROR _srv_net_name_validate(pipes_struct *p, SRV_Q_NET_NAME_VALIDATE *q_u, SRV
 
 	return WERR_OK;
 }
+
+
+/********************************************************************
+********************************************************************/
+
+WERROR _srv_net_file_close(pipes_struct *p, SRV_Q_NET_FILE_CLOSE *q_u, SRV_R_NET_FILE_CLOSE *r_u)
+{
+	return WERR_ACCESS_DENIED;
+}
+
diff --git a/source/smbd/nttrans.c b/source/smbd/nttrans.c
index 0ecb14f9c76..2a49e1f4a64 100644
--- a/source/smbd/nttrans.c
+++ b/source/smbd/nttrans.c
@@ -353,7 +353,7 @@ static int nt_open_pipe(char *fname, connection_struct *conn,
 		return(ERROR_DOS(ERRSRV,ERRnofids));
 	}
 
-	/* TODO: Add pipe to db */
+	/* Add pipe to db */
 	
 	if ( !store_pipe_opendb( p ) ) {
 		DEBUG(3,("nt_open_pipe: failed to store %s pipe open.\n", fname));
diff --git a/source/smbd/pipes.c b/source/smbd/pipes.c
index 52660da2ffe..58756a0b5a6 100644
--- a/source/smbd/pipes.c
+++ b/source/smbd/pipes.c
@@ -300,7 +300,5 @@ int reply_pipe_close(connection_struct *conn, char *inbuf,char *outbuf)
 		return ERROR_DOS(ERRDOS,ERRbadfid);
 	}
 	
-	/* TODO: REMOVE PIPE FROM DB */
-
 	return(outsize);
 }
diff --git a/source/utils/net_rpc.c b/source/utils/net_rpc.c
index ba710b67b55..56aee3be91a 100644
--- a/source/utils/net_rpc.c
+++ b/source/utils/net_rpc.c
@@ -4942,12 +4942,12 @@ static int rpc_file_close(int argc, const char **argv)
  * @param str3   strings for FILE_INFO_3
  **/
 
-static void display_file_info_3(FILE_INFO_3 *info3, FILE_INFO_3_STR *str3)
+static void display_file_info_3( FILE_INFO_3 *info3 )
 {
 	fstring user = "", path = "";
 
-	rpcstr_pull_unistr2_fstring(user, &str3->uni_user_name);
-	rpcstr_pull_unistr2_fstring(path, &str3->uni_path_name);
+	rpcstr_pull_unistr2_fstring(user, info3->user);
+	rpcstr_pull_unistr2_fstring(path, info3->path);
 
 	d_printf("%-7.1d %-20.20s 0x%-4.2x %-6.1d %s\n",
 		 info3->id, user, info3->perms, info3->num_locks, path);
@@ -5002,8 +5002,7 @@ static NTSTATUS rpc_file_list_internals(const DOM_SID *domain_sid,
 		 "\nFileId  Opened by            Perms  Locks  Path"\
 		 "\n------  ---------            -----  -----  ---- \n");
 	for (i = 0; i < ctr.num_entries; i++)
-		display_file_info_3(&ctr.file.info3[i].info_3, 
-				    &ctr.file.info3[i].info_3_str);
+		display_file_info_3(&ctr.file.info3[i]);
  done:
 	return W_ERROR_IS_OK(result) ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
 }