/src/samba/source4/libcli/raw/rawsetfileinfo.c

Source
/*
   Unix SMB/CIFS implementation.
   RAW_SFILEINFO_* calls
   Copyright (C) James Myers 2003
   Copyright (C) Andrew Tridgell 2003
   Copyright (C) James Peach 2007

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "includes.h"
#include "libcli/raw/libcliraw.h"
#include "libcli/raw/raw_proto.h"
#include "librpc/gen_ndr/ndr_security.h"


/*
  Handle setfileinfo/setpathinfo passthu constructions
*/
bool smb_raw_setfileinfo_passthru(TALLOC_CTX *mem_ctx,
          enum smb_setfileinfo_level level,
          union smb_setfileinfo *parms,
          DATA_BLOB *blob)
{
  unsigned int len;

#define NEED_BLOB(n) do { \
    *blob = data_blob_talloc(mem_ctx, NULL, n); \
    if (blob->data == NULL && n != 0) return false; \
        } while (0)

  switch (level) {
  case RAW_SFILEINFO_BASIC_INFORMATION:
    NEED_BLOB(40);
    smbcli_push_nttime(blob->data,  0, parms->basic_info.in.create_time);
    smbcli_push_nttime(blob->data,  8, parms->basic_info.in.access_time);
    smbcli_push_nttime(blob->data, 16, parms->basic_info.in.write_time);
    smbcli_push_nttime(blob->data, 24, parms->basic_info.in.change_time);
    SIVAL(blob->data,           32, parms->basic_info.in.attrib);
    SIVAL(blob->data,           36, 0); /* padding */
    return true;

  case RAW_SFILEINFO_DISPOSITION_INFORMATION:
    NEED_BLOB(4);
    SIVAL(blob->data, 0, parms->disposition_info.in.delete_on_close);
    return true;

  case RAW_SFILEINFO_ALLOCATION_INFORMATION:
    NEED_BLOB(8);
    SBVAL(blob->data, 0, parms->allocation_info.in.alloc_size);
    return true;

  case RAW_SFILEINFO_END_OF_FILE_INFORMATION:
    NEED_BLOB(8);
    SBVAL(blob->data, 0, parms->end_of_file_info.in.size);
    return true;

  case RAW_SFILEINFO_RENAME_INFORMATION:
    NEED_BLOB(12);
    SIVAL(blob->data, 0, parms->rename_information.in.overwrite);
    SIVAL(blob->data, 4, parms->rename_information.in.root_fid);
    len = smbcli_blob_append_string(NULL, mem_ctx, blob,
            parms->rename_information.in.new_name,
            STR_UNICODE|STR_TERMINATE);
    SIVAL(blob->data, 8, len - 2);
    return true;

  case RAW_SFILEINFO_RENAME_INFORMATION_SMB2:
    NEED_BLOB(20);
    SIVAL(blob->data, 0, parms->rename_information.in.overwrite);
    SIVAL(blob->data, 4, 0);
    SBVAL(blob->data, 8, parms->rename_information.in.root_fid);
    len = smbcli_blob_append_string(NULL, mem_ctx, blob,
            parms->rename_information.in.new_name,
            STR_UNICODE|STR_TERMINATE);
    SIVAL(blob->data, 16, len - 2);
    return true;

  case RAW_SFILEINFO_POSITION_INFORMATION:
    NEED_BLOB(8);
    SBVAL(blob->data, 0, parms->position_information.in.position);
    return true;

  case RAW_SFILEINFO_MODE_INFORMATION:
    NEED_BLOB(4);
    SIVAL(blob->data, 0, parms->mode_information.in.mode);
    return true;

  case RAW_FILEINFO_SEC_DESC: {
    enum ndr_err_code ndr_err;

    ndr_err = ndr_push_struct_blob(blob, mem_ctx, parms->set_secdesc.in.sd,
                 (ndr_push_flags_fn_t)ndr_push_security_descriptor);
    if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
      return false;
    }

    return true;
  }

  case RAW_SFILEINFO_FULL_EA_INFORMATION:
    printf("num_eas=%d\n", parms->full_ea_information.in.eas.num_eas);
    NEED_BLOB(ea_list_size_chained(
          parms->full_ea_information.in.eas.num_eas,
          parms->full_ea_information.in.eas.eas, 4));
    ea_put_list_chained(blob->data,
            parms->full_ea_information.in.eas.num_eas,
            parms->full_ea_information.in.eas.eas, 4);
    return true;

  case RAW_SFILEINFO_LINK_INFORMATION:
    NEED_BLOB(20);
    memset(blob->data, 0, blob->length);

    PUSH_LE_U8(blob->data, 0, parms->link_information.in.overwrite);
    PUSH_LE_U64(blob->data, 8, parms->link_information.in.root_fid);

    len = smbcli_blob_append_string(
      NULL, mem_ctx, blob,
      parms->link_information.in.new_name,
      STR_UNICODE | STR_TERMINATE);
    PUSH_LE_U32(blob->data, 16, len - 2);
    return true;

    /* Unhandled levels */
  case RAW_SFILEINFO_PIPE_INFORMATION:
  case RAW_SFILEINFO_VALID_DATA_INFORMATION:
  case RAW_SFILEINFO_SHORT_NAME_INFORMATION:
  case RAW_SFILEINFO_1025:
  case RAW_SFILEINFO_1027:
  case RAW_SFILEINFO_1029:
  case RAW_SFILEINFO_1030:
  case RAW_SFILEINFO_1031:
  case RAW_SFILEINFO_1032:
  case RAW_SFILEINFO_1036:
  case RAW_SFILEINFO_1041:
  case RAW_SFILEINFO_1042:
  case RAW_SFILEINFO_1043:
  case RAW_SFILEINFO_1044:
    break;

  default:
    DEBUG(0,("Unhandled setfileinfo passthru level %d\n", level));
    return false;
  }

  return false;
}

