enum rpc_service_mode_e rpc_service_mode(const char *name)
{
const char *rpcsrv_type;
enum rpc_service_mode_e state;
const char *def;
int i;
def = "embedded";
for (i = 0; rpc_service_defaults[i].name; i++) {
if (strcasecmp_m(name, rpc_service_defaults[i].name) == 0) {
def = rpc_service_defaults[i].def_mode;
}
}
rpcsrv_type = lp_parm_const_string(GLOBAL_SECTION_SNUM,
"rpc_server", name, def);
if (strcasecmp_m(rpcsrv_type, "embedded") == 0) {
state = RPC_SERVICE_MODE_EMBEDDED;
} else if (strcasecmp_m(rpcsrv_type, "external") == 0) {
state = RPC_SERVICE_MODE_EXTERNAL;
} else {
state = RPC_SERVICE_MODE_DISABLED;
}
return state;
}
enum rpc_daemon_type_e rpc_daemon_type(const char *name)
{
const char *rpcsrv_type;
enum rpc_daemon_type_e type;
const char *def;
int i;
def = "embedded";
for (i = 0; rpc_daemon_defaults[i].name; i++) {
if (strcasecmp_m(name, rpc_daemon_defaults[i].name) == 0) {
def = rpc_daemon_defaults[i].def_type;
}
}
rpcsrv_type = lp_parm_const_string(GLOBAL_SECTION_SNUM,
"rpc_daemon", name, def);
if (strcasecmp_m(rpcsrv_type, "embedded") == 0) {
type = RPC_DAEMON_EMBEDDED;
} else if (strcasecmp_m(rpcsrv_type, "fork") == 0) {
type = RPC_DAEMON_FORK;
} else {
type = RPC_DAEMON_DISABLED;
}
return type;
}
static NTSTATUS lookup_well_known_names(TALLOC_CTX *mem_ctx, const char *domain,
const char *name, const char **authority_name,
struct dom_sid **sid, uint32_t *rtype)
{
int i;
for (i=0; well_known[i].sid; i++) {
if (domain) {
if (strcasecmp_m(domain, well_known[i].domain) == 0
&& strcasecmp_m(name, well_known[i].name) == 0) {
*authority_name = well_known[i].domain;
*sid = dom_sid_parse_talloc(mem_ctx, well_known[i].sid);
*rtype = well_known[i].rtype;
return NT_STATUS_OK;
}
} else {
if (strcasecmp_m(name, well_known[i].name) == 0) {
*authority_name = well_known[i].domain;
*sid = dom_sid_parse_talloc(mem_ctx, well_known[i].sid);
*rtype = well_known[i].rtype;
return NT_STATUS_OK;
}
}
}
return NT_STATUS_NOT_FOUND;
}
/*
seek to the given name
*/
NTSTATUS pvfs_list_seek(struct pvfs_dir *dir, const char *name, off_t *ofs)
{
struct dirent *de;
int i;
dir->end_of_search = False;
if (ISDOT(name)) {
dir->offset = DIR_OFFSET_DOTDOT;
*ofs = dir->offset;
return NT_STATUS_OK;
}
if (ISDOTDOT(name)) {
dir->offset = DIR_OFFSET_BASE;
*ofs = dir->offset;
return NT_STATUS_OK;
}
for (i=dir->name_cache_index;i>=0;i--) {
struct name_cache_entry *e = &dir->name_cache[i];
if (e->name && strcasecmp_m(name, e->name) == 0) {
*ofs = e->offset;
return NT_STATUS_OK;
}
}
for (i=NAME_CACHE_SIZE-1;i>dir->name_cache_index;i--) {
struct name_cache_entry *e = &dir->name_cache[i];
if (e->name && strcasecmp_m(name, e->name) == 0) {
*ofs = e->offset;
return NT_STATUS_OK;
}
}
rewinddir(dir->dir);
while ((de = readdir(dir->dir))) {
if (strcasecmp_m(name, de->d_name) == 0) {
dir->offset = telldir(dir->dir) + DIR_OFFSET_BASE;
*ofs = dir->offset;
return NT_STATUS_OK;
}
}
dir->end_of_search = True;
return NT_STATUS_OBJECT_NAME_NOT_FOUND;
}
/* lookup hosts or IP addresses using internal samba lookup fns */
int net_lookup(struct net_context *c, int argc, const char **argv)
{
int i;
struct functable table[] = {
{"HOST", net_lookup_host},
{"LDAP", net_lookup_ldap},
{"DC", net_lookup_dc},
{"PDC", net_lookup_pdc},
{"MASTER", net_lookup_master},
{"KDC", net_lookup_kdc},
{"NAME", net_lookup_name},
{"SID", net_lookup_sid},
{"DSGETDCNAME", net_lookup_dsgetdcname},
{NULL, NULL}
};
if (argc < 1) {
d_printf(_("\nUsage: \n"));
return net_lookup_usage(c, argc, argv);
}
for (i=0; table[i].funcname; i++) {
if (strcasecmp_m(argv[0], table[i].funcname) == 0)
return table[i].fn(c, argc-1, argv+1);
}
/* Default to lookup a hostname so 'net lookup foo#1b' can be
used instead of 'net lookup host foo#1b'. The host syntax
is a bit confusing as non #00 names can't really be
considered hosts as such. */
return net_lookup_host(c, argc, argv);
}
/*
reply to a RAW_FILEINFO_EA_LIST call
*/
NTSTATUS pvfs_query_ea_list(struct pvfs_state *pvfs, TALLOC_CTX *mem_ctx,
struct pvfs_filename *name, int fd,
unsigned int num_names,
struct ea_name *names,
struct smb_ea_list *eas)
{
NTSTATUS status;
int i;
struct xattr_DosEAs *ealist = talloc(mem_ctx, struct xattr_DosEAs);
ZERO_STRUCTP(eas);
status = pvfs_doseas_load(pvfs, name, fd, ealist);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
eas->eas = talloc_array(mem_ctx, struct ea_struct, num_names);
if (eas->eas == NULL) {
return NT_STATUS_NO_MEMORY;
}
eas->num_eas = num_names;
for (i=0;i<num_names;i++) {
int j;
eas->eas[i].flags = 0;
eas->eas[i].name.s = names[i].name.s;
eas->eas[i].value = data_blob(NULL, 0);
for (j=0;j<ealist->num_eas;j++) {
if (strcasecmp_m(eas->eas[i].name.s,
ealist->eas[j].name) == 0) {
eas->eas[i].value = ealist->eas[j].value;
break;
}
}
}
return NT_STATUS_OK;
}
static NTSTATUS check_privilege_for_user(struct rpc_pipe_client *pipe_hnd,
TALLOC_CTX *ctx,
struct policy_handle *pol,
struct dom_sid *sid,
const char *right)
{
NTSTATUS status, result;
struct lsa_RightSet rights;
int i;
struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
status = dcerpc_lsa_EnumAccountRights(b, ctx,
pol,
sid,
&rights,
&result);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
if (!NT_STATUS_IS_OK(result)) {
return result;
}
if (rights.count == 0) {
return NT_STATUS_OBJECT_NAME_NOT_FOUND;
}
for (i = 0; i < rights.count; i++) {
if (strcasecmp_m(rights.names[i].string, right) == 0) {
return NT_STATUS_OK;
}
}
return NT_STATUS_OBJECT_NAME_NOT_FOUND;
}
static bool find_returned_ea(union smb_fileinfo *finfo2,
const char *eaname,
const char *eavalue)
{
unsigned int i;
unsigned int num_eas = finfo2->all_eas.out.num_eas;
struct ea_struct *eas = finfo2->all_eas.out.eas;
for (i = 0; i < num_eas; i++) {
if (eas[i].name.s == NULL) {
continue;
}
/* Windows capitalizes returned EA names. */
if (strcasecmp_m(eas[i].name.s, eaname)) {
continue;
}
if (eavalue == NULL && eas[i].value.length == 0) {
/* Null value, found it ! */
return true;
}
if (eas[i].value.length == strlen(eavalue) &&
memcmp(eas[i].value.data,
eavalue,
strlen(eavalue)) == 0) {
return true;
}
}
return false;
}
/**
* This imitates net_run_function but calls the main functions
* through the wrapper net_conf_wrap_function().
*/
static int net_conf_run_function(struct net_context *c, int argc,
const char **argv, const char *whoami,
struct conf_functable *table)
{
int i;
if (argc != 0) {
for (i=0; table[i].funcname; i++) {
if (strcasecmp_m(argv[0], table[i].funcname) == 0)
return net_conf_wrap_function(c, table[i].fn,
argc-1,
argv+1);
}
}
d_printf(_("Usage:\n"));
for (i=0; table[i].funcname; i++) {
if (c->display_usage == false)
d_printf("%s %-15s %s\n", whoami, table[i].funcname,
table[i].description);
else
d_printf("%s\n", table[i].usage);
}
return c->display_usage?0:-1;
}
/****************************************************************************
Returns true if the filename's stream == "::$DATA"
***************************************************************************/
bool is_ntfs_default_stream_smb_fname(const struct smb_filename *smb_fname)
{
if (!is_ntfs_stream_smb_fname(smb_fname)) {
return false;
}
return strcasecmp_m(smb_fname->stream_name, "::$DATA") == 0;
}
static void set_visible(struct clilist_file_info *i, const char *mask,
void *priv)
{
struct list_state *state = (struct list_state *)priv;
if (strcasecmp_m(state->fname, i->name) == 0)
state->visible = true;
}
NTSTATUS libnet_SamDump(struct libnet_context *ctx, TALLOC_CTX *mem_ctx,
struct libnet_SamDump *r)
{
NTSTATUS nt_status;
struct libnet_SamSync r2;
struct samdump_state *samdump_state = talloc(mem_ctx, struct samdump_state);
struct samdump_trusted_domain *t;
struct samdump_secret *s;
if (!samdump_state) {
return NT_STATUS_NO_MEMORY;
}
samdump_state->secrets = NULL;
samdump_state->trusted_domains = NULL;
r2.out.error_string = NULL;
r2.in.binding_string = r->in.binding_string;
r2.in.init_fn = NULL;
r2.in.delta_fn = libnet_samdump_fn;
r2.in.fn_ctx = samdump_state;
r2.in.machine_account = r->in.machine_account;
nt_status = libnet_SamSync_netlogon(ctx, samdump_state, &r2);
r->out.error_string = r2.out.error_string;
talloc_steal(mem_ctx, r->out.error_string);
if (!NT_STATUS_IS_OK(nt_status)) {
talloc_free(samdump_state);
return nt_status;
}
printf("Trusted domains, sids and secrets:\n");
for (t=samdump_state->trusted_domains; t; t=t->next) {
char *secret_name = talloc_asprintf(mem_ctx, "G$$%s", t->name);
for (s=samdump_state->secrets; s; s=s->next) {
size_t converted_size = 0;
char *secret_string;
if (strcasecmp_m(s->name, secret_name) != 0) {
continue;
}
if (!convert_string_talloc_handle(mem_ctx, lpcfg_iconv_handle(ctx->lp_ctx), CH_UTF16, CH_UNIX,
s->secret.data, s->secret.length,
(void **)&secret_string, &converted_size)) {
r->out.error_string = talloc_asprintf(mem_ctx,
"Could not convert secret for domain %s to a string",
t->name);
talloc_free(samdump_state);
return NT_STATUS_INVALID_PARAMETER;
}
printf("%s\t%s\t%s\n",
t->name, dom_sid_string(mem_ctx, t->sid),
secret_string);
}
}
talloc_free(samdump_state);
return nt_status;
}
/**
see if a string matches either our primary or one of our secondary
netbios aliases. do a case insensitive match
*/
bool lpcfg_is_myname(struct loadparm_context *lp_ctx, const char *name)
{
const char **aliases;
int i;
if (strcasecmp_m(name, lpcfg_netbios_name(lp_ctx)) == 0) {
return true;
}
aliases = lpcfg_netbios_aliases(lp_ctx);
for (i=0; aliases && aliases[i]; i++) {
if (strcasecmp_m(name, aliases[i]) == 0) {
return true;
}
}
return false;
}
/**
* Compare 2 strings.
*
* @note The comparison is case-insensitive.
**/
_PUBLIC_ bool strequal(const char *s1, const char *s2)
{
if (s1 == s2)
return true;
if (!s1 || !s2)
return false;
return strcasecmp_m(s1,s2) == 0;
}
static PyObject *py_strcasecmp_m(PyObject *self, PyObject *args)
{
char *s1, *s2;
if (!PyArg_ParseTuple(args, "ss", &s1, &s2))
return NULL;
return PyInt_FromLong(strcasecmp_m(s1, s2));
}
enum rpc_service_mode_e rpc_service_mode(const char *name)
{
const char *pipe_name = name;
const char *rpcsrv_type;
enum rpc_service_mode_e state;
const char *def;
int i;
/* Handle pipes with multiple names */
if (strcmp(pipe_name, "lsass") == 0) {
pipe_name = "lsarpc";
} else if (strcmp(pipe_name, "plugplay") == 0) {
pipe_name = "ntsvcs";
}
def = lp_parm_const_string(GLOBAL_SECTION_SNUM,
"rpc_server", "default", NULL);
if (def == NULL) {
for (i = 0; rpc_service_defaults[i].name; i++) {
if (strcasecmp_m(pipe_name, rpc_service_defaults[i].name) == 0) {
def = rpc_service_defaults[i].def_mode;
break;
}
}
/* if the default is unspecified then use 'embedded' */
if (def == NULL) {
def = "embedded";
}
}
rpcsrv_type = lp_parm_const_string(GLOBAL_SECTION_SNUM,
"rpc_server", pipe_name, def);
if (strcasecmp_m(rpcsrv_type, "embedded") == 0) {
state = RPC_SERVICE_MODE_EMBEDDED;
} else if (strcasecmp_m(rpcsrv_type, "external") == 0) {
state = RPC_SERVICE_MODE_EXTERNAL;
} else {
state = RPC_SERVICE_MODE_DISABLED;
}
return state;
}
NTSTATUS onefs_stream_prep_smb_fname(TALLOC_CTX *ctx,
const struct smb_filename *smb_fname_in,
struct smb_filename **smb_fname_out)
{
char *stream_name = NULL;
NTSTATUS status;
/*
* Only attempt to strip off the trailing :$DATA if there is an actual
* stream there. If it is the default stream, the smb_fname_out will
* just have a NULL stream so the base file is opened.
*/
if (smb_fname_in->stream_name &&
!is_ntfs_default_stream_smb_fname(smb_fname_in)) {
char *str_tmp = smb_fname_in->stream_name;
/* First strip off the leading ':' */
if (str_tmp[0] == ':') {
str_tmp++;
}
/* Create a new copy of the stream_name. */
stream_name = talloc_strdup(ctx, str_tmp);
if (stream_name == NULL) {
return NT_STATUS_NO_MEMORY;
}
/* Strip off the :$DATA if one exists. */
str_tmp = strrchr_m(stream_name, ':');
if (str_tmp) {
if (strcasecmp_m(str_tmp, ":$DATA") != 0) {
return NT_STATUS_INVALID_PARAMETER;
}
str_tmp[0] = '\0';
}
}
/*
* If there was a stream that wasn't the default stream the leading
* colon and trailing :$DATA has now been stripped off. Create a new
* smb_filename to pass back.
*/
status = create_synthetic_smb_fname(ctx, smb_fname_in->base_name,
stream_name, &smb_fname_in->st,
smb_fname_out);
TALLOC_FREE(stream_name);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(5, ("Failed to prep stream name for %s: %s\n",
*smb_fname_out ?
smb_fname_str_dbg(*smb_fname_out) : "NULL",
nt_errstr(status)));
}
return status;
}
struct param *param_section_get (struct param_section *section, const char *name)
{
struct param *p;
for (p = section->parameters; p; p = p->next) {
if (strcasecmp_m(p->name, name) == 0)
return p;
}
return NULL;
}
/* lookup is case-insensitive */
static struct fss_sc_smap *sc_smap_lookup(struct fss_sc_smap *smaps_head,
const char *share)
{
struct fss_sc_smap *sc_smap;
for (sc_smap = smaps_head; sc_smap; sc_smap = sc_smap->next) {
if (!strcasecmp_m(sc_smap->share_name, share)) {
return sc_smap;
}
}
DEBUG(4, ("shadow copy share mapping for %s not found\n", share));
return NULL;
}
struct param_section *param_get_section(struct param_context *ctx, const char *name)
{
struct param_section *sect;
if (name == NULL)
name = GLOBAL_NAME;
for (sect = ctx->sections; sect; sect = sect->next) {
if (!strcasecmp_m(sect->name, name))
return sect;
}
return NULL;
}
/*
reply to a GETDC request
*/
static void nbtd_netlogon_getdc(struct dgram_mailslot_handler *dgmslot,
struct nbtd_interface *iface,
struct nbt_dgram_packet *packet,
const struct socket_address *src,
struct nbt_netlogon_packet *netlogon)
{
struct nbt_name *name = &packet->data.msg.dest_name;
struct nbtd_interface *reply_iface = nbtd_find_reply_iface(iface, src->addr, false);
struct nbt_netlogon_response_from_pdc *pdc;
struct ldb_context *samctx;
struct nbt_netlogon_response netlogon_response;
/* only answer getdc requests on the PDC or LOGON names */
if (name->type != NBT_NAME_PDC && name->type != NBT_NAME_LOGON) {
return;
}
samctx = iface->nbtsrv->sam_ctx;
if (lpcfg_server_role(iface->nbtsrv->task->lp_ctx) != ROLE_DOMAIN_CONTROLLER
|| !samdb_is_pdc(samctx)) {
DEBUG(2, ("Not a PDC, so not processing LOGON_PRIMARY_QUERY\n"));
return;
}
if (strcasecmp_m(name->name, lpcfg_workgroup(iface->nbtsrv->task->lp_ctx)) != 0) {
DEBUG(5,("GetDC requested for a domian %s that we don't host\n", name->name));
return;
}
/* setup a GETDC reply */
ZERO_STRUCT(netlogon_response);
netlogon_response.response_type = NETLOGON_GET_PDC;
pdc = &netlogon_response.data.get_pdc;
pdc->command = NETLOGON_RESPONSE_FROM_PDC;
pdc->pdc_name = lpcfg_netbios_name(iface->nbtsrv->task->lp_ctx);
pdc->unicode_pdc_name = pdc->pdc_name;
pdc->domain_name = lpcfg_workgroup(iface->nbtsrv->task->lp_ctx);
pdc->nt_version = 1;
pdc->lmnt_token = 0xFFFF;
pdc->lm20_token = 0xFFFF;
dgram_mailslot_netlogon_reply(reply_iface->dgmsock,
packet,
lpcfg_netbios_name(iface->nbtsrv->task->lp_ctx),
netlogon->req.pdc.mailslot_name,
&netlogon_response);
}
static NTSTATUS lookup_well_known_sids(TALLOC_CTX *mem_ctx,
const char *sid_str, const char **authority_name,
const char **name, uint32_t *rtype)
{
int i;
for (i=0; well_known[i].sid; i++) {
if (strcasecmp_m(sid_str, well_known[i].sid) == 0) {
*authority_name = well_known[i].domain;
*name = well_known[i].name;
*rtype = well_known[i].rtype;
return NT_STATUS_OK;
}
}
return NT_STATUS_NOT_FOUND;
}
int net_group(struct net_context *c, int argc, const char **argv)
{
if (argc < 1)
return net_group_usage(c, argc, argv);
if (strcasecmp_m(argv[0], "HELP") == 0) {
net_group_usage(c, argc, argv);
return 0;
}
if (net_ads_check(c) == 0)
return net_ads_group(c, argc, argv);
return net_rap_group(c, argc, argv);
}
/*
add a single DOS EA
*/
NTSTATUS pvfs_setfileinfo_ea_set(struct pvfs_state *pvfs,
struct pvfs_filename *name,
int fd, uint16_t num_eas,
struct ea_struct *eas)
{
struct xattr_DosEAs *ealist;
int i, j;
NTSTATUS status;
if (num_eas == 0) {
return NT_STATUS_OK;
}
if (!(pvfs->flags & PVFS_FLAG_XATTR_ENABLE)) {
return NT_STATUS_NOT_SUPPORTED;
}
ealist = talloc(name, struct xattr_DosEAs);
/* load the current list */
status = pvfs_doseas_load(pvfs, name, fd, ealist);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
for (j=0;j<num_eas;j++) {
struct ea_struct *ea = &eas[j];
/* see if its already there */
for (i=0;i<ealist->num_eas;i++) {
if (strcasecmp_m(ealist->eas[i].name, ea->name.s) == 0) {
ealist->eas[i].value = ea->value;
break;
}
}
if (i==ealist->num_eas) {
/* add it */
ealist->eas = talloc_realloc(ealist, ealist->eas,
struct xattr_EA,
ealist->num_eas+1);
if (ealist->eas == NULL) {
return NT_STATUS_NO_MEMORY;
}
ealist->eas[i].name = ea->name.s;
ealist->eas[i].value = ea->value;
ealist->num_eas++;
}
}
static bool test_strcasecmp_m(struct torture_context *tctx)
{
/* file.{accented e} in iso8859-1 */
const char file_iso8859_1[7] = { 0x66, 0x69, 0x6c, 0x65, 0x2d, 0xe9, 0 };
/* file.{accented e} in utf8 */
const char file_utf8[8] = { 0x66, 0x69, 0x6c, 0x65, 0x2d, 0xc3, 0xa9, 0 };
torture_assert(tctx, strcasecmp_m("foo", "bar") != 0, "different strings");
torture_assert(tctx, strcasecmp_m("foo", "foo") == 0, "same case strings");
torture_assert(tctx, strcasecmp_m("foo", "Foo") == 0, "different case strings");
torture_assert(tctx, strcasecmp_m(NULL, "Foo") != 0, "one NULL");
torture_assert(tctx, strcasecmp_m("foo", NULL) != 0, "other NULL");
torture_assert(tctx, strcasecmp_m(NULL, NULL) == 0, "both NULL");
torture_assert(tctx, strcasecmp_m(file_iso8859_1, file_utf8) != 0,
"file.{accented e} should differ");
return true;
}
/*
add to the lsa_RefDomainList for LookupSids and LookupNames
*/
static NTSTATUS dcesrv_lsa_authority_list(struct lsa_policy_state *state, TALLOC_CTX *mem_ctx,
enum lsa_SidType rtype,
const char *authority_name,
struct dom_sid *sid,
struct lsa_RefDomainList *domains,
uint32_t *sid_index)
{
struct dom_sid *authority_sid;
int i;
if (rtype != SID_NAME_DOMAIN) {
authority_sid = dom_sid_dup(mem_ctx, sid);
if (authority_sid == NULL) {
return NT_STATUS_NO_MEMORY;
}
authority_sid->num_auths--;
} else {
authority_sid = sid;
}
/* see if we've already done this authority name */
for (i=0; i<domains->count; i++) {
if (strcasecmp_m(authority_name, domains->domains[i].name.string) == 0) {
*sid_index = i;
return NT_STATUS_OK;
}
}
domains->domains = talloc_realloc(domains,
domains->domains,
struct lsa_DomainInfo,
domains->count+1);
if (domains->domains == NULL) {
return NT_STATUS_NO_MEMORY;
}
domains->domains[i].name.string = authority_name;
domains->domains[i].sid = authority_sid;
domains->count++;
domains->max_size = LSA_REF_DOMAIN_LIST_MULTIPLIER * domains->count;
*sid_index = i;
return NT_STATUS_OK;
}
int write_bom(FILE* file, const char* charset, charset_t ctype)
{
int i;
if ( charset == NULL ) {
for (i=0; BOM[i].name; i++) {
if (BOM[i].ctype == ctype) {
return fwrite(BOM[i].seq, 1, BOM[i].len, file);
}
}
DEBUG(0, ("No Byte Order Mark for charset_t: %u\n", (unsigned)ctype));
} else {
for (i=0; BOM[i].name; i++) {
if (strcasecmp_m(BOM[i].name, charset) == 0) {
return fwrite(BOM[i].seq, 1, BOM[i].len, file);
}
}
DEBUG(0, ("No Byte Order Mark for charset_t: %s\n", charset));
}
return 0;
}
static int compare_dirent (const SMB_STRUCT_DIRENT *da, const SMB_STRUCT_DIRENT *db)
{
return strcasecmp_m(da->d_name, db->d_name);
}
static int compare_dirent (const struct dirent *da, const struct dirent *db)
{
return strcasecmp_m(da->d_name, db->d_name);
}
static int streams_xattr_rename(vfs_handle_struct *handle,
const struct smb_filename *smb_fname_src,
const struct smb_filename *smb_fname_dst)
{
NTSTATUS status;
int ret = -1;
char *src_xattr_name = NULL;
char *dst_xattr_name = NULL;
bool src_is_stream, dst_is_stream;
ssize_t oret;
ssize_t nret;
struct ea_struct ea;
src_is_stream = is_ntfs_stream_smb_fname(smb_fname_src);
dst_is_stream = is_ntfs_stream_smb_fname(smb_fname_dst);
if (!src_is_stream && !dst_is_stream) {
return SMB_VFS_NEXT_RENAME(handle, smb_fname_src,
smb_fname_dst);
}
/* For now don't allow renames from or to the default stream. */
if (is_ntfs_default_stream_smb_fname(smb_fname_src) ||
is_ntfs_default_stream_smb_fname(smb_fname_dst)) {
errno = ENOSYS;
goto done;
}
/* Don't rename if the streams are identical. */
if (strcasecmp_m(smb_fname_src->stream_name,
smb_fname_dst->stream_name) == 0) {
goto done;
}
/* Get the xattr names. */
status = streams_xattr_get_name(handle, talloc_tos(),
smb_fname_src->stream_name,
&src_xattr_name);
if (!NT_STATUS_IS_OK(status)) {
errno = map_errno_from_nt_status(status);
goto fail;
}
status = streams_xattr_get_name(handle, talloc_tos(),
smb_fname_dst->stream_name,
&dst_xattr_name);
if (!NT_STATUS_IS_OK(status)) {
errno = map_errno_from_nt_status(status);
goto fail;
}
/* read the old stream */
status = get_ea_value(talloc_tos(), handle->conn, NULL,
smb_fname_src, src_xattr_name, &ea);
if (!NT_STATUS_IS_OK(status)) {
errno = ENOENT;
goto fail;
}
/* (over)write the new stream */
nret = SMB_VFS_SETXATTR(handle->conn, smb_fname_src,
dst_xattr_name, ea.value.data, ea.value.length,
0);
if (nret < 0) {
if (errno == ENOATTR) {
errno = ENOENT;
}
goto fail;
}
/* remove the old stream */
oret = SMB_VFS_REMOVEXATTR(handle->conn, smb_fname_src,
src_xattr_name);
if (oret < 0) {
if (errno == ENOATTR) {
errno = ENOENT;
}
goto fail;
}
done:
errno = 0;
ret = 0;
fail:
TALLOC_FREE(src_xattr_name);
TALLOC_FREE(dst_xattr_name);
return ret;
}