evin/ms-nfs41-client
3
0
Fork 0
Code Issues Pull requests Releases Wiki Activity
ms-nfs41-client/daemon/acl.c

796 lines
28 KiB
C
Raw Normal View History

[cosmetic] minor license changes added 2011 year to the copyright line added authors info to the license added UofM license to libtirpc files that we modified (but i probably missed some)
2011-08-12 13:20:12 -04:00
/* Copyright (c) 2010, 2011
first stab at handling security irp Basic handling of owner and group security query (no dacl). Added new upcall for NFS41_ACL_QUERY (driver and daemon code). Daemon, upon getting NFS41_ACL_QUERY first places a getattr that has owner, group attribute request. We currently don't cache them!!! Then, we parse nfs4name format (ie user@domain or group@domain) into user and domain. We currently ignore domain part!!! Then, we assume that whatever we are mapping is "known" locally (ie LookupAccountName() api which retrieves a SID for a given name). Mapping from name to SID can only be done in the userland. We then copy the bytes via the upcall pipe to the kernel. If the received user or group cant be mapped via LookupAccoundName(), we create a well known null SID as the reply. Kernel creates a security descriptor in the absolute-format and adds owner and group sids to it. Important: RtlSetOwner/Group functions only work with absolute-format security descriptor, however the reply to the user needs to be in the self-relative format. The way security query works is that it passes us a buffer to be filled with the security context. However the user doesn't know how big the buffer should be so, the user is allowed to pass a null buffer and have the kernel return how much memory is needed. This leads to 2 security queries => 2 NFS41_ACL_QUERY upcalls => 2 getattr rpcs... It should be improved. TODO: - need to add caching of owner/group attributes for a file? - need to add calls to LDAP for more general mapping? - need to cache reply of the ACL if supplied length is 0?
2011-03-15 16:31:52 -04:00
* The Regents of the University of Michigan
* All Rights Reserved
[cosmetic] minor license changes added 2011 year to the copyright line added authors info to the license added UofM license to libtirpc files that we modified (but i probably missed some)
2011-08-12 13:20:12 -04:00
*
* Olga Kornievskaia <aglo@umich.edu>
* Casey Bodley <cbodley@umich.edu>
first stab at handling security irp Basic handling of owner and group security query (no dacl). Added new upcall for NFS41_ACL_QUERY (driver and daemon code). Daemon, upon getting NFS41_ACL_QUERY first places a getattr that has owner, group attribute request. We currently don't cache them!!! Then, we parse nfs4name format (ie user@domain or group@domain) into user and domain. We currently ignore domain part!!! Then, we assume that whatever we are mapping is "known" locally (ie LookupAccountName() api which retrieves a SID for a given name). Mapping from name to SID can only be done in the userland. We then copy the bytes via the upcall pipe to the kernel. If the received user or group cant be mapped via LookupAccoundName(), we create a well known null SID as the reply. Kernel creates a security descriptor in the absolute-format and adds owner and group sids to it. Important: RtlSetOwner/Group functions only work with absolute-format security descriptor, however the reply to the user needs to be in the self-relative format. The way security query works is that it passes us a buffer to be filled with the security context. However the user doesn't know how big the buffer should be so, the user is allowed to pass a null buffer and have the kernel return how much memory is needed. This leads to 2 security queries => 2 NFS41_ACL_QUERY upcalls => 2 getattr rpcs... It should be improved. TODO: - need to add caching of owner/group attributes for a file? - need to add calls to LDAP for more general mapping? - need to cache reply of the ACL if supplied length is 0?
2011-03-15 16:31:52 -04:00
*
* Permission is granted to use, copy and redistribute this software
* for noncommercial education and research purposes, so long as no
* fee is charged, and so long as the name of the University of Michigan
* is not used in any advertising or publicity pertaining to the use
* or distribution of this software without specific, written prior
* authorization. Permission to modify or otherwise create derivative
* works of this software is not granted.
*
* This software is provided as is, without representation or warranty
* of any kind either express or implied, including without limitation
* the implied warranties of merchantability, fitness for a particular
* purpose, or noninfringement. The Regents of the University of
* Michigan shall not be liable for any damages, including special,
* indirect, incidental, or consequential damages, with respect to any
* claim arising out of or in connection with the use of the software,
* even if it has been or is hereafter advised of the possibility of
* such damages.
*/
#include <Windows.h>
#include <strsafe.h>
#include <sddl.h>
#include "nfs41_ops.h"
deleg: return delegation before conflicting operations new function nfs41_delegation_return() for synchronous delegation return. uses a condition variable to wait if another thread is already returning the delegation if nfs41_delegate_open() would conflict with a delegation, return it before sending the OPEN return the delegation before sending LINK, RENAME, REMOVE, and SETATTR all of this functionality is dependent on the preprocessor define DELEGATION_RETURN_ON_CONFLICT (on by default). if not defined, nfs41_delegation_return() is a noop Signed-off-by: Casey Bodley <cbodley@citi.umich.edu>
2011-07-07 13:51:21 -04:00
#include "delegation.h"
first stab at handling security irp Basic handling of owner and group security query (no dacl). Added new upcall for NFS41_ACL_QUERY (driver and daemon code). Daemon, upon getting NFS41_ACL_QUERY first places a getattr that has owner, group attribute request. We currently don't cache them!!! Then, we parse nfs4name format (ie user@domain or group@domain) into user and domain. We currently ignore domain part!!! Then, we assume that whatever we are mapping is "known" locally (ie LookupAccountName() api which retrieves a SID for a given name). Mapping from name to SID can only be done in the userland. We then copy the bytes via the upcall pipe to the kernel. If the received user or group cant be mapped via LookupAccoundName(), we create a well known null SID as the reply. Kernel creates a security descriptor in the absolute-format and adds owner and group sids to it. Important: RtlSetOwner/Group functions only work with absolute-format security descriptor, however the reply to the user needs to be in the self-relative format. The way security query works is that it passes us a buffer to be filled with the security context. However the user doesn't know how big the buffer should be so, the user is allowed to pass a null buffer and have the kernel return how much memory is needed. This leads to 2 security queries => 2 NFS41_ACL_QUERY upcalls => 2 getattr rpcs... It should be improved. TODO: - need to add caching of owner/group attributes for a file? - need to add calls to LDAP for more general mapping? - need to cache reply of the ACL if supplied length is 0?
2011-03-15 16:31:52 -04:00
#include "daemon_debug.h"
#include "util.h"
#include "upcall.h"
fattr4_word0_acl query during nfs41_acl_query upcall querying the server for the acl attribute during the nfs41_acl_query upcall. no mapping of the nfs41 acl to the windows dacl yet.
2011-03-31 19:43:04 -04:00
#include "nfs41_xdr.h"
first stab at handling security irp Basic handling of owner and group security query (no dacl). Added new upcall for NFS41_ACL_QUERY (driver and daemon code). Daemon, upon getting NFS41_ACL_QUERY first places a getattr that has owner, group attribute request. We currently don't cache them!!! Then, we parse nfs4name format (ie user@domain or group@domain) into user and domain. We currently ignore domain part!!! Then, we assume that whatever we are mapping is "known" locally (ie LookupAccountName() api which retrieves a SID for a given name). Mapping from name to SID can only be done in the userland. We then copy the bytes via the upcall pipe to the kernel. If the received user or group cant be mapped via LookupAccoundName(), we create a well known null SID as the reply. Kernel creates a security descriptor in the absolute-format and adds owner and group sids to it. Important: RtlSetOwner/Group functions only work with absolute-format security descriptor, however the reply to the user needs to be in the self-relative format. The way security query works is that it passes us a buffer to be filled with the security context. However the user doesn't know how big the buffer should be so, the user is allowed to pass a null buffer and have the kernel return how much memory is needed. This leads to 2 security queries => 2 NFS41_ACL_QUERY upcalls => 2 getattr rpcs... It should be improved. TODO: - need to add caching of owner/group attributes for a file? - need to add calls to LDAP for more general mapping? - need to cache reply of the ACL if supplied length is 0?
2011-03-15 16:31:52 -04:00
[acls] removing unneeded safety checks
2011-09-23 12:12:45 -04:00
//#define DEBUG_ACLS
[cosmetic] dprintf changes in acl, getattr, name_cache, namespace
2011-11-07 10:50:00 -05:00
#define ACLLVL 2 /* dprintf level for acl logging */
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
static int parse_getacl(unsigned char *buffer, uint32_t length,
nfs41_upcall *upcall)
first stab at handling security irp Basic handling of owner and group security query (no dacl). Added new upcall for NFS41_ACL_QUERY (driver and daemon code). Daemon, upon getting NFS41_ACL_QUERY first places a getattr that has owner, group attribute request. We currently don't cache them!!! Then, we parse nfs4name format (ie user@domain or group@domain) into user and domain. We currently ignore domain part!!! Then, we assume that whatever we are mapping is "known" locally (ie LookupAccountName() api which retrieves a SID for a given name). Mapping from name to SID can only be done in the userland. We then copy the bytes via the upcall pipe to the kernel. If the received user or group cant be mapped via LookupAccoundName(), we create a well known null SID as the reply. Kernel creates a security descriptor in the absolute-format and adds owner and group sids to it. Important: RtlSetOwner/Group functions only work with absolute-format security descriptor, however the reply to the user needs to be in the self-relative format. The way security query works is that it passes us a buffer to be filled with the security context. However the user doesn't know how big the buffer should be so, the user is allowed to pass a null buffer and have the kernel return how much memory is needed. This leads to 2 security queries => 2 NFS41_ACL_QUERY upcalls => 2 getattr rpcs... It should be improved. TODO: - need to add caching of owner/group attributes for a file? - need to add calls to LDAP for more general mapping? - need to cache reply of the ACL if supplied length is 0?
2011-03-15 16:31:52 -04:00
{
int status;
getacl_upcall_args *args = &upcall->args.getacl;
status = safe_read(&buffer, &length, &args->query, sizeof(args->query));
if (status) goto out;
moving session and open_state in upcall header every upcall (except few) pass session and open_state pointer, so add that to marshal_nfs41_header() in the driver. remove passing of session and open_state elsewhere in marshal functions. in the deamon, upcall.c now reads and stores pointers to session and open_state in nfs41_upcall datastructure instead of having each individual upcall store their own pointers. setattrl and readdir args keeping pointer because the rest of the code uses them a lot. in upcall_parse() up refcounts on session and open_state if valid handles were passed in. down refcounts upcall_cleanup() as before. but need to be careful with count value for mount and open upcalls. we need to take an extra ref because upcall_cleanup() now will always decrement it.
2011-04-13 20:07:37 -04:00
dprintf(1, "parsing NFS41_ACL_QUERY: info_class=%d\n", args->query);
first stab at handling security irp Basic handling of owner and group security query (no dacl). Added new upcall for NFS41_ACL_QUERY (driver and daemon code). Daemon, upon getting NFS41_ACL_QUERY first places a getattr that has owner, group attribute request. We currently don't cache them!!! Then, we parse nfs4name format (ie user@domain or group@domain) into user and domain. We currently ignore domain part!!! Then, we assume that whatever we are mapping is "known" locally (ie LookupAccountName() api which retrieves a SID for a given name). Mapping from name to SID can only be done in the userland. We then copy the bytes via the upcall pipe to the kernel. If the received user or group cant be mapped via LookupAccoundName(), we create a well known null SID as the reply. Kernel creates a security descriptor in the absolute-format and adds owner and group sids to it. Important: RtlSetOwner/Group functions only work with absolute-format security descriptor, however the reply to the user needs to be in the self-relative format. The way security query works is that it passes us a buffer to be filled with the security context. However the user doesn't know how big the buffer should be so, the user is allowed to pass a null buffer and have the kernel return how much memory is needed. This leads to 2 security queries => 2 NFS41_ACL_QUERY upcalls => 2 getattr rpcs... It should be improved. TODO: - need to add caching of owner/group attributes for a file? - need to add calls to LDAP for more general mapping? - need to cache reply of the ACL if supplied length is 0?
2011-03-15 16:31:52 -04:00
out:
return status;
}
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
static int create_unknownsid(WELL_KNOWN_SID_TYPE type, PSID *sid,
DWORD *sid_len)
first stab at handling security irp Basic handling of owner and group security query (no dacl). Added new upcall for NFS41_ACL_QUERY (driver and daemon code). Daemon, upon getting NFS41_ACL_QUERY first places a getattr that has owner, group attribute request. We currently don't cache them!!! Then, we parse nfs4name format (ie user@domain or group@domain) into user and domain. We currently ignore domain part!!! Then, we assume that whatever we are mapping is "known" locally (ie LookupAccountName() api which retrieves a SID for a given name). Mapping from name to SID can only be done in the userland. We then copy the bytes via the upcall pipe to the kernel. If the received user or group cant be mapped via LookupAccoundName(), we create a well known null SID as the reply. Kernel creates a security descriptor in the absolute-format and adds owner and group sids to it. Important: RtlSetOwner/Group functions only work with absolute-format security descriptor, however the reply to the user needs to be in the self-relative format. The way security query works is that it passes us a buffer to be filled with the security context. However the user doesn't know how big the buffer should be so, the user is allowed to pass a null buffer and have the kernel return how much memory is needed. This leads to 2 security queries => 2 NFS41_ACL_QUERY upcalls => 2 getattr rpcs... It should be improved. TODO: - need to add caching of owner/group attributes for a file? - need to add calls to LDAP for more general mapping? - need to cache reply of the ACL if supplied length is 0?
2011-03-15 16:31:52 -04:00
{
int status;
*sid_len = 0;
*sid = NULL;
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
status = CreateWellKnownSid(type, NULL, *sid, sid_len);
[cosmetic] dprintf changes in acl, getattr, name_cache, namespace
2011-11-07 10:50:00 -05:00
dprintf(ACLLVL, "create_unknownsid: CreateWellKnownSid type %d returned %d "
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
"GetLastError %d sid len %d needed\n", type, status,
GetLastError(), *sid_len);
if (status)
return ERROR_INTERNAL_ERROR;
status = GetLastError();
if (status != ERROR_INSUFFICIENT_BUFFER)
return status;
*sid = malloc(*sid_len);
if (*sid == NULL)
return ERROR_INSUFFICIENT_BUFFER;
status = CreateWellKnownSid(type, NULL, *sid, sid_len);
if (status)
return ERROR_SUCCESS;
free(*sid);
status = GetLastError();
eprintf("create_unknownsid: CreateWellKnownSid failed with %d\n", status);
return status;
first stab at handling security irp Basic handling of owner and group security query (no dacl). Added new upcall for NFS41_ACL_QUERY (driver and daemon code). Daemon, upon getting NFS41_ACL_QUERY first places a getattr that has owner, group attribute request. We currently don't cache them!!! Then, we parse nfs4name format (ie user@domain or group@domain) into user and domain. We currently ignore domain part!!! Then, we assume that whatever we are mapping is "known" locally (ie LookupAccountName() api which retrieves a SID for a given name). Mapping from name to SID can only be done in the userland. We then copy the bytes via the upcall pipe to the kernel. If the received user or group cant be mapped via LookupAccoundName(), we create a well known null SID as the reply. Kernel creates a security descriptor in the absolute-format and adds owner and group sids to it. Important: RtlSetOwner/Group functions only work with absolute-format security descriptor, however the reply to the user needs to be in the self-relative format. The way security query works is that it passes us a buffer to be filled with the security context. However the user doesn't know how big the buffer should be so, the user is allowed to pass a null buffer and have the kernel return how much memory is needed. This leads to 2 security queries => 2 NFS41_ACL_QUERY upcalls => 2 getattr rpcs... It should be improved. TODO: - need to add caching of owner/group attributes for a file? - need to add calls to LDAP for more general mapping? - need to cache reply of the ACL if supplied length is 0?
2011-03-15 16:31:52 -04:00
}
static void convert_nfs4name_2_user_domain(LPSTR nfs4name,
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
LPSTR *domain)
first stab at handling security irp Basic handling of owner and group security query (no dacl). Added new upcall for NFS41_ACL_QUERY (driver and daemon code). Daemon, upon getting NFS41_ACL_QUERY first places a getattr that has owner, group attribute request. We currently don't cache them!!! Then, we parse nfs4name format (ie user@domain or group@domain) into user and domain. We currently ignore domain part!!! Then, we assume that whatever we are mapping is "known" locally (ie LookupAccountName() api which retrieves a SID for a given name). Mapping from name to SID can only be done in the userland. We then copy the bytes via the upcall pipe to the kernel. If the received user or group cant be mapped via LookupAccoundName(), we create a well known null SID as the reply. Kernel creates a security descriptor in the absolute-format and adds owner and group sids to it. Important: RtlSetOwner/Group functions only work with absolute-format security descriptor, however the reply to the user needs to be in the self-relative format. The way security query works is that it passes us a buffer to be filled with the security context. However the user doesn't know how big the buffer should be so, the user is allowed to pass a null buffer and have the kernel return how much memory is needed. This leads to 2 security queries => 2 NFS41_ACL_QUERY upcalls => 2 getattr rpcs... It should be improved. TODO: - need to add caching of owner/group attributes for a file? - need to add calls to LDAP for more general mapping? - need to cache reply of the ACL if supplied length is 0?
2011-03-15 16:31:52 -04:00
{
LPSTR p = nfs4name;
for(; p[0] != '\0'; p++) {
if (p[0] == '@') {
p[0] = '\0';
*domain = &p[1];
break;
}
}
}
static int map_name_2_sid(DWORD *sid_len, PSID *sid, LPCSTR name)
{
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
int status = ERROR_INTERNAL_ERROR;
first stab at handling security irp Basic handling of owner and group security query (no dacl). Added new upcall for NFS41_ACL_QUERY (driver and daemon code). Daemon, upon getting NFS41_ACL_QUERY first places a getattr that has owner, group attribute request. We currently don't cache them!!! Then, we parse nfs4name format (ie user@domain or group@domain) into user and domain. We currently ignore domain part!!! Then, we assume that whatever we are mapping is "known" locally (ie LookupAccountName() api which retrieves a SID for a given name). Mapping from name to SID can only be done in the userland. We then copy the bytes via the upcall pipe to the kernel. If the received user or group cant be mapped via LookupAccoundName(), we create a well known null SID as the reply. Kernel creates a security descriptor in the absolute-format and adds owner and group sids to it. Important: RtlSetOwner/Group functions only work with absolute-format security descriptor, however the reply to the user needs to be in the self-relative format. The way security query works is that it passes us a buffer to be filled with the security context. However the user doesn't know how big the buffer should be so, the user is allowed to pass a null buffer and have the kernel return how much memory is needed. This leads to 2 security queries => 2 NFS41_ACL_QUERY upcalls => 2 getattr rpcs... It should be improved. TODO: - need to add caching of owner/group attributes for a file? - need to add calls to LDAP for more general mapping? - need to cache reply of the ACL if supplied length is 0?
2011-03-15 16:31:52 -04:00
SID_NAME_USE sid_type;
LPSTR tmp_buf = NULL;
DWORD tmp = 0;
status = LookupAccountName(NULL, name, NULL, sid_len, NULL, &tmp, &sid_type);
[cosmetic] dprintf changes in acl, getattr, name_cache, namespace
2011-11-07 10:50:00 -05:00
dprintf(ACLLVL, "map_name_2_sid: LookupAccountName for %s returned %d "
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
"GetLastError %d name len %d domain len %d\n", name, status,
GetLastError(), *sid_len, tmp);
if (status)
return ERROR_INTERNAL_ERROR;
status = GetLastError();
switch(status) {
case ERROR_INSUFFICIENT_BUFFER:
*sid = malloc(*sid_len);
if (*sid == NULL) {
status = GetLastError();
goto out;
}
tmp_buf = (LPSTR) malloc(tmp);
if (tmp_buf == NULL)
goto out_free_sid;
status = LookupAccountName(NULL, name, *sid, sid_len, tmp_buf,
&tmp, &sid_type);
free(tmp_buf);
if (!status) {
eprintf("map_name_2_sid: LookupAccountName for %s failed "
"with %d\n", name, GetLastError());
goto out_free_sid;
} else {
[acls] removing unneeded safety checks
2011-09-23 12:12:45 -04:00
#ifdef DEBUG_ACLS
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
LPSTR ssid = NULL;
if (IsValidSid(*sid))
if (ConvertSidToStringSidA(*sid, &ssid))
dprintf(1, "map_name_2_sid: sid_type = %d SID %s\n",
sid_type, ssid);
else
dprintf(1, "map_name_2_sid: ConvertSidToStringSidA failed "
"with %d\n", GetLastError());
else
dprintf(1, "map_name_2_sid: Invalid Sid ?\n");
if (ssid) LocalFree(ssid);
[acls] removing unneeded safety checks
2011-09-23 12:12:45 -04:00
#endif
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
}
status = ERROR_SUCCESS;
break;
case ERROR_NONE_MAPPED:
status = create_unknownsid(WinNullSid, sid, sid_len);
if (status)
goto out_free_sid;
}
out:
return status;
out_free_sid:
status = GetLastError();
free(*sid);
goto out;
}
static void free_sids(PSID *sids, int count)
{
int i;
for(i = 0; i < count; i++)
free(sids[i]);
free(sids);
}
static int check_4_special_identifiers(char *who, PSID *sid, DWORD *sid_len,
BOOLEAN *flag)
{
int status = ERROR_SUCCESS;
WELL_KNOWN_SID_TYPE type = 0;
*flag = TRUE;
if (!strncmp(who, ACE4_OWNER, strlen(ACE4_OWNER)-1))
type = WinCreatorOwnerSid;
else if (!strncmp(who, ACE4_GROUP, strlen(ACE4_GROUP)-1))
type = WinCreatorGroupSid;
else if (!strncmp(who, ACE4_EVERYONE, strlen(ACE4_EVERYONE)-1))
type = WinWorldSid;
else if (!strncmp(who, ACE4_NOBODY, strlen(ACE4_NOBODY)))
type = WinNullSid;
else
*flag = FALSE;
if (*flag)
status = create_unknownsid(type, sid, sid_len);
return status;
}
static int convert_nfs4acl_2_dacl(nfsacl41 *acl, int file_type,
PACL *dacl_out, PSID **sids_out)
{
int status = ERROR_NOT_SUPPORTED, size = 0;
uint32_t i;
DWORD sid_len;
PSID *sids;
PACL dacl;
LPSTR domain = NULL;
BOOLEAN flag;
sids = malloc(acl->count * sizeof(PSID));
if (sids == NULL) {
first stab at handling security irp Basic handling of owner and group security query (no dacl). Added new upcall for NFS41_ACL_QUERY (driver and daemon code). Daemon, upon getting NFS41_ACL_QUERY first places a getattr that has owner, group attribute request. We currently don't cache them!!! Then, we parse nfs4name format (ie user@domain or group@domain) into user and domain. We currently ignore domain part!!! Then, we assume that whatever we are mapping is "known" locally (ie LookupAccountName() api which retrieves a SID for a given name). Mapping from name to SID can only be done in the userland. We then copy the bytes via the upcall pipe to the kernel. If the received user or group cant be mapped via LookupAccoundName(), we create a well known null SID as the reply. Kernel creates a security descriptor in the absolute-format and adds owner and group sids to it. Important: RtlSetOwner/Group functions only work with absolute-format security descriptor, however the reply to the user needs to be in the self-relative format. The way security query works is that it passes us a buffer to be filled with the security context. However the user doesn't know how big the buffer should be so, the user is allowed to pass a null buffer and have the kernel return how much memory is needed. This leads to 2 security queries => 2 NFS41_ACL_QUERY upcalls => 2 getattr rpcs... It should be improved. TODO: - need to add caching of owner/group attributes for a file? - need to add calls to LDAP for more general mapping? - need to cache reply of the ACL if supplied length is 0?
2011-03-15 16:31:52 -04:00
status = GetLastError();
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
goto out;
}
for (i = 0; i < acl->count; i++) {
daemon: cleaned up compiler warnings raised warning level to /Wall changed nfs41_file_info.owner, owner_group to char[] to avoid casting Signed-off-by: Casey Bodley <cbodley@citi.umich.edu>
2011-07-06 10:53:39 -04:00
convert_nfs4name_2_user_domain(acl->aces[i].who, &domain);
[cosmetic] dprintf changes in acl, getattr, name_cache, namespace
2011-11-07 10:50:00 -05:00
dprintf(ACLLVL, "handle_getacl: for user=%s domain=%s\n",
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
acl->aces[i].who, domain?domain:"<null>");
status = check_4_special_identifiers(acl->aces[i].who, &sids[i],
&sid_len, &flag);
if (status) {
free_sids(sids, i);
goto out;
}
if (!flag) {
daemon: cleaned up compiler warnings raised warning level to /Wall changed nfs41_file_info.owner, owner_group to char[] to avoid casting Signed-off-by: Casey Bodley <cbodley@citi.umich.edu>
2011-07-06 10:53:39 -04:00
status = map_name_2_sid(&sid_len, &sids[i], acl->aces[i].who);
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
if (status) {
free_sids(sids, i);
first stab at handling security irp Basic handling of owner and group security query (no dacl). Added new upcall for NFS41_ACL_QUERY (driver and daemon code). Daemon, upon getting NFS41_ACL_QUERY first places a getattr that has owner, group attribute request. We currently don't cache them!!! Then, we parse nfs4name format (ie user@domain or group@domain) into user and domain. We currently ignore domain part!!! Then, we assume that whatever we are mapping is "known" locally (ie LookupAccountName() api which retrieves a SID for a given name). Mapping from name to SID can only be done in the userland. We then copy the bytes via the upcall pipe to the kernel. If the received user or group cant be mapped via LookupAccoundName(), we create a well known null SID as the reply. Kernel creates a security descriptor in the absolute-format and adds owner and group sids to it. Important: RtlSetOwner/Group functions only work with absolute-format security descriptor, however the reply to the user needs to be in the self-relative format. The way security query works is that it passes us a buffer to be filled with the security context. However the user doesn't know how big the buffer should be so, the user is allowed to pass a null buffer and have the kernel return how much memory is needed. This leads to 2 security queries => 2 NFS41_ACL_QUERY upcalls => 2 getattr rpcs... It should be improved. TODO: - need to add caching of owner/group attributes for a file? - need to add calls to LDAP for more general mapping? - need to cache reply of the ACL if supplied length is 0?
2011-03-15 16:31:52 -04:00
goto out;
}
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
}
size += sid_len - sizeof(DWORD);
}
size += sizeof(ACL) + (sizeof(ACCESS_ALLOWED_ACE)*acl->count);
size = (size + sizeof(DWORD) - 1) & 0xfffffffc; //align size on word boundry
dacl = malloc(size);
if (dacl == NULL)
goto out_free_sids;
if (InitializeAcl(dacl, size, ACL_REVISION)) {
ACCESS_MASK mask;
for (i = 0; i < acl->count; i++) {
// nfs4 acemask should be exactly the same as file access mask
mask = acl->aces[i].acemask;
[cosmetic] dprintf changes in acl, getattr, name_cache, namespace
2011-11-07 10:50:00 -05:00
dprintf(ACLLVL, "access mask %x ace type %s\n", mask,
[bakeathon] [acl] fixing inheritance flags windows inherite directory flag was translated to file inherite flag cosmetic: print ace type
2011-10-24 12:09:49 -04:00
acl->aces[i].acetype?"DENIED ACE":"ALLOWED ACE");
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
if (acl->aces[i].acetype == ACE4_ACCESS_ALLOWED_ACE_TYPE) {
status = AddAccessAllowedAce(dacl, ACL_REVISION, mask, sids[i]);
if (!status) {
eprintf("convert_nfs4acl_2_dacl: AddAccessAllowedAce failed "
"with %d\n", status);
goto out_free_dacl;
}
else status = ERROR_SUCCESS;
} else if (acl->aces[i].acetype == ACE4_ACCESS_DENIED_ACE_TYPE) {
status = AddAccessDeniedAce(dacl, ACL_REVISION, mask, sids[i]);
if (!status) {
eprintf("convert_nfs4acl_2_dacl: AddAccessDeniedAce failed "
"with %d\n", status);
goto out_free_dacl;
}
else status = ERROR_SUCCESS;
first stab at handling security irp Basic handling of owner and group security query (no dacl). Added new upcall for NFS41_ACL_QUERY (driver and daemon code). Daemon, upon getting NFS41_ACL_QUERY first places a getattr that has owner, group attribute request. We currently don't cache them!!! Then, we parse nfs4name format (ie user@domain or group@domain) into user and domain. We currently ignore domain part!!! Then, we assume that whatever we are mapping is "known" locally (ie LookupAccountName() api which retrieves a SID for a given name). Mapping from name to SID can only be done in the userland. We then copy the bytes via the upcall pipe to the kernel. If the received user or group cant be mapped via LookupAccoundName(), we create a well known null SID as the reply. Kernel creates a security descriptor in the absolute-format and adds owner and group sids to it. Important: RtlSetOwner/Group functions only work with absolute-format security descriptor, however the reply to the user needs to be in the self-relative format. The way security query works is that it passes us a buffer to be filled with the security context. However the user doesn't know how big the buffer should be so, the user is allowed to pass a null buffer and have the kernel return how much memory is needed. This leads to 2 security queries => 2 NFS41_ACL_QUERY upcalls => 2 getattr rpcs... It should be improved. TODO: - need to add caching of owner/group attributes for a file? - need to add calls to LDAP for more general mapping? - need to cache reply of the ACL if supplied length is 0?
2011-03-15 16:31:52 -04:00
} else {
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
eprintf("convert_nfs4acl_2_dacl: unknown acetype %d\n",
acl->aces[i].acetype);
status = ERROR_INTERNAL_ERROR;
free(dacl);
free_sids(sids, acl->count);
goto out;
first stab at handling security irp Basic handling of owner and group security query (no dacl). Added new upcall for NFS41_ACL_QUERY (driver and daemon code). Daemon, upon getting NFS41_ACL_QUERY first places a getattr that has owner, group attribute request. We currently don't cache them!!! Then, we parse nfs4name format (ie user@domain or group@domain) into user and domain. We currently ignore domain part!!! Then, we assume that whatever we are mapping is "known" locally (ie LookupAccountName() api which retrieves a SID for a given name). Mapping from name to SID can only be done in the userland. We then copy the bytes via the upcall pipe to the kernel. If the received user or group cant be mapped via LookupAccoundName(), we create a well known null SID as the reply. Kernel creates a security descriptor in the absolute-format and adds owner and group sids to it. Important: RtlSetOwner/Group functions only work with absolute-format security descriptor, however the reply to the user needs to be in the self-relative format. The way security query works is that it passes us a buffer to be filled with the security context. However the user doesn't know how big the buffer should be so, the user is allowed to pass a null buffer and have the kernel return how much memory is needed. This leads to 2 security queries => 2 NFS41_ACL_QUERY upcalls => 2 getattr rpcs... It should be improved. TODO: - need to add caching of owner/group attributes for a file? - need to add calls to LDAP for more general mapping? - need to cache reply of the ACL if supplied length is 0?
2011-03-15 16:31:52 -04:00
}
}
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
} else {
eprintf("convert_nfs4acl_2_dacl: InitializeAcl failed with %d\n", status);
goto out_free_dacl;
}
return success if received empty acl
2011-10-26 12:23:27 -04:00
status = ERROR_SUCCESS;
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
*sids_out = sids;
*dacl_out = dacl;
first stab at handling security irp Basic handling of owner and group security query (no dacl). Added new upcall for NFS41_ACL_QUERY (driver and daemon code). Daemon, upon getting NFS41_ACL_QUERY first places a getattr that has owner, group attribute request. We currently don't cache them!!! Then, we parse nfs4name format (ie user@domain or group@domain) into user and domain. We currently ignore domain part!!! Then, we assume that whatever we are mapping is "known" locally (ie LookupAccountName() api which retrieves a SID for a given name). Mapping from name to SID can only be done in the userland. We then copy the bytes via the upcall pipe to the kernel. If the received user or group cant be mapped via LookupAccoundName(), we create a well known null SID as the reply. Kernel creates a security descriptor in the absolute-format and adds owner and group sids to it. Important: RtlSetOwner/Group functions only work with absolute-format security descriptor, however the reply to the user needs to be in the self-relative format. The way security query works is that it passes us a buffer to be filled with the security context. However the user doesn't know how big the buffer should be so, the user is allowed to pass a null buffer and have the kernel return how much memory is needed. This leads to 2 security queries => 2 NFS41_ACL_QUERY upcalls => 2 getattr rpcs... It should be improved. TODO: - need to add caching of owner/group attributes for a file? - need to add calls to LDAP for more general mapping? - need to cache reply of the ACL if supplied length is 0?
2011-03-15 16:31:52 -04:00
out:
return status;
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
out_free_dacl:
free(dacl);
out_free_sids:
free_sids(sids, acl->count);
status = GetLastError();
goto out;
first stab at handling security irp Basic handling of owner and group security query (no dacl). Added new upcall for NFS41_ACL_QUERY (driver and daemon code). Daemon, upon getting NFS41_ACL_QUERY first places a getattr that has owner, group attribute request. We currently don't cache them!!! Then, we parse nfs4name format (ie user@domain or group@domain) into user and domain. We currently ignore domain part!!! Then, we assume that whatever we are mapping is "known" locally (ie LookupAccountName() api which retrieves a SID for a given name). Mapping from name to SID can only be done in the userland. We then copy the bytes via the upcall pipe to the kernel. If the received user or group cant be mapped via LookupAccoundName(), we create a well known null SID as the reply. Kernel creates a security descriptor in the absolute-format and adds owner and group sids to it. Important: RtlSetOwner/Group functions only work with absolute-format security descriptor, however the reply to the user needs to be in the self-relative format. The way security query works is that it passes us a buffer to be filled with the security context. However the user doesn't know how big the buffer should be so, the user is allowed to pass a null buffer and have the kernel return how much memory is needed. This leads to 2 security queries => 2 NFS41_ACL_QUERY upcalls => 2 getattr rpcs... It should be improved. TODO: - need to add caching of owner/group attributes for a file? - need to add calls to LDAP for more general mapping? - need to cache reply of the ACL if supplied length is 0?
2011-03-15 16:31:52 -04:00
}
static int handle_getacl(nfs41_upcall *upcall)
{
int status = ERROR_NOT_SUPPORTED;
getacl_upcall_args *args = &upcall->args.getacl;
moving session and open_state in upcall header every upcall (except few) pass session and open_state pointer, so add that to marshal_nfs41_header() in the driver. remove passing of session and open_state elsewhere in marshal functions. in the deamon, upcall.c now reads and stores pointers to session and open_state in nfs41_upcall datastructure instead of having each individual upcall store their own pointers. setattrl and readdir args keeping pointer because the rest of the code uses them a lot. in upcall_parse() up refcounts on session and open_state if valid handles were passed in. down refcounts upcall_cleanup() as before. but need to be careful with count value for mount and open upcalls. we need to take an extra ref because upcall_cleanup() now will always decrement it.
2011-04-13 20:07:37 -04:00
nfs41_open_state *state = upcall->state_ref;
removing unnecessary ZeroMemory calls instead of calling ZeroMemory(foobar) to initialize the data structure, during declaration do struct some_struct foobar = { 0 }
2011-08-24 17:43:20 -04:00
nfs41_file_info info = { 0 };
query owner and group attr only on specific getattrs previously we'd query owner and group file attributes on all getattrs and storing that in nfs41_file_info structure which was caused a problem for readdirs.
2011-07-18 14:21:29 -04:00
bitmap4 attr_request = { 0 };
first stab at handling security irp Basic handling of owner and group security query (no dacl). Added new upcall for NFS41_ACL_QUERY (driver and daemon code). Daemon, upon getting NFS41_ACL_QUERY first places a getattr that has owner, group attribute request. We currently don't cache them!!! Then, we parse nfs4name format (ie user@domain or group@domain) into user and domain. We currently ignore domain part!!! Then, we assume that whatever we are mapping is "known" locally (ie LookupAccountName() api which retrieves a SID for a given name). Mapping from name to SID can only be done in the userland. We then copy the bytes via the upcall pipe to the kernel. If the received user or group cant be mapped via LookupAccoundName(), we create a well known null SID as the reply. Kernel creates a security descriptor in the absolute-format and adds owner and group sids to it. Important: RtlSetOwner/Group functions only work with absolute-format security descriptor, however the reply to the user needs to be in the self-relative format. The way security query works is that it passes us a buffer to be filled with the security context. However the user doesn't know how big the buffer should be so, the user is allowed to pass a null buffer and have the kernel return how much memory is needed. This leads to 2 security queries => 2 NFS41_ACL_QUERY upcalls => 2 getattr rpcs... It should be improved. TODO: - need to add caching of owner/group attributes for a file? - need to add calls to LDAP for more general mapping? - need to cache reply of the ACL if supplied length is 0?
2011-03-15 16:31:52 -04:00
LPSTR domain = NULL;
changing getacl downcall instead of passing sids for the owner and group, create a security descriptor and pass that back. this way we can add all the security information that was queried in the daemon and pass a fully formed security descriptor back to the kernel. notice: irp_mj_query_security provides a pointer to the buffer that suppose to hold the security descriptor. that memory is valid only in the context of the process doing the security irp. we can't use this pointer in then upcall entry and try to write the security descriptor directly there as we process the downcall. that leads to kernel oops. thus we have to first allocate memory to hold the security descriptor then copy bytes passed to us from the daemon. then do another copy with the context of the security irp.
2011-04-08 20:19:59 -04:00
SECURITY_DESCRIPTOR sec_desc;
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
PACL dacl = NULL;
PSID *sids = NULL;
PSID osid = NULL, gsid = NULL;
DWORD sid_len;
query owner and group attr only on specific getattrs previously we'd query owner and group file attributes on all getattrs and storing that in nfs41_file_info structure which was caused a problem for readdirs.
2011-07-18 14:21:29 -04:00
char owner[NFS4_OPAQUE_LIMIT], group[NFS4_OPAQUE_LIMIT];
[acl] using static memory for main getacl structure
2011-09-07 13:04:32 -04:00
nfsacl41 acl = { 0 };
first stab at handling security irp Basic handling of owner and group security query (no dacl). Added new upcall for NFS41_ACL_QUERY (driver and daemon code). Daemon, upon getting NFS41_ACL_QUERY first places a getattr that has owner, group attribute request. We currently don't cache them!!! Then, we parse nfs4name format (ie user@domain or group@domain) into user and domain. We currently ignore domain part!!! Then, we assume that whatever we are mapping is "known" locally (ie LookupAccountName() api which retrieves a SID for a given name). Mapping from name to SID can only be done in the userland. We then copy the bytes via the upcall pipe to the kernel. If the received user or group cant be mapped via LookupAccoundName(), we create a well known null SID as the reply. Kernel creates a security descriptor in the absolute-format and adds owner and group sids to it. Important: RtlSetOwner/Group functions only work with absolute-format security descriptor, however the reply to the user needs to be in the self-relative format. The way security query works is that it passes us a buffer to be filled with the security context. However the user doesn't know how big the buffer should be so, the user is allowed to pass a null buffer and have the kernel return how much memory is needed. This leads to 2 security queries => 2 NFS41_ACL_QUERY upcalls => 2 getattr rpcs... It should be improved. TODO: - need to add caching of owner/group attributes for a file? - need to add calls to LDAP for more general mapping? - need to cache reply of the ACL if supplied length is 0?
2011-03-15 16:31:52 -04:00
// need to cache owner/group information XX
query owner and group attr only on specific getattrs previously we'd query owner and group file attributes on all getattrs and storing that in nfs41_file_info structure which was caused a problem for readdirs.
2011-07-18 14:21:29 -04:00
attr_request.count = 2;
attr_request.arr[1] = FATTR4_WORD1_OWNER | FATTR4_WORD1_OWNER_GROUP;
fattr4_word0_acl query during nfs41_acl_query upcall querying the server for the acl attribute during the nfs41_acl_query upcall. no mapping of the nfs41 acl to the windows dacl yet.
2011-03-31 19:43:04 -04:00
if (args->query & DACL_SECURITY_INFORMATION) {
[acl] using static memory for main getacl structure
2011-09-07 13:04:32 -04:00
info.acl = &acl;
fattr4_word0_acl query during nfs41_acl_query upcall querying the server for the acl attribute during the nfs41_acl_query upcall. no mapping of the nfs41 acl to the windows dacl yet.
2011-03-31 19:43:04 -04:00
attr_request.arr[0] |= FATTR4_WORD0_ACL;
}
query owner and group attr only on specific getattrs previously we'd query owner and group file attributes on all getattrs and storing that in nfs41_file_info structure which was caused a problem for readdirs.
2011-07-18 14:21:29 -04:00
info.owner = owner;
info.owner_group = group;
first stab at handling security irp Basic handling of owner and group security query (no dacl). Added new upcall for NFS41_ACL_QUERY (driver and daemon code). Daemon, upon getting NFS41_ACL_QUERY first places a getattr that has owner, group attribute request. We currently don't cache them!!! Then, we parse nfs4name format (ie user@domain or group@domain) into user and domain. We currently ignore domain part!!! Then, we assume that whatever we are mapping is "known" locally (ie LookupAccountName() api which retrieves a SID for a given name). Mapping from name to SID can only be done in the userland. We then copy the bytes via the upcall pipe to the kernel. If the received user or group cant be mapped via LookupAccoundName(), we create a well known null SID as the reply. Kernel creates a security descriptor in the absolute-format and adds owner and group sids to it. Important: RtlSetOwner/Group functions only work with absolute-format security descriptor, however the reply to the user needs to be in the self-relative format. The way security query works is that it passes us a buffer to be filled with the security context. However the user doesn't know how big the buffer should be so, the user is allowed to pass a null buffer and have the kernel return how much memory is needed. This leads to 2 security queries => 2 NFS41_ACL_QUERY upcalls => 2 getattr rpcs... It should be improved. TODO: - need to add caching of owner/group attributes for a file? - need to add calls to LDAP for more general mapping? - need to cache reply of the ACL if supplied length is 0?
2011-03-15 16:31:52 -04:00
status = nfs41_getattr(state->session, &state->file, &attr_request, &info);
if (status) {
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
eprintf("handle_getacl: nfs41_cached_getattr() failed with %d\n",
status);
first stab at handling security irp Basic handling of owner and group security query (no dacl). Added new upcall for NFS41_ACL_QUERY (driver and daemon code). Daemon, upon getting NFS41_ACL_QUERY first places a getattr that has owner, group attribute request. We currently don't cache them!!! Then, we parse nfs4name format (ie user@domain or group@domain) into user and domain. We currently ignore domain part!!! Then, we assume that whatever we are mapping is "known" locally (ie LookupAccountName() api which retrieves a SID for a given name). Mapping from name to SID can only be done in the userland. We then copy the bytes via the upcall pipe to the kernel. If the received user or group cant be mapped via LookupAccoundName(), we create a well known null SID as the reply. Kernel creates a security descriptor in the absolute-format and adds owner and group sids to it. Important: RtlSetOwner/Group functions only work with absolute-format security descriptor, however the reply to the user needs to be in the self-relative format. The way security query works is that it passes us a buffer to be filled with the security context. However the user doesn't know how big the buffer should be so, the user is allowed to pass a null buffer and have the kernel return how much memory is needed. This leads to 2 security queries => 2 NFS41_ACL_QUERY upcalls => 2 getattr rpcs... It should be improved. TODO: - need to add caching of owner/group attributes for a file? - need to add calls to LDAP for more general mapping? - need to cache reply of the ACL if supplied length is 0?
2011-03-15 16:31:52 -04:00
goto out;
}
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
status = InitializeSecurityDescriptor(&sec_desc,
SECURITY_DESCRIPTOR_REVISION);
changing getacl downcall instead of passing sids for the owner and group, create a security descriptor and pass that back. this way we can add all the security information that was queried in the daemon and pass a fully formed security descriptor back to the kernel. notice: irp_mj_query_security provides a pointer to the buffer that suppose to hold the security descriptor. that memory is valid only in the context of the process doing the security irp. we can't use this pointer in then upcall entry and try to write the security descriptor directly there as we process the downcall. that leads to kernel oops. thus we have to first allocate memory to hold the security descriptor then copy bytes passed to us from the daemon. then do another copy with the context of the security irp.
2011-04-08 20:19:59 -04:00
if (!status) {
status = GetLastError();
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
eprintf("handle_getacl: InitializeSecurityDescriptor failed with %d\n",
status);
changing getacl downcall instead of passing sids for the owner and group, create a security descriptor and pass that back. this way we can add all the security information that was queried in the daemon and pass a fully formed security descriptor back to the kernel. notice: irp_mj_query_security provides a pointer to the buffer that suppose to hold the security descriptor. that memory is valid only in the context of the process doing the security irp. we can't use this pointer in then upcall entry and try to write the security descriptor directly there as we process the downcall. that leads to kernel oops. thus we have to first allocate memory to hold the security descriptor then copy bytes passed to us from the daemon. then do another copy with the context of the security irp.
2011-04-08 20:19:59 -04:00
goto out;
}
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
/* can't (re)use the same sid variable for both owner and group sids
* because security descriptor is created in absolute-form and it just
* stores pointers to the sids. thus each owner and group needs its own
* memory. free them after creating self-relative security descriptor.
*/
first stab at handling security irp Basic handling of owner and group security query (no dacl). Added new upcall for NFS41_ACL_QUERY (driver and daemon code). Daemon, upon getting NFS41_ACL_QUERY first places a getattr that has owner, group attribute request. We currently don't cache them!!! Then, we parse nfs4name format (ie user@domain or group@domain) into user and domain. We currently ignore domain part!!! Then, we assume that whatever we are mapping is "known" locally (ie LookupAccountName() api which retrieves a SID for a given name). Mapping from name to SID can only be done in the userland. We then copy the bytes via the upcall pipe to the kernel. If the received user or group cant be mapped via LookupAccoundName(), we create a well known null SID as the reply. Kernel creates a security descriptor in the absolute-format and adds owner and group sids to it. Important: RtlSetOwner/Group functions only work with absolute-format security descriptor, however the reply to the user needs to be in the self-relative format. The way security query works is that it passes us a buffer to be filled with the security context. However the user doesn't know how big the buffer should be so, the user is allowed to pass a null buffer and have the kernel return how much memory is needed. This leads to 2 security queries => 2 NFS41_ACL_QUERY upcalls => 2 getattr rpcs... It should be improved. TODO: - need to add caching of owner/group attributes for a file? - need to add calls to LDAP for more general mapping? - need to cache reply of the ACL if supplied length is 0?
2011-03-15 16:31:52 -04:00
if (args->query & OWNER_SECURITY_INFORMATION) {
// parse user@domain. currently ignoring domain part XX
daemon: cleaned up compiler warnings raised warning level to /Wall changed nfs41_file_info.owner, owner_group to char[] to avoid casting Signed-off-by: Casey Bodley <cbodley@citi.umich.edu>
2011-07-06 10:53:39 -04:00
convert_nfs4name_2_user_domain(info.owner, &domain);
[cosmetic] dprintf changes in acl, getattr, name_cache, namespace
2011-11-07 10:50:00 -05:00
dprintf(ACLLVL, "handle_getacl: OWNER_SECURITY_INFORMATION: for user=%s "
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
"domain=%s\n", info.owner, domain?domain:"<null>");
sid_len = 0;
daemon: cleaned up compiler warnings raised warning level to /Wall changed nfs41_file_info.owner, owner_group to char[] to avoid casting Signed-off-by: Casey Bodley <cbodley@citi.umich.edu>
2011-07-06 10:53:39 -04:00
status = map_name_2_sid(&sid_len, &osid, info.owner);
first stab at handling security irp Basic handling of owner and group security query (no dacl). Added new upcall for NFS41_ACL_QUERY (driver and daemon code). Daemon, upon getting NFS41_ACL_QUERY first places a getattr that has owner, group attribute request. We currently don't cache them!!! Then, we parse nfs4name format (ie user@domain or group@domain) into user and domain. We currently ignore domain part!!! Then, we assume that whatever we are mapping is "known" locally (ie LookupAccountName() api which retrieves a SID for a given name). Mapping from name to SID can only be done in the userland. We then copy the bytes via the upcall pipe to the kernel. If the received user or group cant be mapped via LookupAccoundName(), we create a well known null SID as the reply. Kernel creates a security descriptor in the absolute-format and adds owner and group sids to it. Important: RtlSetOwner/Group functions only work with absolute-format security descriptor, however the reply to the user needs to be in the self-relative format. The way security query works is that it passes us a buffer to be filled with the security context. However the user doesn't know how big the buffer should be so, the user is allowed to pass a null buffer and have the kernel return how much memory is needed. This leads to 2 security queries => 2 NFS41_ACL_QUERY upcalls => 2 getattr rpcs... It should be improved. TODO: - need to add caching of owner/group attributes for a file? - need to add calls to LDAP for more general mapping? - need to cache reply of the ACL if supplied length is 0?
2011-03-15 16:31:52 -04:00
if (status)
goto out;
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
status = SetSecurityDescriptorOwner(&sec_desc, osid, TRUE);
changing getacl downcall instead of passing sids for the owner and group, create a security descriptor and pass that back. this way we can add all the security information that was queried in the daemon and pass a fully formed security descriptor back to the kernel. notice: irp_mj_query_security provides a pointer to the buffer that suppose to hold the security descriptor. that memory is valid only in the context of the process doing the security irp. we can't use this pointer in then upcall entry and try to write the security descriptor directly there as we process the downcall. that leads to kernel oops. thus we have to first allocate memory to hold the security descriptor then copy bytes passed to us from the daemon. then do another copy with the context of the security irp.
2011-04-08 20:19:59 -04:00
if (!status) {
status = GetLastError();
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
eprintf("handle_getacl: SetSecurityDescriptorOwner failed with "
"%d\n", status);
changing getacl downcall instead of passing sids for the owner and group, create a security descriptor and pass that back. this way we can add all the security information that was queried in the daemon and pass a fully formed security descriptor back to the kernel. notice: irp_mj_query_security provides a pointer to the buffer that suppose to hold the security descriptor. that memory is valid only in the context of the process doing the security irp. we can't use this pointer in then upcall entry and try to write the security descriptor directly there as we process the downcall. that leads to kernel oops. thus we have to first allocate memory to hold the security descriptor then copy bytes passed to us from the daemon. then do another copy with the context of the security irp.
2011-04-08 20:19:59 -04:00
goto out;
}
first stab at handling security irp Basic handling of owner and group security query (no dacl). Added new upcall for NFS41_ACL_QUERY (driver and daemon code). Daemon, upon getting NFS41_ACL_QUERY first places a getattr that has owner, group attribute request. We currently don't cache them!!! Then, we parse nfs4name format (ie user@domain or group@domain) into user and domain. We currently ignore domain part!!! Then, we assume that whatever we are mapping is "known" locally (ie LookupAccountName() api which retrieves a SID for a given name). Mapping from name to SID can only be done in the userland. We then copy the bytes via the upcall pipe to the kernel. If the received user or group cant be mapped via LookupAccoundName(), we create a well known null SID as the reply. Kernel creates a security descriptor in the absolute-format and adds owner and group sids to it. Important: RtlSetOwner/Group functions only work with absolute-format security descriptor, however the reply to the user needs to be in the self-relative format. The way security query works is that it passes us a buffer to be filled with the security context. However the user doesn't know how big the buffer should be so, the user is allowed to pass a null buffer and have the kernel return how much memory is needed. This leads to 2 security queries => 2 NFS41_ACL_QUERY upcalls => 2 getattr rpcs... It should be improved. TODO: - need to add caching of owner/group attributes for a file? - need to add calls to LDAP for more general mapping? - need to cache reply of the ACL if supplied length is 0?
2011-03-15 16:31:52 -04:00
}
if (args->query & GROUP_SECURITY_INFORMATION) {
daemon: cleaned up compiler warnings raised warning level to /Wall changed nfs41_file_info.owner, owner_group to char[] to avoid casting Signed-off-by: Casey Bodley <cbodley@citi.umich.edu>
2011-07-06 10:53:39 -04:00
convert_nfs4name_2_user_domain(info.owner_group, &domain);
[cosmetic] dprintf changes in acl, getattr, name_cache, namespace
2011-11-07 10:50:00 -05:00
dprintf(ACLLVL, "handle_getacl: GROUP_SECURITY_INFORMATION: for %s "
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
"domain=%s\n", info.owner_group, domain?domain:"<null>");
sid_len = 0;
daemon: cleaned up compiler warnings raised warning level to /Wall changed nfs41_file_info.owner, owner_group to char[] to avoid casting Signed-off-by: Casey Bodley <cbodley@citi.umich.edu>
2011-07-06 10:53:39 -04:00
status = map_name_2_sid(&sid_len, &gsid, info.owner_group);
first stab at handling security irp Basic handling of owner and group security query (no dacl). Added new upcall for NFS41_ACL_QUERY (driver and daemon code). Daemon, upon getting NFS41_ACL_QUERY first places a getattr that has owner, group attribute request. We currently don't cache them!!! Then, we parse nfs4name format (ie user@domain or group@domain) into user and domain. We currently ignore domain part!!! Then, we assume that whatever we are mapping is "known" locally (ie LookupAccountName() api which retrieves a SID for a given name). Mapping from name to SID can only be done in the userland. We then copy the bytes via the upcall pipe to the kernel. If the received user or group cant be mapped via LookupAccoundName(), we create a well known null SID as the reply. Kernel creates a security descriptor in the absolute-format and adds owner and group sids to it. Important: RtlSetOwner/Group functions only work with absolute-format security descriptor, however the reply to the user needs to be in the self-relative format. The way security query works is that it passes us a buffer to be filled with the security context. However the user doesn't know how big the buffer should be so, the user is allowed to pass a null buffer and have the kernel return how much memory is needed. This leads to 2 security queries => 2 NFS41_ACL_QUERY upcalls => 2 getattr rpcs... It should be improved. TODO: - need to add caching of owner/group attributes for a file? - need to add calls to LDAP for more general mapping? - need to cache reply of the ACL if supplied length is 0?
2011-03-15 16:31:52 -04:00
if (status)
goto out;
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
status = SetSecurityDescriptorGroup(&sec_desc, gsid, TRUE);
changing getacl downcall instead of passing sids for the owner and group, create a security descriptor and pass that back. this way we can add all the security information that was queried in the daemon and pass a fully formed security descriptor back to the kernel. notice: irp_mj_query_security provides a pointer to the buffer that suppose to hold the security descriptor. that memory is valid only in the context of the process doing the security irp. we can't use this pointer in then upcall entry and try to write the security descriptor directly there as we process the downcall. that leads to kernel oops. thus we have to first allocate memory to hold the security descriptor then copy bytes passed to us from the daemon. then do another copy with the context of the security irp.
2011-04-08 20:19:59 -04:00
if (!status) {
status = GetLastError();
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
eprintf("handle_getacl: SetSecurityDescriptorGroup failed with "
"%d\n", status);
changing getacl downcall instead of passing sids for the owner and group, create a security descriptor and pass that back. this way we can add all the security information that was queried in the daemon and pass a fully formed security descriptor back to the kernel. notice: irp_mj_query_security provides a pointer to the buffer that suppose to hold the security descriptor. that memory is valid only in the context of the process doing the security irp. we can't use this pointer in then upcall entry and try to write the security descriptor directly there as we process the downcall. that leads to kernel oops. thus we have to first allocate memory to hold the security descriptor then copy bytes passed to us from the daemon. then do another copy with the context of the security irp.
2011-04-08 20:19:59 -04:00
goto out;
}
first stab at handling security irp Basic handling of owner and group security query (no dacl). Added new upcall for NFS41_ACL_QUERY (driver and daemon code). Daemon, upon getting NFS41_ACL_QUERY first places a getattr that has owner, group attribute request. We currently don't cache them!!! Then, we parse nfs4name format (ie user@domain or group@domain) into user and domain. We currently ignore domain part!!! Then, we assume that whatever we are mapping is "known" locally (ie LookupAccountName() api which retrieves a SID for a given name). Mapping from name to SID can only be done in the userland. We then copy the bytes via the upcall pipe to the kernel. If the received user or group cant be mapped via LookupAccoundName(), we create a well known null SID as the reply. Kernel creates a security descriptor in the absolute-format and adds owner and group sids to it. Important: RtlSetOwner/Group functions only work with absolute-format security descriptor, however the reply to the user needs to be in the self-relative format. The way security query works is that it passes us a buffer to be filled with the security context. However the user doesn't know how big the buffer should be so, the user is allowed to pass a null buffer and have the kernel return how much memory is needed. This leads to 2 security queries => 2 NFS41_ACL_QUERY upcalls => 2 getattr rpcs... It should be improved. TODO: - need to add caching of owner/group attributes for a file? - need to add calls to LDAP for more general mapping? - need to cache reply of the ACL if supplied length is 0?
2011-03-15 16:31:52 -04:00
}
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
if (args->query & DACL_SECURITY_INFORMATION) {
[cosmetic] dprintf changes in acl, getattr, name_cache, namespace
2011-11-07 10:50:00 -05:00
dprintf(ACLLVL, "handle_getacl: DACL_SECURITY_INFORMATION\n");
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
status = convert_nfs4acl_2_dacl(info.acl, state->type, &dacl, &sids);
if (status)
goto out;
status = SetSecurityDescriptorDacl(&sec_desc, TRUE, dacl, TRUE);
if (!status) {
status = GetLastError();
eprintf("handle_getacl: SetSecurityDescriptorDacl failed with "
"%d\n", status);
goto out;
}
}
first stab at handling security irp Basic handling of owner and group security query (no dacl). Added new upcall for NFS41_ACL_QUERY (driver and daemon code). Daemon, upon getting NFS41_ACL_QUERY first places a getattr that has owner, group attribute request. We currently don't cache them!!! Then, we parse nfs4name format (ie user@domain or group@domain) into user and domain. We currently ignore domain part!!! Then, we assume that whatever we are mapping is "known" locally (ie LookupAccountName() api which retrieves a SID for a given name). Mapping from name to SID can only be done in the userland. We then copy the bytes via the upcall pipe to the kernel. If the received user or group cant be mapped via LookupAccoundName(), we create a well known null SID as the reply. Kernel creates a security descriptor in the absolute-format and adds owner and group sids to it. Important: RtlSetOwner/Group functions only work with absolute-format security descriptor, however the reply to the user needs to be in the self-relative format. The way security query works is that it passes us a buffer to be filled with the security context. However the user doesn't know how big the buffer should be so, the user is allowed to pass a null buffer and have the kernel return how much memory is needed. This leads to 2 security queries => 2 NFS41_ACL_QUERY upcalls => 2 getattr rpcs... It should be improved. TODO: - need to add caching of owner/group attributes for a file? - need to add calls to LDAP for more general mapping? - need to cache reply of the ACL if supplied length is 0?
2011-03-15 16:31:52 -04:00
changing getacl downcall instead of passing sids for the owner and group, create a security descriptor and pass that back. this way we can add all the security information that was queried in the daemon and pass a fully formed security descriptor back to the kernel. notice: irp_mj_query_security provides a pointer to the buffer that suppose to hold the security descriptor. that memory is valid only in the context of the process doing the security irp. we can't use this pointer in then upcall entry and try to write the security descriptor directly there as we process the downcall. that leads to kernel oops. thus we have to first allocate memory to hold the security descriptor then copy bytes passed to us from the daemon. then do another copy with the context of the security irp.
2011-04-08 20:19:59 -04:00
args->sec_desc_len = 0;
status = MakeSelfRelativeSD(&sec_desc, args->sec_desc, &args->sec_desc_len);
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
if (status) {
changing getacl downcall instead of passing sids for the owner and group, create a security descriptor and pass that back. this way we can add all the security information that was queried in the daemon and pass a fully formed security descriptor back to the kernel. notice: irp_mj_query_security provides a pointer to the buffer that suppose to hold the security descriptor. that memory is valid only in the context of the process doing the security irp. we can't use this pointer in then upcall entry and try to write the security descriptor directly there as we process the downcall. that leads to kernel oops. thus we have to first allocate memory to hold the security descriptor then copy bytes passed to us from the daemon. then do another copy with the context of the security irp.
2011-04-08 20:19:59 -04:00
status = ERROR_INTERNAL_ERROR;
first stab at handling security irp Basic handling of owner and group security query (no dacl). Added new upcall for NFS41_ACL_QUERY (driver and daemon code). Daemon, upon getting NFS41_ACL_QUERY first places a getattr that has owner, group attribute request. We currently don't cache them!!! Then, we parse nfs4name format (ie user@domain or group@domain) into user and domain. We currently ignore domain part!!! Then, we assume that whatever we are mapping is "known" locally (ie LookupAccountName() api which retrieves a SID for a given name). Mapping from name to SID can only be done in the userland. We then copy the bytes via the upcall pipe to the kernel. If the received user or group cant be mapped via LookupAccoundName(), we create a well known null SID as the reply. Kernel creates a security descriptor in the absolute-format and adds owner and group sids to it. Important: RtlSetOwner/Group functions only work with absolute-format security descriptor, however the reply to the user needs to be in the self-relative format. The way security query works is that it passes us a buffer to be filled with the security context. However the user doesn't know how big the buffer should be so, the user is allowed to pass a null buffer and have the kernel return how much memory is needed. This leads to 2 security queries => 2 NFS41_ACL_QUERY upcalls => 2 getattr rpcs... It should be improved. TODO: - need to add caching of owner/group attributes for a file? - need to add calls to LDAP for more general mapping? - need to cache reply of the ACL if supplied length is 0?
2011-03-15 16:31:52 -04:00
goto out;
}
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
status = GetLastError();
if (status != ERROR_INSUFFICIENT_BUFFER) {
eprintf("handle_getacl: MakeSelfRelativeSD failes with %d\n", status);
goto out;
}
args->sec_desc = malloc(args->sec_desc_len);
if (args->sec_desc == NULL) {
status = GetLastError();
goto out;
}
status = MakeSelfRelativeSD(&sec_desc, args->sec_desc, &args->sec_desc_len);
if (!status) {
status = GetLastError();
eprintf("handle_getacl: MakeSelfRelativeSD failes with %d\n", status);
free(args->sec_desc);
goto out;
} else status = ERROR_SUCCESS;
changing getacl downcall instead of passing sids for the owner and group, create a security descriptor and pass that back. this way we can add all the security information that was queried in the daemon and pass a fully formed security descriptor back to the kernel. notice: irp_mj_query_security provides a pointer to the buffer that suppose to hold the security descriptor. that memory is valid only in the context of the process doing the security irp. we can't use this pointer in then upcall entry and try to write the security descriptor directly there as we process the downcall. that leads to kernel oops. thus we have to first allocate memory to hold the security descriptor then copy bytes passed to us from the daemon. then do another copy with the context of the security irp.
2011-04-08 20:19:59 -04:00
first stab at handling security irp Basic handling of owner and group security query (no dacl). Added new upcall for NFS41_ACL_QUERY (driver and daemon code). Daemon, upon getting NFS41_ACL_QUERY first places a getattr that has owner, group attribute request. We currently don't cache them!!! Then, we parse nfs4name format (ie user@domain or group@domain) into user and domain. We currently ignore domain part!!! Then, we assume that whatever we are mapping is "known" locally (ie LookupAccountName() api which retrieves a SID for a given name). Mapping from name to SID can only be done in the userland. We then copy the bytes via the upcall pipe to the kernel. If the received user or group cant be mapped via LookupAccoundName(), we create a well known null SID as the reply. Kernel creates a security descriptor in the absolute-format and adds owner and group sids to it. Important: RtlSetOwner/Group functions only work with absolute-format security descriptor, however the reply to the user needs to be in the self-relative format. The way security query works is that it passes us a buffer to be filled with the security context. However the user doesn't know how big the buffer should be so, the user is allowed to pass a null buffer and have the kernel return how much memory is needed. This leads to 2 security queries => 2 NFS41_ACL_QUERY upcalls => 2 getattr rpcs... It should be improved. TODO: - need to add caching of owner/group attributes for a file? - need to add calls to LDAP for more general mapping? - need to cache reply of the ACL if supplied length is 0?
2011-03-15 16:31:52 -04:00
out:
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
if (args->query & OWNER_SECURITY_INFORMATION) {
if (osid) free(osid);
}
if (args->query & GROUP_SECURITY_INFORMATION) {
if (gsid) free(gsid);
}
changing getacl downcall instead of passing sids for the owner and group, create a security descriptor and pass that back. this way we can add all the security information that was queried in the daemon and pass a fully formed security descriptor back to the kernel. notice: irp_mj_query_security provides a pointer to the buffer that suppose to hold the security descriptor. that memory is valid only in the context of the process doing the security irp. we can't use this pointer in then upcall entry and try to write the security descriptor directly there as we process the downcall. that leads to kernel oops. thus we have to first allocate memory to hold the security descriptor then copy bytes passed to us from the daemon. then do another copy with the context of the security irp.
2011-04-08 20:19:59 -04:00
if (args->query & DACL_SECURITY_INFORMATION) {
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
if (sids) free_sids(sids, info.acl->count);
free(dacl);
changing getacl downcall instead of passing sids for the owner and group, create a security descriptor and pass that back. this way we can add all the security information that was queried in the daemon and pass a fully formed security descriptor back to the kernel. notice: irp_mj_query_security provides a pointer to the buffer that suppose to hold the security descriptor. that memory is valid only in the context of the process doing the security irp. we can't use this pointer in then upcall entry and try to write the security descriptor directly there as we process the downcall. that leads to kernel oops. thus we have to first allocate memory to hold the security descriptor then copy bytes passed to us from the daemon. then do another copy with the context of the security irp.
2011-04-08 20:19:59 -04:00
nfsacl41_free(info.acl);
}
first stab at handling security irp Basic handling of owner and group security query (no dacl). Added new upcall for NFS41_ACL_QUERY (driver and daemon code). Daemon, upon getting NFS41_ACL_QUERY first places a getattr that has owner, group attribute request. We currently don't cache them!!! Then, we parse nfs4name format (ie user@domain or group@domain) into user and domain. We currently ignore domain part!!! Then, we assume that whatever we are mapping is "known" locally (ie LookupAccountName() api which retrieves a SID for a given name). Mapping from name to SID can only be done in the userland. We then copy the bytes via the upcall pipe to the kernel. If the received user or group cant be mapped via LookupAccoundName(), we create a well known null SID as the reply. Kernel creates a security descriptor in the absolute-format and adds owner and group sids to it. Important: RtlSetOwner/Group functions only work with absolute-format security descriptor, however the reply to the user needs to be in the self-relative format. The way security query works is that it passes us a buffer to be filled with the security context. However the user doesn't know how big the buffer should be so, the user is allowed to pass a null buffer and have the kernel return how much memory is needed. This leads to 2 security queries => 2 NFS41_ACL_QUERY upcalls => 2 getattr rpcs... It should be improved. TODO: - need to add caching of owner/group attributes for a file? - need to add calls to LDAP for more general mapping? - need to cache reply of the ACL if supplied length is 0?
2011-03-15 16:31:52 -04:00
return status;
}
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
static int marshall_getacl(unsigned char *buffer, uint32_t *length,
nfs41_upcall *upcall)
first stab at handling security irp Basic handling of owner and group security query (no dacl). Added new upcall for NFS41_ACL_QUERY (driver and daemon code). Daemon, upon getting NFS41_ACL_QUERY first places a getattr that has owner, group attribute request. We currently don't cache them!!! Then, we parse nfs4name format (ie user@domain or group@domain) into user and domain. We currently ignore domain part!!! Then, we assume that whatever we are mapping is "known" locally (ie LookupAccountName() api which retrieves a SID for a given name). Mapping from name to SID can only be done in the userland. We then copy the bytes via the upcall pipe to the kernel. If the received user or group cant be mapped via LookupAccoundName(), we create a well known null SID as the reply. Kernel creates a security descriptor in the absolute-format and adds owner and group sids to it. Important: RtlSetOwner/Group functions only work with absolute-format security descriptor, however the reply to the user needs to be in the self-relative format. The way security query works is that it passes us a buffer to be filled with the security context. However the user doesn't know how big the buffer should be so, the user is allowed to pass a null buffer and have the kernel return how much memory is needed. This leads to 2 security queries => 2 NFS41_ACL_QUERY upcalls => 2 getattr rpcs... It should be improved. TODO: - need to add caching of owner/group attributes for a file? - need to add calls to LDAP for more general mapping? - need to cache reply of the ACL if supplied length is 0?
2011-03-15 16:31:52 -04:00
{
int status = ERROR_NOT_SUPPORTED;
getacl_upcall_args *args = &upcall->args.getacl;
changing getacl downcall instead of passing sids for the owner and group, create a security descriptor and pass that back. this way we can add all the security information that was queried in the daemon and pass a fully formed security descriptor back to the kernel. notice: irp_mj_query_security provides a pointer to the buffer that suppose to hold the security descriptor. that memory is valid only in the context of the process doing the security irp. we can't use this pointer in then upcall entry and try to write the security descriptor directly there as we process the downcall. that leads to kernel oops. thus we have to first allocate memory to hold the security descriptor then copy bytes passed to us from the daemon. then do another copy with the context of the security irp.
2011-04-08 20:19:59 -04:00
status = safe_write(&buffer, length, &args->sec_desc_len, sizeof(DWORD));
if (status) goto out;
status = safe_write(&buffer, length, args->sec_desc, args->sec_desc_len);
free(args->sec_desc);
if (status) goto out;
first stab at handling security irp Basic handling of owner and group security query (no dacl). Added new upcall for NFS41_ACL_QUERY (driver and daemon code). Daemon, upon getting NFS41_ACL_QUERY first places a getattr that has owner, group attribute request. We currently don't cache them!!! Then, we parse nfs4name format (ie user@domain or group@domain) into user and domain. We currently ignore domain part!!! Then, we assume that whatever we are mapping is "known" locally (ie LookupAccountName() api which retrieves a SID for a given name). Mapping from name to SID can only be done in the userland. We then copy the bytes via the upcall pipe to the kernel. If the received user or group cant be mapped via LookupAccoundName(), we create a well known null SID as the reply. Kernel creates a security descriptor in the absolute-format and adds owner and group sids to it. Important: RtlSetOwner/Group functions only work with absolute-format security descriptor, however the reply to the user needs to be in the self-relative format. The way security query works is that it passes us a buffer to be filled with the security context. However the user doesn't know how big the buffer should be so, the user is allowed to pass a null buffer and have the kernel return how much memory is needed. This leads to 2 security queries => 2 NFS41_ACL_QUERY upcalls => 2 getattr rpcs... It should be improved. TODO: - need to add caching of owner/group attributes for a file? - need to add calls to LDAP for more general mapping? - need to cache reply of the ACL if supplied length is 0?
2011-03-15 16:31:52 -04:00
out:
return status;
}
const nfs41_upcall_op nfs41_op_getacl = {
parse_getacl,
handle_getacl,
marshall_getacl
};
daemon portion of setacl upcall this commit does NOT have correct windows to nfs4 acl mappings but rather has the wrapper functions defined for mapping them. cthon tests still work with these mappings.
2011-04-05 14:42:37 -04:00
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
static int parse_setacl(unsigned char *buffer, uint32_t length,
nfs41_upcall *upcall)
daemon portion of setacl upcall this commit does NOT have correct windows to nfs4 acl mappings but rather has the wrapper functions defined for mapping them. cthon tests still work with these mappings.
2011-04-05 14:42:37 -04:00
{
int status;
setacl_upcall_args *args = &upcall->args.setacl;
ULONG sec_desc_len;
status = safe_read(&buffer, &length, &args->query, sizeof(args->query));
if (status) goto out;
status = safe_read(&buffer, &length, &sec_desc_len, sizeof(ULONG));
if (status) goto out;
[acl] setacl uses memory out of upcall buffer
2011-09-07 15:07:23 -04:00
args->sec_desc = (PSECURITY_DESCRIPTOR)buffer;
daemon portion of setacl upcall this commit does NOT have correct windows to nfs4 acl mappings but rather has the wrapper functions defined for mapping them. cthon tests still work with these mappings.
2011-04-05 14:42:37 -04:00
moving session and open_state in upcall header every upcall (except few) pass session and open_state pointer, so add that to marshal_nfs41_header() in the driver. remove passing of session and open_state elsewhere in marshal functions. in the deamon, upcall.c now reads and stores pointers to session and open_state in nfs41_upcall datastructure instead of having each individual upcall store their own pointers. setattrl and readdir args keeping pointer because the rest of the code uses them a lot. in upcall_parse() up refcounts on session and open_state if valid handles were passed in. down refcounts upcall_cleanup() as before. but need to be careful with count value for mount and open upcalls. we need to take an extra ref because upcall_cleanup() now will always decrement it.
2011-04-13 20:07:37 -04:00
dprintf(1, "parsing NFS41_ACL_SET: info_class=%d sec_desc_len=%d\n",
args->query, sec_desc_len);
daemon portion of setacl upcall this commit does NOT have correct windows to nfs4 acl mappings but rather has the wrapper functions defined for mapping them. cthon tests still work with these mappings.
2011-04-05 14:42:37 -04:00
out:
return status;
}
static int is_well_known_sid(PSID sid, char *who)
{
int status, i;
for (i = 0; i < 78; i++) {
status = IsWellKnownSid(sid, (WELL_KNOWN_SID_TYPE)i);
if (!status) continue;
else {
[cosmetic] dprintf changes in acl, getattr, name_cache, namespace
2011-11-07 10:50:00 -05:00
dprintf(ACLLVL, "WELL_KNOWN_SID_TYPE %d\n", i);
daemon portion of setacl upcall this commit does NOT have correct windows to nfs4 acl mappings but rather has the wrapper functions defined for mapping them. cthon tests still work with these mappings.
2011-04-05 14:42:37 -04:00
switch((WELL_KNOWN_SID_TYPE)i) {
case WinCreatorOwnerSid:
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
memcpy(who, ACE4_OWNER, strlen(ACE4_OWNER)+1);
return TRUE;
daemon portion of setacl upcall this commit does NOT have correct windows to nfs4 acl mappings but rather has the wrapper functions defined for mapping them. cthon tests still work with these mappings.
2011-04-05 14:42:37 -04:00
case WinNullSid:
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
memcpy(who, ACE4_NOBODY, strlen(ACE4_NOBODY)+1);
return TRUE;
daemon portion of setacl upcall this commit does NOT have correct windows to nfs4 acl mappings but rather has the wrapper functions defined for mapping them. cthon tests still work with these mappings.
2011-04-05 14:42:37 -04:00
case WinAnonymousSid:
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
memcpy(who, ACE4_ANONYMOUS, strlen(ACE4_ANONYMOUS)+1);
return TRUE;
daemon portion of setacl upcall this commit does NOT have correct windows to nfs4 acl mappings but rather has the wrapper functions defined for mapping them. cthon tests still work with these mappings.
2011-04-05 14:42:37 -04:00
case WinWorldSid:
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
memcpy(who, ACE4_EVERYONE, strlen(ACE4_EVERYONE)+1);
return TRUE;
daemon portion of setacl upcall this commit does NOT have correct windows to nfs4 acl mappings but rather has the wrapper functions defined for mapping them. cthon tests still work with these mappings.
2011-04-05 14:42:37 -04:00
case WinCreatorGroupSid:
case WinBuiltinUsersSid:
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
memcpy(who, ACE4_GROUP, strlen(ACE4_GROUP)+1);
return TRUE;
daemon portion of setacl upcall this commit does NOT have correct windows to nfs4 acl mappings but rather has the wrapper functions defined for mapping them. cthon tests still work with these mappings.
2011-04-05 14:42:37 -04:00
case WinAuthenticatedUserSid:
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
memcpy(who, ACE4_AUTHENTICATED, strlen(ACE4_AUTHENTICATED)+1);
return TRUE;
daemon portion of setacl upcall this commit does NOT have correct windows to nfs4 acl mappings but rather has the wrapper functions defined for mapping them. cthon tests still work with these mappings.
2011-04-05 14:42:37 -04:00
case WinDialupSid:
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
memcpy(who, ACE4_DIALUP, strlen(ACE4_DIALUP)+1);
return TRUE;
daemon portion of setacl upcall this commit does NOT have correct windows to nfs4 acl mappings but rather has the wrapper functions defined for mapping them. cthon tests still work with these mappings.
2011-04-05 14:42:37 -04:00
case WinNetworkSid:
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
memcpy(who, ACE4_NETWORK, strlen(ACE4_NETWORK)+1);
return TRUE;
daemon portion of setacl upcall this commit does NOT have correct windows to nfs4 acl mappings but rather has the wrapper functions defined for mapping them. cthon tests still work with these mappings.
2011-04-05 14:42:37 -04:00
case WinBatchSid:
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
memcpy(who, ACE4_BATCH, strlen(ACE4_BATCH)+1);
return TRUE;
daemon portion of setacl upcall this commit does NOT have correct windows to nfs4 acl mappings but rather has the wrapper functions defined for mapping them. cthon tests still work with these mappings.
2011-04-05 14:42:37 -04:00
case WinInteractiveSid:
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
memcpy(who, ACE4_INTERACTIVE, strlen(ACE4_INTERACTIVE)+1);
return TRUE;
daemon portion of setacl upcall this commit does NOT have correct windows to nfs4 acl mappings but rather has the wrapper functions defined for mapping them. cthon tests still work with these mappings.
2011-04-05 14:42:37 -04:00
case WinNetworkServiceSid:
case WinLocalServiceSid:
case WinServiceSid:
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
memcpy(who, ACE4_SERVICE, strlen(ACE4_SERVICE)+1);
return TRUE;
daemon portion of setacl upcall this commit does NOT have correct windows to nfs4 acl mappings but rather has the wrapper functions defined for mapping them. cthon tests still work with these mappings.
2011-04-05 14:42:37 -04:00
default: return FALSE;
}
}
}
return FALSE;
}
static void map_aceflags(BYTE win_aceflags, uint32_t *nfs4_aceflags)
{
if (win_aceflags & OBJECT_INHERIT_ACE)
*nfs4_aceflags |= ACE4_FILE_INHERIT_ACE;
if (win_aceflags & CONTAINER_INHERIT_ACE)
[bakeathon] [acl] fixing inheritance flags windows inherite directory flag was translated to file inherite flag cosmetic: print ace type
2011-10-24 12:09:49 -04:00
*nfs4_aceflags |= ACE4_DIRECTORY_INHERIT_ACE;
daemon portion of setacl upcall this commit does NOT have correct windows to nfs4 acl mappings but rather has the wrapper functions defined for mapping them. cthon tests still work with these mappings.
2011-04-05 14:42:37 -04:00
if (win_aceflags & NO_PROPAGATE_INHERIT_ACE)
*nfs4_aceflags |= ACE4_NO_PROPAGATE_INHERIT_ACE;
if (win_aceflags & INHERIT_ONLY_ACE)
*nfs4_aceflags |= ACE4_INHERIT_ONLY_ACE;
if (win_aceflags & INHERITED_ACE)
*nfs4_aceflags |= ACE4_INHERITED_ACE;
[cosmetic] dprintf changes in acl, getattr, name_cache, namespace
2011-11-07 10:50:00 -05:00
dprintf(ACLLVL, "ACE FLAGS: %x nfs4 aceflags %x\n",
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
win_aceflags, *nfs4_aceflags);
daemon portion of setacl upcall this commit does NOT have correct windows to nfs4 acl mappings but rather has the wrapper functions defined for mapping them. cthon tests still work with these mappings.
2011-04-05 14:42:37 -04:00
}
static void map_acemask(ACCESS_MASK mask, int file_type, uint32_t *nfs4_mask)
{
[cosmetic] dprintf changes in acl, getattr, name_cache, namespace
2011-11-07 10:50:00 -05:00
dprintf(ACLLVL, "ACE MASK: %x\n", mask);
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
print_windows_access_mask(0, mask);
/* check if any GENERIC bits set */
if (mask & 0xf000000) {
if (mask & GENERIC_ALL) {
if (file_type == NF4DIR)
*nfs4_mask |= ACE4_ALL_DIR;
else
*nfs4_mask |= ACE4_ALL_FILE;
} else {
if (mask & GENERIC_READ)
*nfs4_mask |= ACE4_GENERIC_READ;
if (mask & GENERIC_WRITE)
*nfs4_mask |= ACE4_GENERIC_WRITE;
if (mask & GENERIC_EXECUTE)
*nfs4_mask |= ACE4_GENERIC_EXECUTE;
}
}
else /* ignoring generic and reserved bits */
*nfs4_mask = mask & 0x00ffffff;
print_nfs_access_mask(0, *nfs4_mask);
daemon portion of setacl upcall this commit does NOT have correct windows to nfs4 acl mappings but rather has the wrapper functions defined for mapping them. cthon tests still work with these mappings.
2011-04-05 14:42:37 -04:00
}
[acl] converting group sid to GROUP@ when we process aces from windows, if we see an ace with sids of the primary group, replace that with GROUP@ special who identifier.
2011-06-27 16:01:34 -04:00
static int map_nfs4ace_who(PSID sid, PSID owner_sid, PSID group_sid, char *who_out, char *domain)
daemon portion of setacl upcall this commit does NOT have correct windows to nfs4 acl mappings but rather has the wrapper functions defined for mapping them. cthon tests still work with these mappings.
2011-04-05 14:42:37 -04:00
{
int status = ERROR_INTERNAL_ERROR;
DWORD size = 0, tmp_size = 0;
SID_NAME_USE sid_type;
LPSTR tmp_buf = NULL, who = NULL;
[acls] setattr of owner and group attributes
2011-04-12 19:59:58 -04:00
/* for ace mapping, we want to map owner's sid into "owner@"
* but for set_owner attribute we want to map owner into a user name
* same applies to group
*/
[acl] converting group sid to GROUP@ when we process aces from windows, if we see an ace with sids of the primary group, replace that with GROUP@ special who identifier.
2011-06-27 16:01:34 -04:00
status = 0;
[acls] setattr of owner and group attributes
2011-04-12 19:59:58 -04:00
if (owner_sid) {
if (EqualSid(sid, owner_sid)) {
[cosmetic] dprintf changes in acl, getattr, name_cache, namespace
2011-11-07 10:50:00 -05:00
dprintf(ACLLVL, "map_nfs4ace_who: this is owner's sid\n");
[acls] setattr of owner and group attributes
2011-04-12 19:59:58 -04:00
memcpy(who_out, ACE4_OWNER, strlen(ACE4_OWNER)+1);
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
return ERROR_SUCCESS;
[acls] setattr of owner and group attributes
2011-04-12 19:59:58 -04:00
}
[acl] converting group sid to GROUP@ when we process aces from windows, if we see an ace with sids of the primary group, replace that with GROUP@ special who identifier.
2011-06-27 16:01:34 -04:00
}
if (group_sid) {
if (EqualSid(sid, group_sid)) {
[cosmetic] dprintf changes in acl, getattr, name_cache, namespace
2011-11-07 10:50:00 -05:00
dprintf(ACLLVL, "map_nfs4ace_who: this is group's sid\n");
[acl] converting group sid to GROUP@ when we process aces from windows, if we see an ace with sids of the primary group, replace that with GROUP@ special who identifier.
2011-06-27 16:01:34 -04:00
memcpy(who_out, ACE4_GROUP, strlen(ACE4_GROUP)+1);
return ERROR_SUCCESS;
[acls] setattr of owner and group attributes
2011-04-12 19:59:58 -04:00
}
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
}
[acl] converting group sid to GROUP@ when we process aces from windows, if we see an ace with sids of the primary group, replace that with GROUP@ special who identifier.
2011-06-27 16:01:34 -04:00
status = is_well_known_sid(sid, who_out);
if (status) {
if (!strncmp(who_out, ACE4_NOBODY, strlen(ACE4_NOBODY))) {
daemon: cleaned up compiler warnings raised warning level to /Wall changed nfs41_file_info.owner, owner_group to char[] to avoid casting Signed-off-by: Casey Bodley <cbodley@citi.umich.edu>
2011-07-06 10:53:39 -04:00
size = (DWORD)strlen(ACE4_NOBODY);
[acl] converting group sid to GROUP@ when we process aces from windows, if we see an ace with sids of the primary group, replace that with GROUP@ special who identifier.
2011-06-27 16:01:34 -04:00
goto add_domain;
}
else
return ERROR_SUCCESS;
}
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
daemon portion of setacl upcall this commit does NOT have correct windows to nfs4 acl mappings but rather has the wrapper functions defined for mapping them. cthon tests still work with these mappings.
2011-04-05 14:42:37 -04:00
status = LookupAccountSid(NULL, sid, who, &size, tmp_buf,
&tmp_size, &sid_type);
[cosmetic] dprintf changes in acl, getattr, name_cache, namespace
2011-11-07 10:50:00 -05:00
dprintf(ACLLVL, "map_nfs4ace_who: LookupAccountSid returned %d GetLastError "
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
"%d name len %d domain len %d\n", status, GetLastError(),
size, tmp_size);
if (status)
return ERROR_INTERNAL_ERROR;
status = GetLastError();
if (status != ERROR_INSUFFICIENT_BUFFER)
return ERROR_INTERNAL_ERROR;
who = malloc(size);
if (who == NULL) {
daemon portion of setacl upcall this commit does NOT have correct windows to nfs4 acl mappings but rather has the wrapper functions defined for mapping them. cthon tests still work with these mappings.
2011-04-05 14:42:37 -04:00
status = GetLastError();
goto out;
}
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
tmp_buf = malloc(tmp_size);
if (tmp_buf == NULL)
goto out_free_who;
status = LookupAccountSid(NULL, sid, who, &size, tmp_buf,
&tmp_size, &sid_type);
free(tmp_buf);
if (!status) {
eprintf("map_nfs4ace_who: LookupAccountSid failed with %d\n",
GetLastError());
goto out_free_who;
}
memcpy(who_out, who, size);
add_domain:
memcpy(who_out+size, "@", sizeof(char));
memcpy(who_out+size+1, domain, strlen(domain)+1);
[cosmetic] dprintf changes in acl, getattr, name_cache, namespace
2011-11-07 10:50:00 -05:00
dprintf(ACLLVL, "map_nfs4ace_who: who=%s\n", who_out);
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
if (who) free(who);
status = ERROR_SUCCESS;
daemon portion of setacl upcall this commit does NOT have correct windows to nfs4 acl mappings but rather has the wrapper functions defined for mapping them. cthon tests still work with these mappings.
2011-04-05 14:42:37 -04:00
out:
return status;
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
out_free_who:
free(who);
status = GetLastError();
goto out;
daemon portion of setacl upcall this commit does NOT have correct windows to nfs4 acl mappings but rather has the wrapper functions defined for mapping them. cthon tests still work with these mappings.
2011-04-05 14:42:37 -04:00
}
[acl] converting group sid to GROUP@ when we process aces from windows, if we see an ace with sids of the primary group, replace that with GROUP@ special who identifier.
2011-06-27 16:01:34 -04:00
static int map_dacl_2_nfs4acl(PACL acl, PSID sid, PSID gsid, nfsacl41 *nfs4_acl,
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
int file_type, char *domain)
daemon portion of setacl upcall this commit does NOT have correct windows to nfs4 acl mappings but rather has the wrapper functions defined for mapping them. cthon tests still work with these mappings.
2011-04-05 14:42:37 -04:00
{
int status;
if (acl == NULL) {
[cosmetic] dprintf changes in acl, getattr, name_cache, namespace
2011-11-07 10:50:00 -05:00
dprintf(ACLLVL, "this is a NULL dacl: all access to an object\n");
daemon portion of setacl upcall this commit does NOT have correct windows to nfs4 acl mappings but rather has the wrapper functions defined for mapping them. cthon tests still work with these mappings.
2011-04-05 14:42:37 -04:00
nfs4_acl->count = 1;
nfs4_acl->aces = calloc(1, sizeof(nfsace4));
if (nfs4_acl->aces == NULL) {
status = GetLastError();
goto out;
}
nfs4_acl->flag = 0;
memcpy(nfs4_acl->aces->who, ACE4_EVERYONE, strlen(ACE4_EVERYONE)+1);
nfs4_acl->aces->acetype = ACE4_ACCESS_ALLOWED_ACE_TYPE;
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
if (file_type == NF4DIR)
nfs4_acl->aces->acemask = ACE4_ALL_DIR;
else
nfs4_acl->aces->acemask = ACE4_ALL_FILE;
daemon portion of setacl upcall this commit does NOT have correct windows to nfs4 acl mappings but rather has the wrapper functions defined for mapping them. cthon tests still work with these mappings.
2011-04-05 14:42:37 -04:00
nfs4_acl->aces->aceflag = 0;
} else {
int i;
PACE_HEADER ace;
PBYTE tmp_pointer;
[cosmetic] dprintf changes in acl, getattr, name_cache, namespace
2011-11-07 10:50:00 -05:00
dprintf(ACLLVL, "NON-NULL dacl with %d ACEs\n", acl->AceCount);
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
print_hexbuf_no_asci(3, (unsigned char *)"ACL\n",
(unsigned char *)acl, acl->AclSize);
daemon portion of setacl upcall this commit does NOT have correct windows to nfs4 acl mappings but rather has the wrapper functions defined for mapping them. cthon tests still work with these mappings.
2011-04-05 14:42:37 -04:00
nfs4_acl->count = acl->AceCount;
nfs4_acl->aces = calloc(nfs4_acl->count, sizeof(nfsace4));
if (nfs4_acl->aces == NULL) {
status = GetLastError();
goto out;
}
nfs4_acl->flag = 0;
for (i = 0; i < acl->AceCount; i++) {
status = GetAce(acl, i, &ace);
if (!status) {
status = GetLastError();
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
eprintf("map_dacl_2_nfs4acl: GetAce failed with %d\n", status);
goto out_free;
daemon portion of setacl upcall this commit does NOT have correct windows to nfs4 acl mappings but rather has the wrapper functions defined for mapping them. cthon tests still work with these mappings.
2011-04-05 14:42:37 -04:00
}
tmp_pointer = (PBYTE)ace;
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
print_hexbuf_no_asci(3, (unsigned char *)"ACE\n",
(unsigned char *)ace, ace->AceSize);
[cosmetic] dprintf changes in acl, getattr, name_cache, namespace
2011-11-07 10:50:00 -05:00
dprintf(ACLLVL, "ACE TYPE: %x\n", ace->AceType);
daemon portion of setacl upcall this commit does NOT have correct windows to nfs4 acl mappings but rather has the wrapper functions defined for mapping them. cthon tests still work with these mappings.
2011-04-05 14:42:37 -04:00
if (ace->AceType == ACCESS_ALLOWED_ACE_TYPE)
nfs4_acl->aces[i].acetype = ACE4_ACCESS_ALLOWED_ACE_TYPE;
else if (ace->AceType == ACCESS_DENIED_ACE_TYPE)
nfs4_acl->aces[i].acetype = ACE4_ACCESS_DENIED_ACE_TYPE;
else {
eprintf("map_dacl_2_nfs4acl: unsupported ACE type %d\n",
ace->AceType);
status = ERROR_NOT_SUPPORTED;
goto out_free;
}
map_aceflags(ace->AceFlags, &nfs4_acl->aces[i].aceflag);
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
map_acemask(*(PACCESS_MASK)(ace + 1), file_type,
&nfs4_acl->aces[i].acemask);
daemon portion of setacl upcall this commit does NOT have correct windows to nfs4 acl mappings but rather has the wrapper functions defined for mapping them. cthon tests still work with these mappings.
2011-04-05 14:42:37 -04:00
tmp_pointer += sizeof(ACCESS_MASK) + sizeof(ACE_HEADER);
[acl] converting group sid to GROUP@ when we process aces from windows, if we see an ace with sids of the primary group, replace that with GROUP@ special who identifier.
2011-06-27 16:01:34 -04:00
status = map_nfs4ace_who(tmp_pointer, sid, gsid, nfs4_acl->aces[i].who,
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
domain);
daemon portion of setacl upcall this commit does NOT have correct windows to nfs4 acl mappings but rather has the wrapper functions defined for mapping them. cthon tests still work with these mappings.
2011-04-05 14:42:37 -04:00
if (status)
goto out_free;
}
}
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
status = ERROR_SUCCESS;
daemon portion of setacl upcall this commit does NOT have correct windows to nfs4 acl mappings but rather has the wrapper functions defined for mapping them. cthon tests still work with these mappings.
2011-04-05 14:42:37 -04:00
out:
return status;
out_free:
free(nfs4_acl->aces);
goto out;
}
static int handle_setacl(nfs41_upcall *upcall)
{
int status = ERROR_NOT_SUPPORTED;
setacl_upcall_args *args = &upcall->args.setacl;
moving session and open_state in upcall header every upcall (except few) pass session and open_state pointer, so add that to marshal_nfs41_header() in the driver. remove passing of session and open_state elsewhere in marshal functions. in the deamon, upcall.c now reads and stores pointers to session and open_state in nfs41_upcall datastructure instead of having each individual upcall store their own pointers. setattrl and readdir args keeping pointer because the rest of the code uses them a lot. in upcall_parse() up refcounts on session and open_state if valid handles were passed in. down refcounts upcall_cleanup() as before. but need to be careful with count value for mount and open upcalls. we need to take an extra ref because upcall_cleanup() now will always decrement it.
2011-04-13 20:07:37 -04:00
nfs41_open_state *state = upcall->state_ref;
removing unnecessary ZeroMemory calls instead of calling ZeroMemory(foobar) to initialize the data structure, during declaration do struct some_struct foobar = { 0 }
2011-08-24 17:43:20 -04:00
nfs41_file_info info = { 0 };
daemon portion of setacl upcall this commit does NOT have correct windows to nfs4 acl mappings but rather has the wrapper functions defined for mapping them. cthon tests still work with these mappings.
2011-04-05 14:42:37 -04:00
stateid_arg stateid;
daemon: cleaned up compiler warnings raised warning level to /Wall changed nfs41_file_info.owner, owner_group to char[] to avoid casting Signed-off-by: Casey Bodley <cbodley@citi.umich.edu>
2011-07-06 10:53:39 -04:00
nfsacl41 nfs4_acl = { 0 };
[acl] converting group sid to GROUP@ when we process aces from windows, if we see an ace with sids of the primary group, replace that with GROUP@ special who identifier.
2011-06-27 16:01:34 -04:00
PSID sid = NULL, gsid = NULL;
BOOL sid_default, gsid_default;
daemon portion of setacl upcall this commit does NOT have correct windows to nfs4 acl mappings but rather has the wrapper functions defined for mapping them. cthon tests still work with these mappings.
2011-04-05 14:42:37 -04:00
[acls] setattr of owner and group attributes
2011-04-12 19:59:58 -04:00
if (args->query & OWNER_SECURITY_INFORMATION) {
fixing null pointer deref in setowner/group
2011-08-26 16:27:19 -04:00
char owner[NFS4_OPAQUE_LIMIT];
[cosmetic] dprintf changes in acl, getattr, name_cache, namespace
2011-11-07 10:50:00 -05:00
dprintf(ACLLVL, "handle_setacl: OWNER_SECURITY_INFORMATION\n");
[acls] setattr of owner and group attributes
2011-04-12 19:59:58 -04:00
status = GetSecurityDescriptorOwner(args->sec_desc, &sid, &sid_default);
if (!status) {
status = GetLastError();
eprintf("GetSecurityDescriptorOwner failed with %d\n", status);
goto out;
}
fixing null pointer deref in setowner/group
2011-08-26 16:27:19 -04:00
info.owner = owner;
daemon: cleaned up compiler warnings raised warning level to /Wall changed nfs41_file_info.owner, owner_group to char[] to avoid casting Signed-off-by: Casey Bodley <cbodley@citi.umich.edu>
2011-07-06 10:53:39 -04:00
status = map_nfs4ace_who(sid, NULL, NULL, info.owner,
[acls] setattr of owner and group attributes
2011-04-12 19:59:58 -04:00
state->session->client->domain_name);
if (status)
goto out;
else {
info.attrmask.arr[1] |= FATTR4_WORD1_OWNER;
info.attrmask.count = 2;
}
}
if (args->query & GROUP_SECURITY_INFORMATION) {
fixing null pointer deref in setowner/group
2011-08-26 16:27:19 -04:00
char group[NFS4_OPAQUE_LIMIT];
[cosmetic] dprintf changes in acl, getattr, name_cache, namespace
2011-11-07 10:50:00 -05:00
dprintf(ACLLVL, "handle_setacl: GROUP_SECURITY_INFORMATION\n");
[acls] setattr of owner and group attributes
2011-04-12 19:59:58 -04:00
status = GetSecurityDescriptorGroup(args->sec_desc, &sid, &sid_default);
if (!status) {
status = GetLastError();
eprintf("GetSecurityDescriptorOwner failed with %d\n", status);
goto out;
}
fixing null pointer deref in setowner/group
2011-08-26 16:27:19 -04:00
info.owner_group = group;
daemon: cleaned up compiler warnings raised warning level to /Wall changed nfs41_file_info.owner, owner_group to char[] to avoid casting Signed-off-by: Casey Bodley <cbodley@citi.umich.edu>
2011-07-06 10:53:39 -04:00
status = map_nfs4ace_who(sid, NULL, NULL, info.owner_group,
[acls] setattr of owner and group attributes
2011-04-12 19:59:58 -04:00
state->session->client->domain_name);
if (status)
goto out;
else {
info.attrmask.arr[1] |= FATTR4_WORD1_OWNER_GROUP;
info.attrmask.count = 2;
}
}
daemon portion of setacl upcall this commit does NOT have correct windows to nfs4 acl mappings but rather has the wrapper functions defined for mapping them. cthon tests still work with these mappings.
2011-04-05 14:42:37 -04:00
if (args->query & DACL_SECURITY_INFORMATION) {
[acls] setattr of owner and group attributes
2011-04-12 19:59:58 -04:00
BOOL dacl_present, dacl_default;
daemon portion of setacl upcall this commit does NOT have correct windows to nfs4 acl mappings but rather has the wrapper functions defined for mapping them. cthon tests still work with these mappings.
2011-04-05 14:42:37 -04:00
PACL acl;
[cosmetic] dprintf changes in acl, getattr, name_cache, namespace
2011-11-07 10:50:00 -05:00
dprintf(ACLLVL, "handle_setacl: DACL_SECURITY_INFORMATION\n");
daemon portion of setacl upcall this commit does NOT have correct windows to nfs4 acl mappings but rather has the wrapper functions defined for mapping them. cthon tests still work with these mappings.
2011-04-05 14:42:37 -04:00
status = GetSecurityDescriptorDacl(args->sec_desc, &dacl_present,
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
&acl, &dacl_default);
daemon portion of setacl upcall this commit does NOT have correct windows to nfs4 acl mappings but rather has the wrapper functions defined for mapping them. cthon tests still work with these mappings.
2011-04-05 14:42:37 -04:00
if (!status) {
status = GetLastError();
eprintf("GetSecurityDescriptorDacl failed with %d\n", status);
goto out;
}
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
status = GetSecurityDescriptorOwner(args->sec_desc, &sid, &sid_default);
if (!status) {
status = GetLastError();
eprintf("GetSecurityDescriptorOwner failed with %d\n", status);
goto out;
}
[acl] converting group sid to GROUP@ when we process aces from windows, if we see an ace with sids of the primary group, replace that with GROUP@ special who identifier.
2011-06-27 16:01:34 -04:00
status = GetSecurityDescriptorGroup(args->sec_desc, &gsid, &gsid_default);
if (!status) {
status = GetLastError();
eprintf("GetSecurityDescriptorOwner failed with %d\n", status);
goto out;
}
status = map_dacl_2_nfs4acl(acl, sid, gsid, &nfs4_acl, state->type,
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
state->session->client->domain_name);
daemon portion of setacl upcall this commit does NOT have correct windows to nfs4 acl mappings but rather has the wrapper functions defined for mapping them. cthon tests still work with these mappings.
2011-04-05 14:42:37 -04:00
if (status)
goto out;
else {
info.acl = &nfs4_acl;
info.attrmask.arr[0] |= FATTR4_WORD0_ACL;
[acls] setattr of owner and group attributes
2011-04-12 19:59:58 -04:00
if (!info.attrmask.count)
info.attrmask.count = 1;
daemon portion of setacl upcall this commit does NOT have correct windows to nfs4 acl mappings but rather has the wrapper functions defined for mapping them. cthon tests still work with these mappings.
2011-04-05 14:42:37 -04:00
}
}
deleg: return delegation before conflicting operations new function nfs41_delegation_return() for synchronous delegation return. uses a condition variable to wait if another thread is already returning the delegation if nfs41_delegate_open() would conflict with a delegation, return it before sending the OPEN return the delegation before sending LINK, RENAME, REMOVE, and SETATTR all of this functionality is dependent on the preprocessor define DELEGATION_RETURN_ON_CONFLICT (on by default). if not defined, nfs41_delegation_return() is a noop Signed-off-by: Casey Bodley <cbodley@citi.umich.edu>
2011-07-07 13:51:21 -04:00
/* break read delegations before SETATTR */
nfs41_delegation_return(state->session, &state->file,
OPEN_DELEGATE_READ, FALSE);
deleg: make use of delegation stateids combined nfs41_lock_stateid_arg() into nfs41_open_stateid_arg(). if a delegation is present, use the delegation stateid before looking at lock/open stateids. if a delegation recall is in progress, wait on its condition variable before falling back to the open stateid made nfs41_lock_stateid_arg() static to lock.c because of its special semantics; open_to_lock_owner4 for LOCK won't accept a delegation stateid, so nfs41_delegation_to_open() is called to convert it Signed-off-by: Casey Bodley <cbodley@citi.umich.edu>
2011-07-07 13:48:48 -04:00
nfs41_open_stateid_arg(state, &stateid);
daemon portion of setacl upcall this commit does NOT have correct windows to nfs4 acl mappings but rather has the wrapper functions defined for mapping them. cthon tests still work with these mappings.
2011-04-05 14:42:37 -04:00
status = nfs41_setattr(state->session, &state->file, &stateid, &info);
if (status) {
[cosmetic] dprintf changes in acl, getattr, name_cache, namespace
2011-11-07 10:50:00 -05:00
dprintf(ACLLVL, "handle_setacl: nfs41_setattr() failed with error %s.\n",
more acl reformated some of the old functions. finalized mapping functions for windows to nfs4 access mask bits. satisfying nfs41_acl_query for dacl. when doing setacl and creating "who" field of the format user@nfs4domain, use dns domain name of the windows client machine
2011-04-12 16:47:14 -04:00
nfs_error_string(status));
daemon portion of setacl upcall this commit does NOT have correct windows to nfs4 acl mappings but rather has the wrapper functions defined for mapping them. cthon tests still work with these mappings.
2011-04-05 14:42:37 -04:00
status = nfs_to_windows_error(status, ERROR_NOT_SUPPORTED);
}
if (args->query & DACL_SECURITY_INFORMATION)
free(nfs4_acl.aces);
out:
return status;
}
const nfs41_upcall_op nfs41_op_setacl = {
parse_setacl,
handle_setacl,
};
Reference in a new issue Copy permalink