/*
  Handle setfileinfo/setpathinfo trans2 backend.
*/
static bool smb_raw_setinfo_backend(struct smbcli_tree *tree,
            TALLOC_CTX *mem_ctx,
            union smb_setfileinfo *parms,
            DATA_BLOB *blob)
{
  switch (parms->generic.level) {
  case RAW_SFILEINFO_GENERIC:
  case RAW_SFILEINFO_SETATTR:
  case RAW_SFILEINFO_SETATTRE:
  case RAW_SFILEINFO_SEC_DESC:
    /* not handled here */
    return false;

  case RAW_SFILEINFO_STANDARD:
    NEED_BLOB(12);
    raw_push_dos_date2(tree->session->transport,
          blob->data, 0, parms->standard.in.create_time);
    raw_push_dos_date2(tree->session->transport,
          blob->data, 4, parms->standard.in.access_time);
    raw_push_dos_date2(tree->session->transport,
          blob->data, 8, parms->standard.in.write_time);
    return true;

  case RAW_SFILEINFO_EA_SET:
    NEED_BLOB(ea_list_size(parms->ea_set.in.num_eas, parms->ea_set.in.eas));
    ea_put_list(blob->data, parms->ea_set.in.num_eas, parms->ea_set.in.eas);
    return true;

  case RAW_SFILEINFO_BASIC_INFO:
  case RAW_SFILEINFO_BASIC_INFORMATION:
    return smb_raw_setfileinfo_passthru(mem_ctx, RAW_SFILEINFO_BASIC_INFORMATION,
                parms, blob);

  case RAW_SFILEINFO_UNIX_BASIC:
    NEED_BLOB(100);
    SBVAL(blob->data, 0, parms->unix_basic.in.end_of_file);
    SBVAL(blob->data, 8, parms->unix_basic.in.num_bytes);
    smbcli_push_nttime(blob->data, 16, parms->unix_basic.in.status_change_time);
    smbcli_push_nttime(blob->data, 24, parms->unix_basic.in.access_time);
    smbcli_push_nttime(blob->data, 32, parms->unix_basic.in.change_time);
    SBVAL(blob->data, 40, parms->unix_basic.in.uid);
    SBVAL(blob->data, 48, parms->unix_basic.in.gid);
    SIVAL(blob->data, 56, parms->unix_basic.in.file_type);
    SBVAL(blob->data, 60, parms->unix_basic.in.dev_major);
    SBVAL(blob->data, 68, parms->unix_basic.in.dev_minor);
    SBVAL(blob->data, 76, parms->unix_basic.in.unique_id);
    SBVAL(blob->data, 84, parms->unix_basic.in.permissions);
    SBVAL(blob->data, 92, parms->unix_basic.in.nlink);
    return true;

  case RAW_SFILEINFO_UNIX_INFO2:
    NEED_BLOB(116);
    SBVAL(blob->data,   0, parms->unix_info2.in.end_of_file);
    SBVAL(blob->data,   8, parms->unix_info2.in.num_bytes);
    smbcli_push_nttime(blob->data, 16, parms->unix_info2.in.status_change_time);
    smbcli_push_nttime(blob->data, 24, parms->unix_info2.in.access_time);
    smbcli_push_nttime(blob->data, 32, parms->unix_info2.in.change_time);
    SBVAL(blob->data,  40,parms->unix_info2.in.uid);
    SBVAL(blob->data,  48,parms->unix_info2.in.gid);
    SIVAL(blob->data,  56,parms->unix_info2.in.file_type);
    SBVAL(blob->data,  60,parms->unix_info2.in.dev_major);
    SBVAL(blob->data,  68,parms->unix_info2.in.dev_minor);
    SBVAL(blob->data,  76,parms->unix_info2.in.unique_id);
    SBVAL(blob->data,  84,parms->unix_info2.in.permissions);
    SBVAL(blob->data,  92,parms->unix_info2.in.nlink);
    smbcli_push_nttime(blob->data, 100, parms->unix_info2.in.create_time);
    SIVAL(blob->data, 108, parms->unix_info2.in.file_flags);
    SIVAL(blob->data, 112, parms->unix_info2.in.flags_mask);
    return true;

  case RAW_SFILEINFO_DISPOSITION_INFO:
  case RAW_SFILEINFO_DISPOSITION_INFORMATION:
    return smb_raw_setfileinfo_passthru(mem_ctx, RAW_SFILEINFO_DISPOSITION_INFORMATION,
                parms, blob);

  case RAW_SFILEINFO_ALLOCATION_INFO:
  case RAW_SFILEINFO_ALLOCATION_INFORMATION:
    return smb_raw_setfileinfo_passthru(mem_ctx, RAW_SFILEINFO_ALLOCATION_INFORMATION,
                parms, blob);

  case RAW_SFILEINFO_END_OF_FILE_INFO:
  case RAW_SFILEINFO_END_OF_FILE_INFORMATION:
    return smb_raw_setfileinfo_passthru(mem_ctx, RAW_SFILEINFO_END_OF_FILE_INFORMATION,
                parms, blob);

  case RAW_SFILEINFO_RENAME_INFORMATION:
    return smb_raw_setfileinfo_passthru(mem_ctx, RAW_SFILEINFO_RENAME_INFORMATION,
                parms, blob);

  case RAW_SFILEINFO_POSITION_INFORMATION:
    return smb_raw_setfileinfo_passthru(mem_ctx, RAW_SFILEINFO_POSITION_INFORMATION,
                parms, blob);

  case RAW_SFILEINFO_MODE_INFORMATION:
    return smb_raw_setfileinfo_passthru(mem_ctx, RAW_SFILEINFO_MODE_INFORMATION,
                parms, blob);

    /* Unhandled passthru levels */
  case RAW_SFILEINFO_PIPE_INFORMATION:
  case RAW_SFILEINFO_VALID_DATA_INFORMATION:
  case RAW_SFILEINFO_SHORT_NAME_INFORMATION:
  case RAW_SFILEINFO_FULL_EA_INFORMATION:
  case RAW_SFILEINFO_1025:
  case RAW_SFILEINFO_1027:
  case RAW_SFILEINFO_1029:
  case RAW_SFILEINFO_1030:
  case RAW_SFILEINFO_1031:
  case RAW_SFILEINFO_1032:
  case RAW_SFILEINFO_1036:
  case RAW_SFILEINFO_1041:
  case RAW_SFILEINFO_1042:
  case RAW_SFILEINFO_1043:
  case RAW_SFILEINFO_1044:
    return smb_raw_setfileinfo_passthru(mem_ctx, parms->generic.level,
                parms, blob);

  /* Unhandled levels */
  case RAW_SFILEINFO_UNIX_LINK:
  case RAW_SFILEINFO_UNIX_HLINK:
  case RAW_SFILEINFO_RENAME_INFORMATION_SMB2:
  case RAW_SFILEINFO_LINK_INFORMATION:
    break;
  }

  return false;
}

/****************************************************************************
 Very raw set file info - takes data blob (async send)
****************************************************************************/
static struct smbcli_request *smb_raw_setfileinfo_blob_send(struct smbcli_tree *tree,
               TALLOC_CTX *mem_ctx,
               uint16_t fnum,
               uint16_t info_level,
               DATA_BLOB *blob)
{
  struct smb_trans2 tp;
  uint16_t setup = TRANSACT2_SETFILEINFO;

  tp.in.max_setup = 0;
  tp.in.flags = 0;
  tp.in.timeout = 0;
  tp.in.setup_count = 1;
  tp.in.max_param = 2;
  tp.in.max_data = 0;
  tp.in.setup = &setup;

  tp.in.params = data_blob_talloc(mem_ctx, NULL, 6);
  if (!tp.in.params.data) {
    return NULL;
  }
  SSVAL(tp.in.params.data, 0, fnum);
  SSVAL(tp.in.params.data, 2, info_level);
  SSVAL(tp.in.params.data, 4, 0); /* reserved */

  tp.in.data = *blob;

  return smb_raw_trans2_send(tree, &tp);
}

/****************************************************************************
 Very raw set path info - takes data blob
****************************************************************************/
static struct smbcli_request *smb_raw_setpathinfo_blob_send(struct smbcli_tree *tree,
                  TALLOC_CTX *mem_ctx,
                  const char *fname,
                  uint16_t info_level,
                  DATA_BLOB *blob)
{
  struct smb_trans2 tp;
  uint16_t setup = TRANSACT2_SETPATHINFO;

  tp.in.max_setup = 0;
  tp.in.flags = 0;
  tp.in.timeout = 0;
  tp.in.setup_count = 1;
  tp.in.max_param = 2;
  tp.in.max_data = 0;
  tp.in.setup = &setup;

  tp.in.params = data_blob_talloc(mem_ctx, NULL, 6);
  if (!tp.in.params.data) {
    return NULL;
  }
  SSVAL(tp.in.params.data, 0, info_level);
  SIVAL(tp.in.params.data, 2, 0);
  smbcli_blob_append_string(tree->session, mem_ctx,
          &tp.in.params,
          fname, STR_TERMINATE);

  tp.in.data = *blob;

  return smb_raw_trans2_send(tree, &tp);
}

/****************************************************************************
 Handle setattr (async send)
****************************************************************************/
static struct smbcli_request *smb_raw_setattr_send(struct smbcli_tree *tree,
            union smb_setfileinfo *parms)
{
  struct smbcli_request *req;

  req = smbcli_request_setup(tree, SMBsetatr, 8, 0);
  if (!req) return NULL;

  SSVAL(req->out.vwv,         VWV(0), parms->setattr.in.attrib);
  raw_push_dos_date3(tree->session->transport,
        req->out.vwv, VWV(1), parms->setattr.in.write_time);
  memset(req->out.vwv + VWV(3), 0, 10); /* reserved */
  smbcli_req_append_ascii4(req, parms->setattr.in.file.path, STR_TERMINATE);
  smbcli_req_append_ascii4(req, "", STR_TERMINATE);

  if (!smbcli_request_send(req)) {
    smbcli_request_destroy(req);
    return NULL;
  }

  return req;
}

/****************************************************************************
 Handle setattrE. (async send)
****************************************************************************/
static struct smbcli_request *smb_raw_setattrE_send(struct smbcli_tree *tree,
             union smb_setfileinfo *parms)
{
  struct smbcli_request *req;

  req = smbcli_request_setup(tree, SMBsetattrE, 7, 0);
  if (!req) return NULL;

  SSVAL(req->out.vwv,         VWV(0), parms->setattre.in.file.fnum);
  raw_push_dos_date2(tree->session->transport,
        req->out.vwv, VWV(1), parms->setattre.in.create_time);
  raw_push_dos_date2(tree->session->transport,
        req->out.vwv, VWV(3), parms->setattre.in.access_time);
  raw_push_dos_date2(tree->session->transport,
        req->out.vwv, VWV(5), parms->setattre.in.write_time);

  if (!smbcli_request_send(req)) {
    smbcli_request_destroy(req);
    return NULL;
  }

  return req;
}

/****************************************************************************
 Set file info (async send)
****************************************************************************/
struct smbcli_request *smb_raw_setfileinfo_send(struct smbcli_tree *tree,
               union smb_setfileinfo *parms)
{
  DATA_BLOB blob;
  TALLOC_CTX *mem_ctx;
  struct smbcli_request *req;

  if (parms->generic.level == RAW_SFILEINFO_SETATTRE) {
    return smb_raw_setattrE_send(tree, parms);
  }
  if (parms->generic.level == RAW_SFILEINFO_SEC_DESC) {
    return smb_raw_set_secdesc_send(tree, parms);
  }
  if (parms->generic.level >= RAW_SFILEINFO_GENERIC) {
    return NULL;
  }

  mem_ctx = talloc_init("setpathinfo");
  if (!mem_ctx) return NULL;

  if (!smb_raw_setinfo_backend(tree, mem_ctx, parms, &blob)) {
    talloc_free(mem_ctx);
    return NULL;
  }

  /* send request and process the output */
  req = smb_raw_setfileinfo_blob_send(tree,
              mem_ctx,
              parms->generic.in.file.fnum,
              parms->generic.level,
              &blob);

  talloc_free(mem_ctx);
  return req;
}

/****************************************************************************
 Set file info (async send)
****************************************************************************/
_PUBLIC_ NTSTATUS smb_raw_setfileinfo(struct smbcli_tree *tree,
           union smb_setfileinfo *parms)
{
  struct smbcli_request *req = smb_raw_setfileinfo_send(tree, parms);
  return smbcli_request_simple_recv(req);
}


/****************************************************************************
 Set path info (async send)
****************************************************************************/
_PUBLIC_ struct smbcli_request *smb_raw_setpathinfo_send(struct smbcli_tree *tree,
               union smb_setfileinfo *parms)
{
  DATA_BLOB blob;
  TALLOC_CTX *mem_ctx;
  struct smbcli_request *req;

  if (parms->generic.level == RAW_SFILEINFO_SETATTR) {
    return smb_raw_setattr_send(tree, parms);
  }
  if (parms->generic.level >= RAW_SFILEINFO_GENERIC) {
    return NULL;
  }

  mem_ctx = talloc_init("setpathinfo");
  if (!mem_ctx) return NULL;

  if (!smb_raw_setinfo_backend(tree, mem_ctx, parms, &blob)) {
    talloc_free(mem_ctx);
    return NULL;
  }

  /* send request and process the output */
  req = smb_raw_setpathinfo_blob_send(tree,
              mem_ctx,
              parms->generic.in.file.path,
              parms->generic.level,
              &blob);

  talloc_free(mem_ctx);
  return req;
}

/****************************************************************************
 Set path info (sync interface)
****************************************************************************/
_PUBLIC_ NTSTATUS smb_raw_setpathinfo(struct smbcli_tree *tree,
           union smb_setfileinfo *parms)
{
  struct smbcli_request *req = smb_raw_setpathinfo_send(tree, parms);
  return smbcli_request_simple_recv(req);
}

Coverage Report

Created: 2025-12-31 06:20

Line	Count	Source
1		/*
2		Unix SMB/CIFS implementation.
3		RAW_SFILEINFO_* calls
4		Copyright (C) James Myers 2003
5		Copyright (C) Andrew Tridgell 2003
6		Copyright (C) James Peach 2007
7
8		This program is free software; you can redistribute it and/or modify
9		it under the terms of the GNU General Public License as published by
10		the Free Software Foundation; either version 3 of the License, or
11		(at your option) any later version.
12
13		This program is distributed in the hope that it will be useful,
14		but WITHOUT ANY WARRANTY; without even the implied warranty of
15		MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16		GNU General Public License for more details.
17
18		You should have received a copy of the GNU General Public License
19		along with this program. If not, see <http://www.gnu.org/licenses/>.
20		*/
21
22		#include "includes.h"
23		#include "libcli/raw/libcliraw.h"
24		#include "libcli/raw/raw_proto.h"
25		#include "librpc/gen_ndr/ndr_security.h"
26
27
28		/*
29		Handle setfileinfo/setpathinfo passthu constructions
30		*/
31		bool smb_raw_setfileinfo_passthru(TALLOC_CTX *mem_ctx,
32		enum smb_setfileinfo_level level,
33		union smb_setfileinfo *parms,
34		DATA_BLOB *blob)
35	0	{
36	0	unsigned int len;
37
38	0	#define NEED_BLOB(n) do { \
39	0	*blob = data_blob_talloc(mem_ctx, NULL, n); \
40	0	if (blob->data == NULL && n != 0) return false; \
41	0	} while (0)
42
43	0	switch (level) {
44	0	case RAW_SFILEINFO_BASIC_INFORMATION:
45	0	NEED_BLOB(40);
46	0	smbcli_push_nttime(blob->data, 0, parms->basic_info.in.create_time);
47	0	smbcli_push_nttime(blob->data, 8, parms->basic_info.in.access_time);
48	0	smbcli_push_nttime(blob->data, 16, parms->basic_info.in.write_time);
49	0	smbcli_push_nttime(blob->data, 24, parms->basic_info.in.change_time);
50	0	SIVAL(blob->data, 32, parms->basic_info.in.attrib);
51	0	SIVAL(blob->data, 36, 0); /* padding */
52	0	return true;
53
54	0	case RAW_SFILEINFO_DISPOSITION_INFORMATION:
55	0	NEED_BLOB(4);
56	0	SIVAL(blob->data, 0, parms->disposition_info.in.delete_on_close);
57	0	return true;
58
59	0	case RAW_SFILEINFO_ALLOCATION_INFORMATION:
60	0	NEED_BLOB(8);
61	0	SBVAL(blob->data, 0, parms->allocation_info.in.alloc_size);
62	0	return true;
63
64	0	case RAW_SFILEINFO_END_OF_FILE_INFORMATION:
65	0	NEED_BLOB(8);
66	0	SBVAL(blob->data, 0, parms->end_of_file_info.in.size);
67	0	return true;
68
69	0	case RAW_SFILEINFO_RENAME_INFORMATION:
70	0	NEED_BLOB(12);
71	0	SIVAL(blob->data, 0, parms->rename_information.in.overwrite);
72	0	SIVAL(blob->data, 4, parms->rename_information.in.root_fid);
73	0	len = smbcli_blob_append_string(NULL, mem_ctx, blob,
74	0	parms->rename_information.in.new_name,
75	0	STR_UNICODE\|STR_TERMINATE);
76	0	SIVAL(blob->data, 8, len - 2);
77	0	return true;
78
79	0	case RAW_SFILEINFO_RENAME_INFORMATION_SMB2:
80	0	NEED_BLOB(20);
81	0	SIVAL(blob->data, 0, parms->rename_information.in.overwrite);
82	0	SIVAL(blob->data, 4, 0);
83	0	SBVAL(blob->data, 8, parms->rename_information.in.root_fid);
84	0	len = smbcli_blob_append_string(NULL, mem_ctx, blob,
85	0	parms->rename_information.in.new_name,
86	0	STR_UNICODE\|STR_TERMINATE);
87	0	SIVAL(blob->data, 16, len - 2);
88	0	return true;
89
90	0	case RAW_SFILEINFO_POSITION_INFORMATION:
91	0	NEED_BLOB(8);
92	0	SBVAL(blob->data, 0, parms->position_information.in.position);
93	0	return true;
94
95	0	case RAW_SFILEINFO_MODE_INFORMATION:
96	0	NEED_BLOB(4);
97	0	SIVAL(blob->data, 0, parms->mode_information.in.mode);
98	0	return true;
99
100	0	case RAW_FILEINFO_SEC_DESC: {
101	0	enum ndr_err_code ndr_err;
102
103	0	ndr_err = ndr_push_struct_blob(blob, mem_ctx, parms->set_secdesc.in.sd,
104	0	(ndr_push_flags_fn_t)ndr_push_security_descriptor);
105	0	if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
106	0	return false;
107	0	}
108
109	0	return true;
110	0	}
111
112	0	case RAW_SFILEINFO_FULL_EA_INFORMATION:
113	0	printf("num_eas=%d\n", parms->full_ea_information.in.eas.num_eas);
114	0	NEED_BLOB(ea_list_size_chained(
115	0	parms->full_ea_information.in.eas.num_eas,
116	0	parms->full_ea_information.in.eas.eas, 4));
117	0	ea_put_list_chained(blob->data,
118	0	parms->full_ea_information.in.eas.num_eas,
119	0	parms->full_ea_information.in.eas.eas, 4);
120	0	return true;
121
122	0	case RAW_SFILEINFO_LINK_INFORMATION:
123	0	NEED_BLOB(20);
124	0	memset(blob->data, 0, blob->length);
125
126	0	PUSH_LE_U8(blob->data, 0, parms->link_information.in.overwrite);
127	0	PUSH_LE_U64(blob->data, 8, parms->link_information.in.root_fid);
128
129	0	len = smbcli_blob_append_string(
130	0	NULL, mem_ctx, blob,
131	0	parms->link_information.in.new_name,
132	0	STR_UNICODE \| STR_TERMINATE);
133	0	PUSH_LE_U32(blob->data, 16, len - 2);
134	0	return true;
135
136		/* Unhandled levels */
137	0	case RAW_SFILEINFO_PIPE_INFORMATION:
138	0	case RAW_SFILEINFO_VALID_DATA_INFORMATION:
139	0	case RAW_SFILEINFO_SHORT_NAME_INFORMATION:
140	0	case RAW_SFILEINFO_1025:
141	0	case RAW_SFILEINFO_1027:
142	0	case RAW_SFILEINFO_1029:
143	0	case RAW_SFILEINFO_1030:
144	0	case RAW_SFILEINFO_1031:
145	0	case RAW_SFILEINFO_1032:
146	0	case RAW_SFILEINFO_1036:
147	0	case RAW_SFILEINFO_1041:
148	0	case RAW_SFILEINFO_1042:
149	0	case RAW_SFILEINFO_1043:
150	0	case RAW_SFILEINFO_1044:
151	0	break;
152
153	0	default:
154	0	DEBUG(0,("Unhandled setfileinfo passthru level %d\n", level));
155	0	return false;
156	0	}
157
158	0	return false;
159	0	}
160
161		/*
162		Handle setfileinfo/setpathinfo trans2 backend.
163		*/
164		static bool smb_raw_setinfo_backend(struct smbcli_tree *tree,
165		TALLOC_CTX *mem_ctx,
166		union smb_setfileinfo *parms,
167		DATA_BLOB *blob)
168	0	{
169	0	switch (parms->generic.level) {
170	0	case RAW_SFILEINFO_GENERIC:
171	0	case RAW_SFILEINFO_SETATTR:
172	0	case RAW_SFILEINFO_SETATTRE:
173	0	case RAW_SFILEINFO_SEC_DESC:
174		/* not handled here */
175	0	return false;
176
177	0	case RAW_SFILEINFO_STANDARD:
178	0	NEED_BLOB(12);
179	0	raw_push_dos_date2(tree->session->transport,
180	0	blob->data, 0, parms->standard.in.create_time);
181	0	raw_push_dos_date2(tree->session->transport,
182	0	blob->data, 4, parms->standard.in.access_time);
183	0	raw_push_dos_date2(tree->session->transport,
184	0	blob->data, 8, parms->standard.in.write_time);
185	0	return true;
186
187	0	case RAW_SFILEINFO_EA_SET:
188	0	NEED_BLOB(ea_list_size(parms->ea_set.in.num_eas, parms->ea_set.in.eas));
189	0	ea_put_list(blob->data, parms->ea_set.in.num_eas, parms->ea_set.in.eas);
190	0	return true;
191
192	0	case RAW_SFILEINFO_BASIC_INFO:
193	0	case RAW_SFILEINFO_BASIC_INFORMATION:
194	0	return smb_raw_setfileinfo_passthru(mem_ctx, RAW_SFILEINFO_BASIC_INFORMATION,
195	0	parms, blob);
196
197	0	case RAW_SFILEINFO_UNIX_BASIC:
198	0	NEED_BLOB(100);
199	0	SBVAL(blob->data, 0, parms->unix_basic.in.end_of_file);
200	0	SBVAL(blob->data, 8, parms->unix_basic.in.num_bytes);
201	0	smbcli_push_nttime(blob->data, 16, parms->unix_basic.in.status_change_time);
202	0	smbcli_push_nttime(blob->data, 24, parms->unix_basic.in.access_time);
203	0	smbcli_push_nttime(blob->data, 32, parms->unix_basic.in.change_time);
204	0	SBVAL(blob->data, 40, parms->unix_basic.in.uid);
205	0	SBVAL(blob->data, 48, parms->unix_basic.in.gid);
206	0	SIVAL(blob->data, 56, parms->unix_basic.in.file_type);
207	0	SBVAL(blob->data, 60, parms->unix_basic.in.dev_major);
208	0	SBVAL(blob->data, 68, parms->unix_basic.in.dev_minor);
209	0	SBVAL(blob->data, 76, parms->unix_basic.in.unique_id);
210	0	SBVAL(blob->data, 84, parms->unix_basic.in.permissions);
211	0	SBVAL(blob->data, 92, parms->unix_basic.in.nlink);
212	0	return true;
213
214	0	case RAW_SFILEINFO_UNIX_INFO2:
215	0	NEED_BLOB(116);
216	0	SBVAL(blob->data, 0, parms->unix_info2.in.end_of_file);
217	0	SBVAL(blob->data, 8, parms->unix_info2.in.num_bytes);
218	0	smbcli_push_nttime(blob->data, 16, parms->unix_info2.in.status_change_time);
219	0	smbcli_push_nttime(blob->data, 24, parms->unix_info2.in.access_time);
220	0	smbcli_push_nttime(blob->data, 32, parms->unix_info2.in.change_time);
221	0	SBVAL(blob->data, 40,parms->unix_info2.in.uid);
222	0	SBVAL(blob->data, 48,parms->unix_info2.in.gid);
223	0	SIVAL(blob->data, 56,parms->unix_info2.in.file_type);
224	0	SBVAL(blob->data, 60,parms->unix_info2.in.dev_major);
225	0	SBVAL(blob->data, 68,parms->unix_info2.in.dev_minor);
226	0	SBVAL(blob->data, 76,parms->unix_info2.in.unique_id);
227	0	SBVAL(blob->data, 84,parms->unix_info2.in.permissions);
228	0	SBVAL(blob->data, 92,parms->unix_info2.in.nlink);
229	0	smbcli_push_nttime(blob->data, 100, parms->unix_info2.in.create_time);
230	0	SIVAL(blob->data, 108, parms->unix_info2.in.file_flags);
231	0	SIVAL(blob->data, 112, parms->unix_info2.in.flags_mask);
232	0	return true;
233
234	0	case RAW_SFILEINFO_DISPOSITION_INFO:
235	0	case RAW_SFILEINFO_DISPOSITION_INFORMATION:
236	0	return smb_raw_setfileinfo_passthru(mem_ctx, RAW_SFILEINFO_DISPOSITION_INFORMATION,
237	0	parms, blob);
238
239	0	case RAW_SFILEINFO_ALLOCATION_INFO:
240	0	case RAW_SFILEINFO_ALLOCATION_INFORMATION:
241	0	return smb_raw_setfileinfo_passthru(mem_ctx, RAW_SFILEINFO_ALLOCATION_INFORMATION,
242	0	parms, blob);
243
244	0	case RAW_SFILEINFO_END_OF_FILE_INFO:
245	0	case RAW_SFILEINFO_END_OF_FILE_INFORMATION:
246	0	return smb_raw_setfileinfo_passthru(mem_ctx, RAW_SFILEINFO_END_OF_FILE_INFORMATION,
247	0	parms, blob);
248
249	0	case RAW_SFILEINFO_RENAME_INFORMATION:
250	0	return smb_raw_setfileinfo_passthru(mem_ctx, RAW_SFILEINFO_RENAME_INFORMATION,
251	0	parms, blob);
252
253	0	case RAW_SFILEINFO_POSITION_INFORMATION:
254	0	return smb_raw_setfileinfo_passthru(mem_ctx, RAW_SFILEINFO_POSITION_INFORMATION,
255	0	parms, blob);
256
257	0	case RAW_SFILEINFO_MODE_INFORMATION:
258	0	return smb_raw_setfileinfo_passthru(mem_ctx, RAW_SFILEINFO_MODE_INFORMATION,
259	0	parms, blob);
260
261		/* Unhandled passthru levels */
262	0	case RAW_SFILEINFO_PIPE_INFORMATION:
263	0	case RAW_SFILEINFO_VALID_DATA_INFORMATION:
264	0	case RAW_SFILEINFO_SHORT_NAME_INFORMATION:
265	0	case RAW_SFILEINFO_FULL_EA_INFORMATION:
266	0	case RAW_SFILEINFO_1025:
267	0	case RAW_SFILEINFO_1027:
268	0	case RAW_SFILEINFO_1029:
269	0	case RAW_SFILEINFO_1030:
270	0	case RAW_SFILEINFO_1031:
271	0	case RAW_SFILEINFO_1032:
272	0	case RAW_SFILEINFO_1036:
273	0	case RAW_SFILEINFO_1041:
274	0	case RAW_SFILEINFO_1042:
275	0	case RAW_SFILEINFO_1043:
276	0	case RAW_SFILEINFO_1044:
277	0	return smb_raw_setfileinfo_passthru(mem_ctx, parms->generic.level,
278	0	parms, blob);
279
280		/* Unhandled levels */
281	0	case RAW_SFILEINFO_UNIX_LINK:
282	0	case RAW_SFILEINFO_UNIX_HLINK:
283	0	case RAW_SFILEINFO_RENAME_INFORMATION_SMB2:
284	0	case RAW_SFILEINFO_LINK_INFORMATION:
285	0	break;
286	0	}
287
288	0	return false;
289	0	}
290
291		/****************************************************************************
292		Very raw set file info - takes data blob (async send)
293		****************************************************************************/
294		static struct smbcli_request smb_raw_setfileinfo_blob_send(struct smbcli_tree tree,
295		TALLOC_CTX *mem_ctx,
296		uint16_t fnum,
297		uint16_t info_level,
298		DATA_BLOB *blob)
299	0	{
300	0	struct smb_trans2 tp;
301	0	uint16_t setup = TRANSACT2_SETFILEINFO;
302
303	0	tp.in.max_setup = 0;
304	0	tp.in.flags = 0;
305	0	tp.in.timeout = 0;
306	0	tp.in.setup_count = 1;
307	0	tp.in.max_param = 2;
308	0	tp.in.max_data = 0;
309	0	tp.in.setup = &setup;
310
311	0	tp.in.params = data_blob_talloc(mem_ctx, NULL, 6);
312	0	if (!tp.in.params.data) {
313	0	return NULL;
314	0	}
315	0	SSVAL(tp.in.params.data, 0, fnum);
316	0	SSVAL(tp.in.params.data, 2, info_level);
317	0	SSVAL(tp.in.params.data, 4, 0); /* reserved */
318
319	0	tp.in.data = *blob;
320
321	0	return smb_raw_trans2_send(tree, &tp);
322	0	}
323
324		/****************************************************************************
325		Very raw set path info - takes data blob
326		****************************************************************************/
327		static struct smbcli_request smb_raw_setpathinfo_blob_send(struct smbcli_tree tree,
328		TALLOC_CTX *mem_ctx,
329		const char *fname,
330		uint16_t info_level,
331		DATA_BLOB *blob)
332	0	{
333	0	struct smb_trans2 tp;
334	0	uint16_t setup = TRANSACT2_SETPATHINFO;
335
336	0	tp.in.max_setup = 0;
337	0	tp.in.flags = 0;
338	0	tp.in.timeout = 0;
339	0	tp.in.setup_count = 1;
340	0	tp.in.max_param = 2;
341	0	tp.in.max_data = 0;
342	0	tp.in.setup = &setup;
343
344	0	tp.in.params = data_blob_talloc(mem_ctx, NULL, 6);
345	0	if (!tp.in.params.data) {
346	0	return NULL;
347	0	}
348	0	SSVAL(tp.in.params.data, 0, info_level);
349	0	SIVAL(tp.in.params.data, 2, 0);
350	0	smbcli_blob_append_string(tree->session, mem_ctx,
351	0	&tp.in.params,
352	0	fname, STR_TERMINATE);
353
354	0	tp.in.data = *blob;
355
356	0	return smb_raw_trans2_send(tree, &tp);
357	0	}
358
359		/****************************************************************************
360		Handle setattr (async send)
361		****************************************************************************/
362		static struct smbcli_request smb_raw_setattr_send(struct smbcli_tree tree,
363		union smb_setfileinfo *parms)
364	0	{
365	0	struct smbcli_request *req;
366
367	0	req = smbcli_request_setup(tree, SMBsetatr, 8, 0);
368	0	if (!req) return NULL;
369
370	0	SSVAL(req->out.vwv, VWV(0), parms->setattr.in.attrib);
371	0	raw_push_dos_date3(tree->session->transport,
372	0	req->out.vwv, VWV(1), parms->setattr.in.write_time);
373	0	memset(req->out.vwv + VWV(3), 0, 10); /* reserved */
374	0	smbcli_req_append_ascii4(req, parms->setattr.in.file.path, STR_TERMINATE);
375	0	smbcli_req_append_ascii4(req, "", STR_TERMINATE);
376
377	0	if (!smbcli_request_send(req)) {
378	0	smbcli_request_destroy(req);
379	0	return NULL;
380	0	}
381
382	0	return req;
383	0	}
384
385		/****************************************************************************
386		Handle setattrE. (async send)
387		****************************************************************************/
388		static struct smbcli_request smb_raw_setattrE_send(struct smbcli_tree tree,
389		union smb_setfileinfo *parms)
390	0	{
391	0	struct smbcli_request *req;
392
393	0	req = smbcli_request_setup(tree, SMBsetattrE, 7, 0);
394	0	if (!req) return NULL;
395
396	0	SSVAL(req->out.vwv, VWV(0), parms->setattre.in.file.fnum);
397	0	raw_push_dos_date2(tree->session->transport,
398	0	req->out.vwv, VWV(1), parms->setattre.in.create_time);
399	0	raw_push_dos_date2(tree->session->transport,
400	0	req->out.vwv, VWV(3), parms->setattre.in.access_time);
401	0	raw_push_dos_date2(tree->session->transport,
402	0	req->out.vwv, VWV(5), parms->setattre.in.write_time);
403
404	0	if (!smbcli_request_send(req)) {
405	0	smbcli_request_destroy(req);
406	0	return NULL;
407	0	}
408
409	0	return req;
410	0	}
411
412		/****************************************************************************
413		Set file info (async send)
414		****************************************************************************/
415		struct smbcli_request smb_raw_setfileinfo_send(struct smbcli_tree tree,
416		union smb_setfileinfo *parms)
417	0	{
418	0	DATA_BLOB blob;
419	0	TALLOC_CTX *mem_ctx;
420	0	struct smbcli_request *req;
421
422	0	if (parms->generic.level == RAW_SFILEINFO_SETATTRE) {
423	0	return smb_raw_setattrE_send(tree, parms);
424	0	}
425	0	if (parms->generic.level == RAW_SFILEINFO_SEC_DESC) {
426	0	return smb_raw_set_secdesc_send(tree, parms);
427	0	}
428	0	if (parms->generic.level >= RAW_SFILEINFO_GENERIC) {
429	0	return NULL;
430	0	}
431
432	0	mem_ctx = talloc_init("setpathinfo");
433	0	if (!mem_ctx) return NULL;
434
435	0	if (!smb_raw_setinfo_backend(tree, mem_ctx, parms, &blob)) {
436	0	talloc_free(mem_ctx);
437	0	return NULL;
438	0	}
439
440		/* send request and process the output */
441	0	req = smb_raw_setfileinfo_blob_send(tree,
442	0	mem_ctx,
443	0	parms->generic.in.file.fnum,
444	0	parms->generic.level,
445	0	&blob);
446
447	0	talloc_free(mem_ctx);
448	0	return req;
449	0	}
450
451		/****************************************************************************
452		Set file info (async send)
453		****************************************************************************/
454		_PUBLIC_ NTSTATUS smb_raw_setfileinfo(struct smbcli_tree *tree,
455		union smb_setfileinfo *parms)
456	0	{
457	0	struct smbcli_request *req = smb_raw_setfileinfo_send(tree, parms);
458	0	return smbcli_request_simple_recv(req);
459	0	}
460
461
462		/****************************************************************************
463		Set path info (async send)
464		****************************************************************************/
465		_PUBLIC_ struct smbcli_request smb_raw_setpathinfo_send(struct smbcli_tree tree,
466		union smb_setfileinfo *parms)
467	0	{
468	0	DATA_BLOB blob;
469	0	TALLOC_CTX *mem_ctx;
470	0	struct smbcli_request *req;
471
472	0	if (parms->generic.level == RAW_SFILEINFO_SETATTR) {
473	0	return smb_raw_setattr_send(tree, parms);
474	0	}
475	0	if (parms->generic.level >= RAW_SFILEINFO_GENERIC) {
476	0	return NULL;
477	0	}
478
479	0	mem_ctx = talloc_init("setpathinfo");
480	0	if (!mem_ctx) return NULL;
481
482	0	if (!smb_raw_setinfo_backend(tree, mem_ctx, parms, &blob)) {
483	0	talloc_free(mem_ctx);
484	0	return NULL;
485	0	}
486
487		/* send request and process the output */
488	0	req = smb_raw_setpathinfo_blob_send(tree,
489	0	mem_ctx,
490	0	parms->generic.in.file.path,
491	0	parms->generic.level,
492	0	&blob);
493
494	0	talloc_free(mem_ctx);
495	0	return req;
496	0	}
497
498		/****************************************************************************
499		Set path info (sync interface)
500		****************************************************************************/
501		_PUBLIC_ NTSTATUS smb_raw_setpathinfo(struct smbcli_tree *tree,
502		union smb_setfileinfo *parms)
503	0	{
504	0	struct smbcli_request *req = smb_raw_setpathinfo_send(tree, parms);
505	0	return smbcli_request_simple_recv(req);
506	0	}