/* Test account expire time */
- if (!nt_time_is_zero(acct_expiry) && time(NULL) > nt_time_to_unix(acct_expiry)) {
+ if ((*acct_expiry) != 0 && time(NULL) > nt_time_to_unix(*acct_expiry)) {
DEBUG(1,("sam_account_ok: Account for user '%s' has expired.\n", username));
DEBUG(3,("sam_account_ok: Account expired at '%s'.\n",
- nt_time_string(mem_ctx, acct_expiry)));
+ nt_time_string(mem_ctx, *acct_expiry)));
return NT_STATUS_ACCOUNT_EXPIRED;
}
if (!(acct_flags & ACB_PWNOEXP)) {
/* check for immediate expiry "must change at next logon" */
- if (nt_time_is_zero(must_change_time) && !nt_time_is_zero(last_set_time)) {
+ if (*must_change_time == 0 && *last_set_time != 0) {
DEBUG(1,("sam_account_ok: Account for user '%s' password must change!.\n",
username));
return NT_STATUS_PASSWORD_MUST_CHANGE;
}
/* check for expired password */
- if (!nt_time_is_zero(must_change_time) && nt_time_to_unix(must_change_time) < time(NULL)) {
+ if ((*must_change_time) != 0 && nt_time_to_unix(*must_change_time) < time(NULL)) {
DEBUG(1,("sam_account_ok: Account for user '%s' password expired!.\n",
username));
DEBUG(1,("sam_account_ok: Password expired at '%s' unix time.\n",
- nt_time_string(mem_ctx, must_change_time)));
+ nt_time_string(mem_ctx, *must_change_time)));
return NT_STATUS_PASSWORD_EXPIRED;
}
}
AC_CHECK_TYPE(ssize_t, int)
AC_CHECK_TYPE(wchar_t, unsigned short)
AC_CHECK_TYPE(uint_t, unsigned int)
+AC_CHECK_TYPE(int64_t, long long)
+AC_CHECK_TYPE(uint64_t, unsigned long long)
############################################
# we need dlopen/dlclose/dlsym/dlerror for PAM, the password database plugins and the plugin loading code
{
my($type) = shift;
- if ($type =~ /uint\d+/) {
+ if ($type =~ /^u?int\d+/) {
return 1;
}
if ($type =~ /char|short|long|NTTIME|
static pstring fileselection = "";
/* timing globals */
-SMB_BIG_UINT get_total_size = 0;
+uint64_t get_total_size = 0;
unsigned int get_total_time_ms = 0;
-static SMB_BIG_UINT put_total_size = 0;
+static uint64_t put_total_size = 0;
static unsigned int put_total_time_ms = 0;
/* totals globals */
goto done;
}
- d_printf("\tcreate_time: %s\n", nt_time_string(mem_ctx, &finfo.all_info.out.create_time));
- d_printf("\taccess_time: %s\n", nt_time_string(mem_ctx, &finfo.all_info.out.access_time));
- d_printf("\twrite_time: %s\n", nt_time_string(mem_ctx, &finfo.all_info.out.write_time));
- d_printf("\tchange_time: %s\n", nt_time_string(mem_ctx, &finfo.all_info.out.change_time));
+ d_printf("\tcreate_time: %s\n", nt_time_string(mem_ctx, finfo.all_info.out.create_time));
+ d_printf("\taccess_time: %s\n", nt_time_string(mem_ctx, finfo.all_info.out.access_time));
+ d_printf("\twrite_time: %s\n", nt_time_string(mem_ctx, finfo.all_info.out.write_time));
+ d_printf("\tchange_time: %s\n", nt_time_string(mem_ctx, finfo.all_info.out.change_time));
d_printf("\tattrib: 0x%x\n", finfo.all_info.out.attrib);
d_printf("\talloc_size: %lu\n", (unsigned long)finfo.all_info.out.alloc_size);
d_printf("\tsize: %lu\n", (unsigned long)finfo.all_info.out.size);
struct file_info_struct
{
- SMB_BIG_UINT size;
+ uint64_t size;
uint16 mode;
uid_t uid;
gid_t gid;
static int blocksize=20;
static int tarhandle;
-static void writetarheader(int f, const char *aname, SMB_BIG_UINT size, time_t mtime,
+static void writetarheader(int f, const char *aname, uint64_t size, time_t mtime,
const char *amode, unsigned char ftype);
static void do_atar(char *rname,char *lname,file_info *finfo1);
static void do_tar(file_info *finfo);
-static void oct_it(SMB_BIG_UINT value, int ndgs, char *p);
+static void oct_it(uint64_t value, int ndgs, char *p);
static void fixtarname(char *tptr, const char *fp, int l);
static int dotarbuf(int f, char *b, int n);
static void dozerobuf(int f, int n);
/****************************************************************************
Write a tar header to buffer
****************************************************************************/
-static void writetarheader(int f, const char *aname, SMB_BIG_UINT size, time_t mtime,
+static void writetarheader(int f, const char *aname, uint64_t size, time_t mtime,
const char *amode, unsigned char ftype)
{
union hblock hb;
hb.dbuf.name[NAMSIZ-1]='\0';
safe_strcpy(hb.dbuf.mode, amode, strlen(amode));
- oct_it((SMB_BIG_UINT)0, 8, hb.dbuf.uid);
- oct_it((SMB_BIG_UINT)0, 8, hb.dbuf.gid);
- oct_it((SMB_BIG_UINT) size, 13, hb.dbuf.size);
- oct_it((SMB_BIG_UINT) mtime, 13, hb.dbuf.mtime);
+ oct_it((uint64_t)0, 8, hb.dbuf.uid);
+ oct_it((uint64_t)0, 8, hb.dbuf.gid);
+ oct_it((uint64_t) size, 13, hb.dbuf.size);
+ oct_it((uint64_t) mtime, 13, hb.dbuf.mtime);
memcpy(hb.dbuf.chksum, " ", sizeof(hb.dbuf.chksum));
memset(hb.dbuf.linkname, 0, NAMSIZ);
hb.dbuf.linkflag=ftype;
for (chk=0, i=sizeof(hb.dummy), jp=hb.dummy; --i>=0;) chk+=(0xFF & *jp++);
- oct_it((SMB_BIG_UINT) chk, 8, hb.dbuf.chksum);
+ oct_it((uint64_t) chk, 8, hb.dbuf.chksum);
hb.dbuf.chksum[6] = '\0';
(void) dotarbuf(f, hb.dummy, sizeof(hb.dummy));
/****************************************************************************
Convert from decimal to octal string
****************************************************************************/
-static void oct_it (SMB_BIG_UINT value, int ndgs, char *p)
+static void oct_it (uint64_t value, int ndgs, char *p)
{
/* Converts long to octal string, pads with leading zeros */
static void do_atar(char *rname,char *lname,file_info *finfo1)
{
int fnum;
- SMB_BIG_UINT nread=0;
+ uint64_t nread=0;
char ftype;
file_info2 finfo;
BOOL close_done = False;
/* macros for accessing SMB protocol elements */
#define VWV(vwv) ((vwv)*2)
+/* 64 bit macros */
+#define SBVAL(p, ofs, v) (SIVAL(p,ofs,(v)&0xFFFFFFFF), SIVAL(p,(ofs)+4,(v)>>32))
+#define BVAL(p, ofs) (IVAL(p,ofs) | (((uint64_t)IVAL(p,(ofs)+4)) << 32))
+
#endif /* _BYTEORDER_H */
typedef struct file_info
{
- SMB_BIG_UINT size;
+ uint64_t size;
uint16 mode;
uid_t uid;
gid_t gid;
unsigned chain_count;
/* the sequence number for signing */
- large_t seq_num;
+ uint64_t seq_num;
/* the async structure allows backend functions to delay
replying to requests. To use this, the front end must set
struct signing_context {
DATA_BLOB mac_key;
- large_t next_seq_num;
+ uint64_t next_seq_num;
enum smb_signing_state signing_state;
};
#endif
#endif
+#if !defined(uint64)
+#define uint64 uint64_t
+#endif
+
+#if !defined(int64)
+#define int64 int64_t
+#endif
+
/*
* Types for devices, inodes and offsets.
*/
# endif
#endif
-/* this should really be a 64 bit type if possible */
-#define br_off SMB_BIG_UINT
-
-#define SMB_OFF_T_BITS (sizeof(SMB_OFF_T)*8)
-
/*
* Set the define that tells us if we can do 64 bit
* NT SMB calls.
# endif
#endif
-#ifdef LARGE_SMB_OFF_T
-#define SOFF_T(p, ofs, v) (SIVAL(p,ofs,(v)&0xFFFFFFFF), SIVAL(p,(ofs)+4,(v)>>32))
-#define SOFF_T_R(p, ofs, v) (SIVAL(p,(ofs)+4,(v)&0xFFFFFFFF), SIVAL(p,ofs,(v)>>32))
-#define IVAL_TO_SMB_OFF_T(buf,off) ((SMB_OFF_T)(( ((SMB_BIG_UINT)(IVAL((buf),(off)))) & ((SMB_BIG_UINT)0xFFFFFFFF) )))
-#define IVAL2_TO_SMB_BIG_UINT(buf,off) ( (((SMB_BIG_UINT)(IVAL((buf),(off)))) & ((SMB_BIG_UINT)0xFFFFFFFF)) | \
- (( ((SMB_BIG_UINT)(IVAL((buf),(off+4)))) & ((SMB_BIG_UINT)0xFFFFFFFF) ) << 32 ) )
-#else
-#define SOFF_T(p, ofs, v) (SIVAL(p,ofs,v),SIVAL(p,(ofs)+4,0))
-#define SOFF_T_R(p, ofs, v) (SIVAL(p,(ofs)+4,v),SIVAL(p,ofs,0))
-#define IVAL_TO_SMB_OFF_T(buf,off) ((SMB_OFF_T)(( ((uint32)(IVAL((buf),(off)))) & 0xFFFFFFFF )))
-#define IVAL2_TO_SMB_BIG_UINT(buf,off) ( (((SMB_BIG_UINT)(IVAL((buf),(off)))) & ((SMB_BIG_UINT)0xFFFFFFFF)) | \
- (( ((SMB_BIG_UINT)(IVAL((buf),(off+4)))) & ((SMB_BIG_UINT)0xFFFFFFFF) ) << 32 ) )
-#endif
-
/*
* Type for stat structure.
*/
# endif
#endif
-#if defined(HAVE_LONGLONG)
-#define SMB_BIG_UINT unsigned long long
-#define SMB_BIG_INT long long
-#define SBVAL(p, ofs, v) (SIVAL(p,ofs,(v)&0xFFFFFFFF), SIVAL(p,(ofs)+4,(v)>>32))
-#define BVAL(p, ofs) (IVAL(p,ofs) | (((SMB_BIG_UINT)IVAL(p,(ofs)+4)) << 32))
-#else
-#define SMB_BIG_UINT unsigned long
-#define SMB_BIG_INT long
-#define SBVAL(p, ofs, v) (SIVAL(p,ofs,v),SIVAL(p,(ofs)+4,0))
-#define BVAL(p, ofs) IVAL(p,ofs)
-#endif
-
-#define SMB_BIG_UINT_BITS (sizeof(SMB_BIG_UINT)*8)
-
#ifndef MIN
#define MIN(a,b) ((a)<(b)?(a):(b))
#endif
time_t death_time; /* The time the record must be removed (do not remove if 0). */
time_t refresh_time; /* The time the record should be refreshed. */
- SMB_BIG_UINT id; /* unique id */
+ uint64_t id; /* unique id */
struct in_addr wins_ip; /* the adress of the wins server this record comes from */
int wins_flags; /* similar to the netbios flags but different ! */
char type;
int nb_flags;
int wins_flags;
- SMB_BIG_UINT id;
+ uint64_t id;
int num_ips;
struct in_addr ip[25];
struct in_addr wins_ip;
*/
-typedef SMB_BIG_UINT large_t;
-
/* Globally Unique ID */
#define GUID_SIZE 16
/* 64 bit time (100 nanosec) 1601 - cifs6.txt, section 3.5, page 30 */
-typedef struct nttime_info
-{
- uint32 low;
- uint32 high;
-} NTTIME;
+typedef uint64_t NTTIME;
/* 8 byte aligned 'hyper' type from MS IDL */
-typedef struct
-{
- uint32 low;
- uint32 high;
-} HYPER_T;
+typedef uint64_t HYPER_T;
NTTIME write_time;
NTTIME change_time;
uint32 ex_attrib;
- large_t alloc_size;
- large_t size;
+ uint64_t alloc_size;
+ uint64_t size;
uint32 nlink;
WIRE_STRING fname;
WIRE_STRING alt_fname;
uint8 delete_pending;
uint8 directory;
- large_t compressed_size;
+ uint64_t compressed_size;
uint16 format;
uint8 unit_shift;
uint8 chunk_shift;
uint8 cluster_shift;
- large_t file_id;
+ uint64_t file_id;
uint32 access_flags; /* seen 0x001f01ff from w2k3 */
- large_t position;
+ uint64_t position;
uint32 mode;
uint32 alignment_requirement;
uint32 reparse_tag;
uint_t num_streams;
struct stream_struct {
- large_t size;
- large_t alloc_size;
+ uint64_t size;
+ uint64_t alloc_size;
WIRE_STRING stream_name;
} *streams;
} out;
union smb_fileinfo_in in;
struct {
- large_t alloc_size;
- large_t size;
+ uint64_t alloc_size;
+ uint64_t size;
uint32 nlink;
BOOL delete_pending;
BOOL directory;
NTTIME write_time;
NTTIME change_time;
uint32 attrib;
- large_t alloc_size;
- large_t size;
+ uint64_t alloc_size;
+ uint64_t size;
uint32 nlink;
uint8 delete_pending;
uint8 directory;
union smb_fileinfo_in in;
struct {
- large_t compressed_size;
+ uint64_t compressed_size;
uint16 format;
uint8 unit_shift;
uint8 chunk_shift;
union smb_fileinfo_in in;
struct {
- large_t end_of_file;
- large_t num_bytes;
+ uint64_t end_of_file;
+ uint64_t num_bytes;
NTTIME status_change_time;
NTTIME access_time;
NTTIME change_time;
- large_t uid;
- large_t gid;
+ uint64_t uid;
+ uint64_t gid;
uint32 file_type;
- large_t dev_major;
- large_t dev_minor;
- large_t unique_id;
- large_t permissions;
- large_t nlink;
+ uint64_t dev_major;
+ uint64_t dev_minor;
+ uint64_t unique_id;
+ uint64_t permissions;
+ uint64_t nlink;
} out;
} unix_basic_info;
union smb_fileinfo_in in;
struct {
- large_t file_id;
+ uint64_t file_id;
} out;
} internal_information;
union smb_fileinfo_in in;
struct {
- large_t position;
+ uint64_t position;
} out;
} position_information;
NTTIME access_time;
NTTIME write_time;
NTTIME change_time;
- large_t alloc_size;
- large_t size;
+ uint64_t alloc_size;
+ uint64_t size;
uint32 attrib;
} out;
} network_open_information;
struct {
/* w2k3 rounds this up to nearest 4096 */
- large_t alloc_size;
+ uint64_t alloc_size;
} in;
} allocation_info;
union setfileinfo_file file;
struct {
- large_t size;
+ uint64_t size;
} in;
} end_of_file_info;
union setfileinfo_file file;
struct {
- large_t position;
+ uint64_t position;
} in;
} position_information;
union setfileinfo_file file;
struct {
uint32 mode; /* yuck - this field remains to fix compile of libcli/clifile.c */
- large_t end_of_file;
- large_t num_bytes;
+ uint64_t end_of_file;
+ uint64_t num_bytes;
NTTIME status_change_time;
NTTIME access_time;
NTTIME change_time;
- large_t uid;
- large_t gid;
+ uint64_t uid;
+ uint64_t gid;
uint32 file_type;
- large_t dev_major;
- large_t dev_minor;
- large_t unique_id;
- large_t permissions;
- large_t nlink;
+ uint64_t dev_major;
+ uint64_t dev_minor;
+ uint64_t unique_id;
+ uint64_t permissions;
+ uint64_t nlink;
} in;
} unix_basic;
struct {
uint32 block_size;
- large_t blocks_total;
- large_t blocks_free;
+ uint64_t blocks_total;
+ uint64_t blocks_free;
uint32 fs_id;
NTTIME create_time;
uint32 serial_number;
uint32 max_file_component_length;
uint32 device_type;
uint32 device_characteristics;
- large_t quota_soft;
- large_t quota_hard;
- large_t quota_flags;
+ uint64_t quota_soft;
+ uint64_t quota_hard;
+ uint64_t quota_flags;
struct GUID guid;
char *volume_name;
char *fs_type;
enum fsinfo_level level;
struct {
- large_t total_alloc_units;
- large_t avail_alloc_units; /* maps to call_avail_alloc_units */
+ uint64_t total_alloc_units;
+ uint64_t avail_alloc_units; /* maps to call_avail_alloc_units */
uint32 sectors_per_unit;
uint32 bytes_per_sector;
} out;
struct {
uint16 major_version;
uint16 minor_version;
- large_t capability;
+ uint64_t capability;
} out;
} unix_info;
enum fsinfo_level level;
struct {
- large_t unknown[3];
- large_t quota_soft;
- large_t quota_hard;
- large_t quota_flags;
+ uint64_t unknown[3];
+ uint64_t quota_soft;
+ uint64_t quota_hard;
+ uint64_t quota_flags;
} out;
} quota_information;
enum fsinfo_level level;
struct {
- large_t total_alloc_units;
- large_t call_avail_alloc_units;
- large_t actual_avail_alloc_units;
+ uint64_t total_alloc_units;
+ uint64_t call_avail_alloc_units;
+ uint64_t actual_avail_alloc_units;
uint32 sectors_per_unit;
uint32 bytes_per_sector;
} out;
struct {
struct GUID guid;
- large_t unknown[6];
+ uint64_t unknown[6];
} out;
} objectid_information;
};
uint32 flags;
uint32 root_fid;
uint32 access_mask;
- large_t alloc_size;
+ uint64_t alloc_size;
uint32 file_attr;
uint32 share_access;
uint32 open_disposition;
NTTIME write_time;
NTTIME change_time;
uint32 attrib;
- large_t alloc_size;
- large_t size;
+ uint64_t alloc_size;
+ uint64_t size;
uint16 file_type;
uint16 ipc_state;
uint8 is_directory;
struct {
uint16 fnum;
- SMB_BIG_UINT offset;
+ uint64_t offset;
uint32 size;
} in;
struct {
struct {
uint16 fnum;
- SMB_BIG_UINT offset;
+ uint64_t offset;
uint16 maxcnt;
uint16 mincnt;
uint32 timeout;
struct {
uint16 fnum;
- SMB_BIG_UINT offset;
+ uint64_t offset;
uint16 mincnt;
uint16 maxcnt;
uint16 remaining;
struct {
uint16 fnum;
- SMB_BIG_UINT offset;
+ uint64_t offset;
uint32 count;
const char *data;
} in;
struct {
uint16 fnum;
- SMB_BIG_UINT offset;
+ uint64_t offset;
uint16 wmode;
uint16 remaining;
uint32 count;
uint16 lock_cnt;
struct smb_lock_entry {
uint16 pid;
- SMB_BIG_UINT offset;
- SMB_BIG_UINT count;
+ uint64_t offset;
+ uint64_t count;
} *locks; /* unlocks are first in the arrray */
} in;
} lockx;
NTTIME access_time;
NTTIME write_time;
NTTIME change_time;
- large_t size;
- large_t alloc_size;
+ uint64_t size;
+ uint64_t alloc_size;
uint32 attrib;
WIRE_STRING name;
} directory_info;
NTTIME access_time;
NTTIME write_time;
NTTIME change_time;
- large_t size;
- large_t alloc_size;
+ uint64_t size;
+ uint64_t alloc_size;
uint32 attrib;
uint32 ea_size;
WIRE_STRING name;
NTTIME access_time;
NTTIME write_time;
NTTIME change_time;
- large_t size;
- large_t alloc_size;
+ uint64_t size;
+ uint64_t alloc_size;
uint32 attrib;
uint32 ea_size;
WIRE_STRING short_name;
NTTIME access_time;
NTTIME write_time;
NTTIME change_time;
- large_t size;
- large_t alloc_size;
+ uint64_t size;
+ uint64_t alloc_size;
uint32 attrib;
uint32 ea_size;
- large_t file_id;
+ uint64_t file_id;
WIRE_STRING name;
} id_full_directory_info;
NTTIME access_time;
NTTIME write_time;
NTTIME change_time;
- large_t size;
- large_t alloc_size;
+ uint64_t size;
+ uint64_t alloc_size;
uint32 attrib;
uint32 ea_size;
- large_t file_id;
+ uint64_t file_id;
WIRE_STRING short_name;
WIRE_STRING name;
} id_both_directory_info;
/* RAW_SEARCH_UNIX_INFO interface */
struct {
uint32 file_index;
- large_t size;
- large_t alloc_size;
+ uint64_t size;
+ uint64_t alloc_size;
NTTIME status_change_time;
NTTIME access_time;
NTTIME change_time;
- large_t uid;
- large_t gid;
+ uint64_t uid;
+ uint64_t gid;
uint32 file_type;
- large_t dev_major;
- large_t dev_minor;
- large_t unique_id;
- large_t permissions;
- large_t nlink;
+ uint64_t dev_major;
+ uint64_t dev_minor;
+ uint64_t unique_id;
+ uint64_t permissions;
+ uint64_t nlink;
const char *name;
} unix_info;
};
/* Return the number of TOSIZE-byte blocks used by
BLOCKS FROMSIZE-byte blocks, rounding away from zero.
*/
-static SMB_BIG_UINT adjust_blocks(SMB_BIG_UINT blocks, SMB_BIG_UINT fromsize, SMB_BIG_UINT tosize)
+static uint64_t adjust_blocks(uint64_t blocks, uint64_t fromsize, uint64_t tosize)
{
if (fromsize == tosize) /* e.g., from 512 to 512 */
return blocks;
results are returned in *dfree and *dsize, in 512 byte units
*/
-int sys_fsusage(const char *path, SMB_BIG_UINT *dfree, SMB_BIG_UINT *dsize)
+int sys_fsusage(const char *path, uint64_t *dfree, uint64_t *dsize)
{
#ifdef STAT_STATFS3_OSF1
-#define CONVERT_BLOCKS(B) adjust_blocks ((SMB_BIG_UINT)(B), (SMB_BIG_UINT)fsd.f_fsize, (SMB_BIG_UINT)512)
+#define CONVERT_BLOCKS(B) adjust_blocks ((uint64_t)(B), (uint64_t)fsd.f_fsize, (uint64_t)512)
struct statfs fsd;
if (statfs (path, &fsd, sizeof (struct statfs)) != 0)
#endif /* STAT_STATFS3_OSF1 */
#ifdef STAT_STATFS2_FS_DATA /* Ultrix */
-#define CONVERT_BLOCKS(B) adjust_blocks ((SMB_BIG_UINT)(B), (SMB_BIG_UINT)1024, (SMB_BIG_UINT)512)
+#define CONVERT_BLOCKS(B) adjust_blocks ((uint64_t)(B), (uint64_t)1024, (uint64_t)512)
struct fs_data fsd;
if (statfs (path, &fsd) != 1)
#endif /* STAT_STATFS2_FS_DATA */
#ifdef STAT_STATFS2_BSIZE /* 4.3BSD, SunOS 4, HP-UX, AIX */
-#define CONVERT_BLOCKS(B) adjust_blocks ((SMB_BIG_UINT)(B), (SMB_BIG_UINT)fsd.f_bsize, (SMB_BIG_UINT)512)
+#define CONVERT_BLOCKS(B) adjust_blocks ((uint64_t)(B), (uint64_t)fsd.f_bsize, (uint64_t)512)
struct statfs fsd;
if (statfs (path, &fsd) < 0)
#ifdef STAT_STATFS2_FSIZE /* 4.4BSD */
-#define CONVERT_BLOCKS(B) adjust_blocks ((SMB_BIG_UINT)(B), (SMB_BIG_UINT)fsd.f_fsize, (SMB_BIG_UINT)512)
+#define CONVERT_BLOCKS(B) adjust_blocks ((uint64_t)(B), (uint64_t)fsd.f_fsize, (uint64_t)512)
struct statfs fsd;
#ifdef STAT_STATFS4 /* SVR3, Dynix, Irix, AIX */
# if _AIX || defined(_CRAY)
-# define CONVERT_BLOCKS(B) adjust_blocks ((SMB_BIG_UINT)(B), (SMB_BIG_UINT)fsd.f_bsize, (SMB_BIG_UINT)512)
+# define CONVERT_BLOCKS(B) adjust_blocks ((uint64_t)(B), (uint64_t)fsd.f_bsize, (uint64_t)512)
# ifdef _CRAY
# define f_bavail f_bfree
# endif
# else
-# define CONVERT_BLOCKS(B) ((SMB_BIG_UINT)B)
+# define CONVERT_BLOCKS(B) ((uint64_t)B)
# ifndef _SEQUENT_ /* _SEQUENT_ is DYNIX/ptx */
# ifndef DOLPHIN /* DOLPHIN 3.8.alfa/7.18 has f_bavail */
# define f_bavail f_bfree
#if defined(STAT_STATVFS) || defined(STAT_STATVFS64) /* SVR4 */
# define CONVERT_BLOCKS(B) \
- adjust_blocks ((SMB_BIG_UINT)(B), fsd.f_frsize ? (SMB_BIG_UINT)fsd.f_frsize : (SMB_BIG_UINT)fsd.f_bsize, (SMB_BIG_UINT)512)
+ adjust_blocks ((uint64_t)(B), fsd.f_frsize ? (uint64_t)fsd.f_frsize : (uint64_t)fsd.f_bsize, (uint64_t)512)
#ifdef STAT_STATVFS64
struct statvfs64 fsd;
return strtoul(v->data, NULL, 0);
}
+int64_t ldb_msg_find_int64(const struct ldb_message *msg,
+ const char *attr_name,
+ int64_t default_value)
+{
+ const struct ldb_val *v = ldb_msg_find_ldb_val(msg, attr_name);
+ if (!v || !v->data) {
+ return default_value;
+ }
+ return strtoll(v->data, NULL, 0);
+}
+
+uint64_t ldb_msg_find_uint64(const struct ldb_message *msg,
+ const char *attr_name,
+ uint64_t default_value)
+{
+ const struct ldb_val *v = ldb_msg_find_ldb_val(msg, attr_name);
+ if (!v || !v->data) {
+ return default_value;
+ }
+ return strtoull(v->data, NULL, 0);
+}
+
double ldb_msg_find_double(const struct ldb_message *msg,
const char *attr_name,
double default_value)
#define REG_HANDLE_REGTYPE_NT 1
#define REG_HANDLE_REGTYPE_W9X 2
-#define TTTONTTIME(r, t1, t2) (r)->last_mod_time.low = (t1); \
- (r)->last_mod_time.high = (t2);
+#define TTTONTTIME(r, t1, t2) (r)->last_mod_time = (t1) | (((uint64_t)(t2)) << 32)
#define REGF_HDR_BLKSIZ 0x1000
#endif
}
-/*******************************************************************
- An fseek() wrapper that will deal with 64 bit filesizes.
-********************************************************************/
-
-int sys_fseek(FILE *fp, SMB_OFF_T offset, int whence)
-{
-#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(LARGE_SMB_OFF_T) && defined(HAVE_FSEEK64)
- return fseek64(fp, offset, whence);
-#elif defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(LARGE_SMB_OFF_T) && defined(HAVE_FSEEKO64)
- return fseeko64(fp, offset, whence);
-#else
- return fseek(fp, offset, whence);
-#endif
-}
-
-/*******************************************************************
- An ftell() wrapper that will deal with 64 bit filesizes.
-********************************************************************/
-
-SMB_OFF_T sys_ftell(FILE *fp)
-{
-#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(LARGE_SMB_OFF_T) && defined(HAVE_FTELL64)
- return (SMB_OFF_T)ftell64(fp);
-#elif defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(LARGE_SMB_OFF_T) && defined(HAVE_FTELLO64)
- return (SMB_OFF_T)ftello64(fp);
-#else
- return (SMB_OFF_T)ftell(fp);
-#endif
-}
-
/*******************************************************************
A creat() wrapper that will deal with 64 bit filesizes.
********************************************************************/
#include "includes.h"
#ifndef TIME_T_MIN
-#define TIME_T_MIN ((time_t)0 < (time_t) -1 ? (time_t) 0 \
- : ~ (time_t) 0 << (sizeof (time_t) * 8 - 1))
+#define TIME_T_MIN 0
#endif
#ifndef TIME_T_MAX
-#define TIME_T_MAX (~ (time_t) 0 - TIME_T_MIN)
+#define TIME_T_MAX (~(time_t)0)
#endif
/*******************************************************************
return tm_diff(&tm_utc,tm);
}
-#define TIME_FIXUP_CONSTANT (369.0*365.25*24*60*60-(3.0*24*60*60+6.0*60*60))
+#define TIME_FIXUP_CONSTANT 11644473600LL
/****************************************************************************
interpret an 8 byte "filetime" structure to a time_t
It's originally in "100ns units since jan 1st 1601"
****************************************************************************/
-time_t nt_time_to_unix(const NTTIME *nt)
+time_t nt_time_to_unix(NTTIME nt)
{
- double d;
- time_t ret;
+ nt += 1000*1000*10/2;
+ nt /= 1000*1000*10;
+ nt -= TIME_FIXUP_CONSTANT;
- if (nt->high == 0) {
+ if (TIME_T_MIN >= nt || nt >= TIME_T_MAX) {
return 0;
}
- d = ((double)nt->high)*4.0*(double)(1<<30);
- d += (nt->low&0xFFF00000);
- d *= 1.0e-7;
-
- /* now adjust by 369 years to make the secs since 1970 */
- d -= TIME_FIXUP_CONSTANT;
-
- if (TIME_T_MIN >= d || d >= TIME_T_MAX) {
- return 0;
- }
-
- ret = (time_t)(d+0.5);
-
- return ret;
+ return (time_t)nt;
}
****************************************************************************/
void unix_to_nt_time(NTTIME *nt, time_t t)
{
- double d;
+ uint64_t t2;
- if (t==0) {
- nt->low = 0;
- nt->high = 0;
- return;
- }
- if (t == TIME_T_MAX) {
- nt->low = 0xffffffff;
- nt->high = 0x7fffffff;
+ if (t == (time_t)-1) {
+ *nt = (NTTIME)-1LL;
return;
}
- if (t == -1) {
- nt->low = 0xffffffff;
- nt->high = 0xffffffff;
+ if (t == 0) {
+ *nt = 0;
return;
}
- d = (double)(t);
- d += TIME_FIXUP_CONSTANT;
- d *= 1.0e7;
+ t2 = t;
+ t2 += TIME_FIXUP_CONSTANT;
+ t2 *= 1000*1000*10;
- nt->high = (uint32)(d * (1.0/(4.0*(double)(1<<30))));
- nt->low = (uint32)(d - ((double)nt->high)*4.0*(double)(1<<30));
+ *nt = t2;
}
return TimeBuf;
}
-/****************************************************************************
-check if NTTIME is 0
-****************************************************************************/
-BOOL nt_time_is_zero(NTTIME *nt)
-{
- return (nt->high==0);
-}
-
/*
return a talloced string representing a NTTIME for human consumption
*/
-const char *nt_time_string(TALLOC_CTX *mem_ctx, const NTTIME *nt)
+const char *nt_time_string(TALLOC_CTX *mem_ctx, NTTIME nt)
{
time_t t = nt_time_to_unix(nt);
return talloc_strdup(mem_ctx, timestring(mem_ctx, t));
/*
put a NTTIME into a packet
*/
-void push_nttime(void *base, uint16 offset, NTTIME *t)
+void push_nttime(void *base, uint16 offset, NTTIME t)
{
- SIVAL(base, offset, t->low);
- SIVAL(base, offset+4, t->high);
+ SBVAL(base, offset, t);
}
/*
*/
NTTIME pull_nttime(void *base, uint16 offset)
{
- NTTIME ret;
- ret.low = IVAL(base, offset);
- ret.high = IVAL(base, offset+4);
- return ret;
-}
-
-/*
- convert a NTTIME to a double in 100-nano-seconds since 1601
-*/
-double nttime_to_double_nt(NTTIME t)
-{
- const double t32 = 4294967296.0;
- return t.high*t32 + t.low;
-}
-
-/*
- convert a double in 100-nano-seconds since 1601 to a NTTIME
-*/
-NTTIME nttime_from_double_nt(double t)
-{
- const double t32 = 4294967296.0;
- NTTIME ret;
- ret.high = t / t32;
- ret.low = t - (ret.high*t32);
+ NTTIME ret = BVAL(base, offset);
return ret;
}
*/
NTTIME nttime_from_string(const char *s)
{
- return nttime_from_double_nt(strtod(s, NULL));
+ return strtoull(s, NULL, 0);
}
ZERO_STRUCTP(finfo);
finfo->size = info->both_directory_info.size;
- finfo->ctime = nt_time_to_unix(&info->both_directory_info.create_time);
- finfo->atime = nt_time_to_unix(&info->both_directory_info.access_time);
- finfo->mtime = nt_time_to_unix(&info->both_directory_info.write_time);
+ finfo->ctime = nt_time_to_unix(info->both_directory_info.create_time);
+ finfo->atime = nt_time_to_unix(info->both_directory_info.access_time);
+ finfo->mtime = nt_time_to_unix(info->both_directory_info.write_time);
finfo->mode = info->both_directory_info.attrib; /* 32 bit->16 bit attrib */
if (info->both_directory_info.short_name.s) {
strncpy(finfo->short_name, info->both_directory_info.short_name.s,
return status;
if (c_time) {
- *c_time = nt_time_to_unix(&parms.all_info.out.create_time);
+ *c_time = nt_time_to_unix(parms.all_info.out.create_time);
}
if (a_time) {
- *a_time = nt_time_to_unix(&parms.all_info.out.access_time);
+ *a_time = nt_time_to_unix(parms.all_info.out.access_time);
}
if (m_time) {
- *m_time = nt_time_to_unix(&parms.all_info.out.change_time);
+ *m_time = nt_time_to_unix(parms.all_info.out.change_time);
}
if (w_time) {
- *w_time = nt_time_to_unix(&parms.all_info.out.write_time);
+ *w_time = nt_time_to_unix(parms.all_info.out.write_time);
}
if (size) {
*size = parms.all_info.out.size;
}
if (c_time) {
- *c_time = nt_time_to_unix(&parms.all_info.out.create_time);
+ *c_time = nt_time_to_unix(parms.all_info.out.create_time);
}
if (a_time) {
- *a_time = nt_time_to_unix(&parms.all_info.out.access_time);
+ *a_time = nt_time_to_unix(parms.all_info.out.access_time);
}
if (m_time) {
- *m_time = nt_time_to_unix(&parms.all_info.out.change_time);
+ *m_time = nt_time_to_unix(parms.all_info.out.change_time);
}
if (w_time) {
- *w_time = nt_time_to_unix(&parms.all_info.out.write_time);
+ *w_time = nt_time_to_unix(parms.all_info.out.write_time);
}
if (mode) {
*mode = parms.all_info.out.attrib;
asn1_start_tag(&data,ASN1_CONTEXT(0));
asn1_start_tag(&data,ASN1_SEQUENCE(0));
for (i=0; asn1_tag_remaining(&data) > 0 && i < ASN1_MAX_OIDS; i++) {
- char *oid = NULL;
- asn1_read_OID(&data,&oid);
- OIDs[i] = oid;
+ char *aoid = NULL;
+ asn1_read_OID(&data,&aoid);
+ OIDs[i] = aoid;
}
OIDs[i] = NULL;
asn1_end_tag(&data);
asn1_start_tag(&data, ASN1_CONTEXT(0));
asn1_start_tag(&data, ASN1_SEQUENCE(0));
for (i=0; asn1_tag_remaining(&data) > 0 && i < ASN1_MAX_OIDS; i++) {
- char *oid = NULL;
- asn1_read_OID(&data,&oid);
- OIDs[i] = oid;
+ char *aoid = NULL;
+ asn1_read_OID(&data,&aoid);
+ OIDs[i] = aoid;
}
OIDs[i] = NULL;
asn1_end_tag(&data);
/* this time arrives in real GMT */
ntt = cli_pull_nttime(req->in.vwv, VWV(11)+1);
- transport->negotiate.server_time = nt_time_to_unix(&ntt);
+ transport->negotiate.server_time = nt_time_to_unix(ntt);
transport->negotiate.capabilities = IVAL(req->in.vwv,VWV(9)+1);
transport->negotiate.secblob = cli_req_pull_blob(req, transport->mem_ctx, req->in.data, req->in.data_size);
/*
put a NTTIME into a packet
*/
-
-void cli_push_nttime(void *base, uint16 offset, NTTIME *t)
+void cli_push_nttime(void *base, uint16 offset, NTTIME t)
{
- SIVAL(base, offset, t->low);
- SIVAL(base, offset+4, t->high);
+ SBVAL(base, offset, t);
}
/*
*/
NTTIME cli_pull_nttime(void *base, uint16 offset)
{
- NTTIME ret;
- ret.low = IVAL(base, offset);
- ret.high = IVAL(base, offset+4);
+ NTTIME ret = BVAL(base, offset);
return ret;
}
case RAW_SFILEINFO_BASIC_INFO:
case RAW_SFILEINFO_BASIC_INFORMATION:
NEED_BLOB(40);
- cli_push_nttime(blob->data, 0, &parms->basic_info.in.create_time);
- cli_push_nttime(blob->data, 8, &parms->basic_info.in.access_time);
- cli_push_nttime(blob->data, 16, &parms->basic_info.in.write_time);
- cli_push_nttime(blob->data, 24, &parms->basic_info.in.change_time);
+ cli_push_nttime(blob->data, 0, parms->basic_info.in.create_time);
+ cli_push_nttime(blob->data, 8, parms->basic_info.in.access_time);
+ cli_push_nttime(blob->data, 16, parms->basic_info.in.write_time);
+ cli_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;
NEED_BLOB(92);
SBVAL(blob->data, 0, parms->unix_basic.in.end_of_file);
SBVAL(blob->data, 8, parms->unix_basic.in.num_bytes);
- cli_push_nttime(blob->data, 16, &parms->unix_basic.in.status_change_time);
- cli_push_nttime(blob->data, 24, &parms->unix_basic.in.access_time);
- cli_push_nttime(blob->data, 32, &parms->unix_basic.in.change_time);
+ cli_push_nttime(blob->data, 16, parms->unix_basic.in.status_change_time);
+ cli_push_nttime(blob->data, 24, parms->unix_basic.in.access_time);
+ cli_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);
BOOL asn1_read_OID(ASN1_DATA *data, char **OID)
{
uint8 b;
- pstring oid;
+ pstring aoid;
fstring el;
if (!asn1_start_tag(data, ASN1_OID)) return False;
asn1_read_uint8(data, &b);
- oid[0] = 0;
+ aoid[0] = 0;
snprintf(el, sizeof(el), "%u", b/40);
- pstrcat(oid, el);
+ pstrcat(aoid, el);
snprintf(el, sizeof(el), " %u", b%40);
- pstrcat(oid, el);
+ pstrcat(aoid, el);
while (asn1_tag_remaining(data) > 0) {
unsigned v = 0;
v = (v<<7) | (b&0x7f);
} while (!data->has_error && b & 0x80);
snprintf(el, sizeof(el), " %u", v);
- pstrcat(oid, el);
+ pstrcat(aoid, el);
}
asn1_end_tag(data);
- *OID = strdup(oid);
+ *OID = strdup(aoid);
return !data->has_error;
}
generate_random_buffer(client_chal, sizeof(client_chal), False);
- push_nttime(long_date, 0, &nttime);
+ push_nttime(long_date, 0, nttime);
/* See http://www.ubiqx.org/cifs/SMB.html#SMB.8.5 */
GUID uuid;
} policy_handle;
- /* a 4 byte aligned 64-bit integer */
- typedef [public] struct {
- uint32 low;
- uint32 high;
- } ULONG8;
-
/* this is also used in samr and netlogon */
typedef [public, flag(NDR_PAHEX)] struct {
uint16 units_per_week;
/* in netr_AcctLockStr size seems to be be 24, and rrenard thinks
that the structure of the bindata looks like this:
- ULONG8 lockout_duration;
- ULONG8 reset_count;
+ uint64 lockout_duration;
+ uint64 reset_count;
uint32 bad_attempt_lockout;
uint32 dummy;
NTTIME forcedlogoff;
uint16 minpasswdlen;
uint16 passwdhistorylen;
- ULONG8 pwd_must_change_time;
- ULONG8 pwd_can_change_time;
- ULONG8 sequence_num;
+ uint64 pwd_must_change_time;
+ uint64 pwd_can_change_time;
+ uint64 sequence_num;
NTTIME domain_create_time;
uint32 SecurityInformation;
sec_desc_buf sdbuf;
[case(NETR_DELTA_DELETE_SECRET)] netr_DELTA_DELETE_SECRET delete_secret;
[case(NETR_DELTA_DELETE_GROUP2)] netr_DELTA_DELETE_USER *delete_group;
[case(NETR_DELTA_DELETE_USER2)] netr_DELTA_DELETE_USER *delete_user;
- [case(NETR_DELTA_MODIFY_COUNT)] ULONG8 *modified_count;
+ [case(NETR_DELTA_MODIFY_COUNT)] uint64 *modified_count;
} netr_DELTA_UNION;
typedef union {
[in] netr_Authenticator credential,
[in,out] netr_Authenticator return_authenticator,
[in] uint32 database_id,
- [in,out] ULONG8 sequence_num,
+ [in,out] uint64 sequence_num,
[in] uint32 preferredmaximumlength,
[out] netr_DELTA_ENUM_ARRAY *delta_enum_array
);
uint16 min_pwd_len;
uint16 password_history;
uint32 password_properties;
- ULONG8 max_password_age;
- ULONG8 min_password_age;
+ /* yes, these are signed. They are in negative 100ns */
+ int64 max_password_age;
+ int64 min_password_age;
} samr_DomInfo1;
typedef struct {
- ULONG8 force_logoff_time;
+ uint64 force_logoff_time;
samr_Name comment;
samr_Name domain; /* domain name */
samr_Name primary; /* PDC name if this is a BDC */
} samr_DomInfo2;
typedef struct {
- ULONG8 force_logoff_time;
+ uint64 force_logoff_time;
} samr_DomInfo3;
typedef struct {
} samr_DomInfo9;
typedef struct {
- ULONG8 force_logoff_time;
+ uint64 force_logoff_time;
samr_Name comment;
samr_Name domain;
samr_Name primary;
/************************/
/* Function 0x3f */
+ const int SAMR_REJECT_OTHER = 0;
+ const int SAMR_REJECT_TOO_SHORT = 1;
+ const int SAMR_REJECT_COMPLEXITY = 2;
+
typedef struct {
+ uint32 reason;
uint32 unknown1;
uint32 unknown2;
- uint32 unknown3;
} samr_ChangeReject;
NTSTATUS samr_ChangePasswordUser3(
}
/*
- parse a HYPER_T
+ parse a uint64
*/
-NTSTATUS ndr_pull_HYPER_T(struct ndr_pull *ndr, HYPER_T *v)
+NTSTATUS ndr_pull_uint64(struct ndr_pull *ndr, uint64_t *v)
{
- NDR_PULL_ALIGN(ndr, 8);
+ NDR_PULL_ALIGN(ndr, 4);
NDR_PULL_NEED_BYTES(ndr, 8);
- v->low = NDR_IVAL(ndr, ndr->offset);
- v->high = NDR_IVAL(ndr, ndr->offset+4);
+ *v = NDR_IVAL(ndr, ndr->offset);
+ *v |= (uint64_t)(NDR_IVAL(ndr, ndr->offset+4)) << 32;
ndr->offset += 8;
return NT_STATUS_OK;
}
+/*
+ parse a int64
+*/
+NTSTATUS ndr_pull_int64(struct ndr_pull *ndr, int64_t *v)
+{
+ return ndr_pull_uint64(ndr, (uint64_t *)v);
+}
+
+/*
+ parse a HYPER_T
+*/
+NTSTATUS ndr_pull_HYPER_T(struct ndr_pull *ndr, HYPER_T *v)
+{
+ NDR_PULL_ALIGN(ndr, 8);
+ return ndr_pull_uint64(ndr, v);
+}
+
/*
pull a NTSTATUS
*/
}
/*
- push a HYPER_T
+ push a uint64
*/
-NTSTATUS ndr_push_HYPER_T(struct ndr_push *ndr, HYPER_T v)
+NTSTATUS ndr_push_uint64(struct ndr_push *ndr, uint64 v)
{
- NDR_PUSH_ALIGN(ndr, 8);
+ NDR_PUSH_ALIGN(ndr, 4);
NDR_PUSH_NEED_BYTES(ndr, 8);
- NDR_SIVAL(ndr, ndr->offset, v.low);
- NDR_SIVAL(ndr, ndr->offset+4, v.high);
+ NDR_SIVAL(ndr, ndr->offset, (v & 0xFFFFFFFF));
+ NDR_SIVAL(ndr, ndr->offset+4, (v>>32));
ndr->offset += 8;
return NT_STATUS_OK;
}
+/*
+ push a int64
+*/
+NTSTATUS ndr_push_int64(struct ndr_push *ndr, int64 v)
+{
+ return ndr_push_uint64(ndr, (uint64_t)v);
+}
+
+/*
+ push a HYPER_T
+*/
+NTSTATUS ndr_push_HYPER_T(struct ndr_push *ndr, HYPER_T v)
+{
+ NDR_PUSH_ALIGN(ndr, 8);
+ return ndr_push_uint64(ndr, v);
+}
+
NTSTATUS ndr_push_align(struct ndr_push *ndr, size_t size)
{
NDR_PUSH_ALIGN(ndr, size);
*/
NTSTATUS ndr_push_NTTIME(struct ndr_push *ndr, NTTIME t)
{
- NDR_CHECK(ndr_push_uint32(ndr, t.low));
- NDR_CHECK(ndr_push_uint32(ndr, t.high));
+ NDR_CHECK(ndr_push_uint64(ndr, t));
return NT_STATUS_OK;
}
*/
NTSTATUS ndr_pull_NTTIME(struct ndr_pull *ndr, NTTIME *t)
{
- NDR_CHECK(ndr_pull_uint32(ndr, &t->low));
- NDR_CHECK(ndr_pull_uint32(ndr, &t->high));
+ NDR_CHECK(ndr_pull_uint64(ndr, t));
return NT_STATUS_OK;
}
ndr->print(ndr, "%-25s: 0x%08x (%u)", name, v, v);
}
+void ndr_print_uint64(struct ndr_print *ndr, const char *name, uint64 v)
+{
+ ndr->print(ndr, "%-25s: 0x%08x%08x", name, (uint32)(v >> 32), (uint32)(v & 0xFFFFFFFF));
+}
+
+void ndr_print_int64(struct ndr_print *ndr, const char *name, int64 v)
+{
+ ndr->print(ndr, "%-25s: 0x%08x%08x (%lld)", name,
+ (uint32)(v >> 32),
+ (uint32)(v & 0xFFFFFFFF),
+ v);
+}
+
void ndr_print_HYPER_T(struct ndr_print *ndr, const char *name, HYPER_T v)
{
- ndr->print(ndr, "%-25s: 0x%08x%08x", name, v.high, v.low);
+ ndr->print(ndr, "%-25s: 0x%08x%08x", name, (uint32)(v >> 32), (uint32)(v & 0xFFFFFFFF));
}
void ndr_print_ptr(struct ndr_print *ndr, const char *name, const void *p)
void ndr_print_NTTIME(struct ndr_print *ndr, const char *name, NTTIME t)
{
- ndr->print(ndr, "%-25s: %s", name, nt_time_string(ndr->mem_ctx, &t));
+ ndr->print(ndr, "%-25s: %s", name, nt_time_string(ndr->mem_ctx, t));
}
void ndr_print_time_t(struct ndr_print *ndr, const char *name, time_t t)
ZERO_STRUCT(io->openx.out);
io->openx.out.fnum = io2.generic.out.fnum;
io->openx.out.attrib = io2.generic.out.attrib;
- io->openx.out.write_time = nt_time_to_unix(&io2.generic.out.write_time);
+ io->openx.out.write_time = nt_time_to_unix(io2.generic.out.write_time);
io->openx.out.size = io2.generic.out.size;
return NT_STATUS_OK;
ZERO_STRUCT(io->openx.out);
io->open.out.fnum = io2.generic.out.fnum;
io->open.out.attrib = io2.generic.out.attrib;
- io->open.out.write_time = nt_time_to_unix(&io2.generic.out.write_time);
+ io->open.out.write_time = nt_time_to_unix(io2.generic.out.write_time);
io->open.out.size = io2.generic.out.size;
io->open.out.rmode = DOS_OPEN_RDWR;
case RAW_FILEINFO_GETATTR:
info->getattr.out.attrib = info2->generic.out.attrib & 0xff;
info->getattr.out.size = info2->generic.out.size;
- info->getattr.out.write_time = nt_time_to_unix(&info2->generic.out.write_time);
+ info->getattr.out.write_time = nt_time_to_unix(info2->generic.out.write_time);
return NT_STATUS_OK;
case RAW_FILEINFO_GETATTRE:
info->getattre.out.attrib = info2->generic.out.attrib;
info->getattre.out.size = info2->generic.out.size;
- info->getattre.out.write_time = nt_time_to_unix(&info2->generic.out.write_time);
- info->getattre.out.create_time = nt_time_to_unix(&info2->generic.out.create_time);
- info->getattre.out.access_time = nt_time_to_unix(&info2->generic.out.access_time);
+ info->getattre.out.write_time = nt_time_to_unix(info2->generic.out.write_time);
+ info->getattre.out.create_time = nt_time_to_unix(info2->generic.out.create_time);
+ info->getattre.out.access_time = nt_time_to_unix(info2->generic.out.access_time);
info->getattre.out.alloc_size = info2->generic.out.alloc_size;
return NT_STATUS_OK;
return NT_STATUS_OK;
case RAW_FILEINFO_STANDARD:
- info->standard.out.create_time = nt_time_to_unix(&info2->generic.out.create_time);
- info->standard.out.access_time = nt_time_to_unix(&info2->generic.out.access_time);
- info->standard.out.write_time = nt_time_to_unix(&info2->generic.out.write_time);
+ info->standard.out.create_time = nt_time_to_unix(info2->generic.out.create_time);
+ info->standard.out.access_time = nt_time_to_unix(info2->generic.out.access_time);
+ info->standard.out.write_time = nt_time_to_unix(info2->generic.out.write_time);
info->standard.out.size = info2->generic.out.size;
info->standard.out.alloc_size = info2->generic.out.alloc_size;
info->standard.out.attrib = info2->generic.out.attrib;
return NT_STATUS_OK;
case RAW_FILEINFO_EA_SIZE:
- info->ea_size.out.create_time = nt_time_to_unix(&info2->generic.out.create_time);
- info->ea_size.out.access_time = nt_time_to_unix(&info2->generic.out.access_time);
- info->ea_size.out.write_time = nt_time_to_unix(&info2->generic.out.write_time);
+ info->ea_size.out.create_time = nt_time_to_unix(info2->generic.out.create_time);
+ info->ea_size.out.access_time = nt_time_to_unix(info2->generic.out.access_time);
+ info->ea_size.out.write_time = nt_time_to_unix(info2->generic.out.write_time);
info->ea_size.out.size = info2->generic.out.size;
info->ea_size.out.alloc_size = info2->generic.out.alloc_size;
info->ea_size.out.attrib = info2->generic.out.attrib;
/*
build a file_id from a stat struct
*/
-large_t svfs_file_id(struct stat *st)
+uint64_t svfs_file_id(struct stat *st)
{
- large_t ret = st->st_ino;
+ uint64_t ret = st->st_ino;
ret <<= 32;
ret |= st->st_dev;
return ret;
r->out.info->info3.v = 30;
break;
case 4:
- r->out.info->info4.v.low = 40;
- r->out.info->info4.v.high = 0;
+ r->out.info->info4.v = 40;
break;
case 5:
r->out.info->info5.v1 = 50;
- r->out.info->info5.v2.low = 60;
- r->out.info->info5.v2.high = 0;
+ r->out.info->info5.v2 = 60;
break;
case 6:
r->out.info->info6.v1 = 70;
break;
case 7:
r->out.info->info7.v1 = 80;
- r->out.info->info7.info4.v.low = 90;
- r->out.info->info7.info4.v.high = 0;
+ r->out.info->info7.info4.v = 90;
break;
default:
return NT_STATUS_INVALID_LEVEL;
msg_set_pw,
NULL, /* Don't have plaintext */
NULL, &newNtHash,
- False /* This is not considered a password change */);
+ False /* This is not considered a password change */,
+ NULL);
if (!NT_STATUS_IS_OK(nt_status)) {
samdb_close(sam_ctx);
/* the set password levels are handled separately */
case 24:
- status = samr_set_password(a_state->sam_ctx,
- dce_call,
+ status = samr_set_password(dce_call,
+ a_state->sam_ctx,
a_state->account_dn,
a_state->domain_state->domain_dn,
mem_ctx, msg,
return samdb_result_uint(res[0], attr_name, default_value);
}
+/*
+ search the sam for a single signed 64 bit integer attribute in exactly 1 record
+*/
+int64_t samdb_search_int64(void *ctx,
+ TALLOC_CTX *mem_ctx,
+ int64_t default_value,
+ const char *basedn,
+ const char *attr_name,
+ const char *format, ...)
+{
+ va_list ap;
+ int count;
+ struct ldb_message **res;
+ const char * const attrs[2] = { attr_name, NULL };
+
+ va_start(ap, format);
+ count = samdb_search_v(ctx, mem_ctx, basedn, &res, attrs, format, ap);
+ va_end(ap);
+
+ if (count != 1) {
+ return default_value;
+ }
+
+ return samdb_result_int64(res[0], attr_name, default_value);
+}
+
/*
search the sam for multipe records each giving a single string attribute
return the number of matches, or -1 on error
return ldb_msg_find_uint(msg, attr, default_value);
}
+/*
+ pull a (signed) int64 from a result set.
+*/
+int64_t samdb_result_int64(struct ldb_message *msg, const char *attr, int64_t default_value)
+{
+ return ldb_msg_find_int64(msg, attr, default_value);
+}
+
/*
pull a string from a result set.
*/
}
/*
- pull a double (really a large integer) from a result set.
+ pull a uint64_t from a result set.
*/
-double samdb_result_double(struct ldb_message *msg, const char *attr, double default_value)
+uint64_t samdb_result_uint64(struct ldb_message *msg, const char *attr, uint64_t default_value)
{
- return ldb_msg_find_double(msg, attr, default_value);
+ return ldb_msg_find_uint64(msg, attr, default_value);
}
NTTIME samdb_result_allow_pwd_change(void *ctx, TALLOC_CTX *mem_ctx,
const char *domain_dn, struct ldb_message *msg, const char *attr)
{
- double attr_time = samdb_result_double(msg, attr, 0);
- if (attr_time > 0) {
- const char *minPwdAge = samdb_search_string(ctx, mem_ctx, NULL, "minPwdAge",
- "dn=%s", domain_dn);
- if (minPwdAge) {
- /* yes, this is a -= not a += as minPwdAge is stored as the negative
- of the number of 100-nano-seconds */
- attr_time -= strtod(minPwdAge, NULL);
- }
+ uint64_t attr_time = samdb_result_uint64(msg, attr, 0);
+ int64_t minPwdAge;
+
+ if (attr_time == 0) {
+ return 0;
}
- return nttime_from_double_nt(attr_time);
+
+ minPwdAge = samdb_search_int64(ctx, mem_ctx, 0, "minPwdAge", "dn=%s", domain_dn);
+
+ /* yes, this is a -= not a += as minPwdAge is stored as the negative
+ of the number of 100-nano-seconds */
+ attr_time -= minPwdAge;
+
+ return attr_time;
}
/*
NTTIME samdb_result_force_pwd_change(void *ctx, TALLOC_CTX *mem_ctx,
const char *domain_dn, struct ldb_message *msg, const char *attr)
{
- double attr_time = samdb_result_double(msg, attr, 0);
- if (attr_time > 0) {
- const char *maxPwdAge = samdb_search_string(ctx, mem_ctx, NULL, "maxPwdAge",
- "dn=%s", domain_dn);
- if (!maxPwdAge || strcmp(maxPwdAge, "0") == 0) {
- attr_time = 0;
- } else {
- attr_time -= strtod(maxPwdAge, NULL);
- }
+ uint64_t attr_time = samdb_result_uint64(msg, attr, 0);
+ int64_t maxPwdAge;
+
+ if (attr_time == 0) {
+ return 0;
}
- return nttime_from_double_nt(attr_time);
+
+ maxPwdAge = samdb_search_int64(ctx, mem_ctx, 0, "maxPwdAge", "dn=%s", domain_dn);
+ if (maxPwdAge == 0) {
+ attr_time = 0;
+ } else {
+ attr_time -= maxPwdAge;
+ }
+
+ return attr_time;
}
/*
}
/*
- add a double element to a message (actually a large integer)
+ add a (signed) int64_t element to a message
+*/
+int samdb_msg_add_int64(void *ctx, TALLOC_CTX *mem_ctx, struct ldb_message *msg,
+ const char *attr_name, int64_t v)
+{
+ const char *s = talloc_asprintf(mem_ctx, "%lld", v);
+ return samdb_msg_add_string(ctx, mem_ctx, msg, attr_name, s);
+}
+
+/*
+ add a uint64_t element to a message
*/
-int samdb_msg_add_double(void *ctx, TALLOC_CTX *mem_ctx, struct ldb_message *msg,
- const char *attr_name, double v)
+int samdb_msg_add_uint64(void *ctx, TALLOC_CTX *mem_ctx, struct ldb_message *msg,
+ const char *attr_name, uint64_t v)
{
- const char *s = talloc_asprintf(mem_ctx, "%.0f", v);
+ const char *s = talloc_asprintf(mem_ctx, "%llu", v);
return samdb_msg_add_string(ctx, mem_ctx, msg, attr_name, s);
}
status = samdb_set_password(a_state->sam_ctx, mem_ctx,
a_state->account_dn, a_state->domain_state->domain_dn,
- &mod, NULL, &new_lmPwdHash, &new_ntPwdHash, True);
+ &mod, NULL, &new_lmPwdHash, &new_ntPwdHash,
+ True, NULL);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
user_dn, domain_dn,
&mod, new_pass,
NULL, NULL,
- True);
+ True, NULL);
if (!NT_STATUS_IS_OK(status)) {
samdb_close(sam_ctx);
return status;
/*
samr_ChangePasswordUser3
*/
-NTSTATUS samr_ChangePasswordUser3(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
+NTSTATUS samr_ChangePasswordUser3(struct dcesrv_call_state *dce_call,
+ TALLOC_CTX *mem_ctx,
struct samr_ChangePasswordUser3 *r)
-{
- DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
+{
+ NTSTATUS status;
+ char new_pass[512];
+ uint32 new_pass_len;
+ void *sam_ctx = NULL;
+ const char *user_dn, *domain_dn = NULL;
+ int ret;
+ struct ldb_message **res, mod;
+ const char * const attrs[] = { "objectSid", "ntPwdHash", NULL };
+ const char * const dom_attrs[] = { "minPwdLength", "pwdHistoryLength",
+ "pwdProperties", "minPwdAge", "maxPwdAge",
+ NULL };
+ const char *domain_sid;
+ struct samr_Hash *ntPwdHash;
+ struct samr_DomInfo1 *dominfo;
+ struct samr_ChangeReject *reject;
+ uint32 reason = 0;
+
+ ZERO_STRUCT(r->out);
+
+ if (r->in.nt_password == NULL ||
+ r->in.nt_verifier == NULL) {
+ status = NT_STATUS_INVALID_PARAMETER;
+ goto failed;
+ }
+
+ /* this call doesn't take a policy handle, so we need to open
+ the sam db from scratch */
+ sam_ctx = samdb_connect();
+ if (sam_ctx == NULL) {
+ status = NT_STATUS_INVALID_SYSTEM_SERVICE;
+ goto failed;
+ }
+
+ /* we need the users dn and the domain dn (derived from the
+ user SID). We also need the current lm and nt password hashes
+ in order to decrypt the incoming passwords */
+ ret = samdb_search(sam_ctx,
+ mem_ctx, NULL, &res, attrs,
+ "(&(sAMAccountName=%s)(objectclass=user))",
+ r->in.account->name);
+ if (ret != 1) {
+ status = NT_STATUS_NO_SUCH_USER;
+ goto failed;
+ }
+
+ user_dn = res[0]->dn;
+
+ ret = samdb_result_hashes(mem_ctx, res[0], "ntPwdHash", &ntPwdHash);
+ if (ret != 1) {
+ status = NT_STATUS_WRONG_PASSWORD;
+ goto failed;
+ }
+
+ /* decrypt the password we have been given */
+ SamOEMhash(r->in.nt_password->data, ntPwdHash->hash, 516);
+
+ if (!decode_pw_buffer(r->in.nt_password->data, new_pass, sizeof(new_pass),
+ &new_pass_len, STR_UNICODE)) {
+ DEBUG(3,("samr: failed to decode password buffer\n"));
+ status = NT_STATUS_WRONG_PASSWORD;
+ goto failed;
+ }
+
+ /* work out the domain dn */
+ domain_sid = samdb_result_sid_prefix(mem_ctx, res[0], "objectSid");
+ if (domain_sid == NULL) {
+ status = NT_STATUS_NO_SUCH_DOMAIN;
+ goto failed;
+ }
+
+ domain_dn = samdb_search_string(sam_ctx, mem_ctx, NULL, "dn",
+ "(objectSid=%s)", domain_sid);
+ if (!domain_dn) {
+ status = NT_STATUS_INTERNAL_DB_CORRUPTION;
+ goto failed;
+ }
+
+
+ ZERO_STRUCT(mod);
+ mod.dn = talloc_strdup(mem_ctx, user_dn);
+ if (!mod.dn) {
+ status = NT_STATUS_NO_MEMORY;
+ goto failed;
+ }
+
+ /* set the password - samdb needs to know both the domain and user DNs,
+ so the domain password policy can be used */
+ status = samdb_set_password(sam_ctx, mem_ctx,
+ user_dn, domain_dn,
+ &mod, new_pass,
+ NULL, NULL,
+ True, &reason);
+ if (!NT_STATUS_IS_OK(status)) {
+ goto failed;
+ }
+
+ /* modify the samdb record */
+ ret = samdb_replace(sam_ctx, mem_ctx, &mod);
+ if (ret != 0) {
+ status = NT_STATUS_UNSUCCESSFUL;
+ goto failed;
+ }
+
+ samdb_close(sam_ctx);
+ return NT_STATUS_OK;
+
+failed:
+ if (sam_ctx) {
+ samdb_close(sam_ctx);
+ }
+
+ /* on failure we need to fill in the reject reasons */
+ dominfo = talloc_p(mem_ctx, struct samr_DomInfo1);
+ if (dominfo == NULL) {
+ return NT_STATUS_NO_MEMORY;
+ }
+ reject = talloc_p(mem_ctx, struct samr_ChangeReject);
+ if (reject == NULL) {
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ ZERO_STRUCTP(dominfo);
+ ZERO_STRUCTP(reject);
+
+ reject->reason = reason;
+
+ r->out.dominfo = dominfo;
+ r->out.reject = reject;
+
+ if (!domain_dn) {
+ return status;
+ }
+
+ ret = samdb_search(sam_ctx,
+ mem_ctx, NULL, &res, dom_attrs,
+ "dn=%s", domain_dn);
+ if (ret != 1) {
+ status = NT_STATUS_NO_SUCH_USER;
+ goto failed;
+ }
+
+ dominfo->min_pwd_len = samdb_result_uint(res[0], "minPwdLength", 0);
+ dominfo->password_properties = samdb_result_uint(res[0], "pwdProperties", 0);
+ dominfo->password_history = samdb_result_uint(res[0], "pwdHistoryLength", 0);
+ dominfo->max_password_age = samdb_result_int64(res[0], "maxPwdAge", 0);
+ dominfo->min_password_age = samdb_result_int64(res[0], "minPwdAge", 0);
+
+ return status;
}
changes (as is needed by some of the set user info levels)
*/
NTSTATUS samdb_set_password(void *ctx, TALLOC_CTX *mem_ctx,
- const char *user_dn, const char *domain_dn,
- struct ldb_message *mod,
- const char *new_pass,
- struct samr_Hash *lmNewHash,
- struct samr_Hash *ntNewHash,
- BOOL user_change)
+ const char *user_dn, const char *domain_dn,
+ struct ldb_message *mod,
+ const char *new_pass,
+ struct samr_Hash *lmNewHash,
+ struct samr_Hash *ntNewHash,
+ BOOL user_change,
+ uint32 *reject_reason)
{
const char * const user_attrs[] = { "userAccountControl", "lmPwdHistory",
"ntPwdHistory", "unicodePwd",
"maxPwdAge", "minPwdAge",
"minPwdLength", "pwdLastSet", NULL };
const char *unicodePwd;
- double minPwdAge, pwdLastSet;
+ NTTIME pwdLastSet;
+ int64_t minPwdAge;
uint_t minPwdLength, pwdProperties, pwdHistoryLength;
uint_t userAccountControl, badPwdCount;
struct samr_Hash *lmPwdHistory, *ntPwdHistory, lmPwdHash, ntPwdHash;
int count;
time_t now = time(NULL);
NTTIME now_nt;
- double now_double;
int i;
/* we need to know the time to compute password age */
unix_to_nt_time(&now_nt, now);
- now_double = nttime_to_double_nt(now_nt);
/* pull all the user parameters */
count = samdb_search(ctx, mem_ctx, NULL, &res, user_attrs, "dn=%s", user_dn);
"ntPwdHistory", &ntPwdHistory);
lmPwdHash = samdb_result_hash(res[0], "lmPwdHash");
ntPwdHash = samdb_result_hash(res[0], "ntPwdHash");
- pwdLastSet = samdb_result_double(res[0], "pwdLastSet", 0);
+ pwdLastSet = samdb_result_uint64(res[0], "pwdLastSet", 0);
/* pull the domain parameters */
count = samdb_search(ctx, mem_ctx, NULL, &res, domain_attrs, "dn=%s", domain_dn);
pwdProperties = samdb_result_uint(res[0], "pwdProperties", 0);
pwdHistoryLength = samdb_result_uint(res[0], "pwdHistoryLength", 0);
minPwdLength = samdb_result_uint(res[0], "minPwdLength", 0);
- minPwdAge = samdb_result_double(res[0], "minPwdAge", 0);
+ minPwdAge = samdb_result_int64(res[0], "minPwdAge", 0);
if (new_pass) {
/* check the various password restrictions */
if (minPwdLength > str_charnum(new_pass)) {
+ if (reject_reason) {
+ *reject_reason = SAMR_REJECT_TOO_SHORT;
+ }
return NT_STATUS_PASSWORD_RESTRICTION;
}
/* possibly check password complexity */
if (pwdProperties & DOMAIN_PASSWORD_COMPLEX &&
!samdb_password_complexity_ok(new_pass)) {
+ if (reject_reason) {
+ *reject_reason = SAMR_REJECT_COMPLEXITY;
+ }
return NT_STATUS_PASSWORD_RESTRICTION;
}
if (user_change) {
/* are all password changes disallowed? */
if (pwdProperties & DOMAIN_REFUSE_PASSWORD_CHANGE) {
+ if (reject_reason) {
+ *reject_reason = SAMR_REJECT_OTHER;
+ }
return NT_STATUS_PASSWORD_RESTRICTION;
}
/* can this user change password? */
if (userAccountControl & UF_PASSWD_CANT_CHANGE) {
+ if (reject_reason) {
+ *reject_reason = SAMR_REJECT_OTHER;
+ }
return NT_STATUS_PASSWORD_RESTRICTION;
}
/* yes, this is a minus. The ages are in negative 100nsec units! */
- if (pwdLastSet - minPwdAge > now_double) {
+ if (pwdLastSet - minPwdAge > now_nt) {
+ if (reject_reason) {
+ *reject_reason = SAMR_REJECT_OTHER;
+ }
return NT_STATUS_PASSWORD_RESTRICTION;
}
/* check the immediately past password */
if (pwdHistoryLength > 0) {
if (lmNewHash && memcmp(lmNewHash->hash, lmPwdHash.hash, 16) == 0) {
+ if (reject_reason) {
+ *reject_reason = SAMR_REJECT_COMPLEXITY;
+ }
return NT_STATUS_PASSWORD_RESTRICTION;
}
if (ntNewHash && memcmp(ntNewHash->hash, ntPwdHash.hash, 16) == 0) {
+ if (reject_reason) {
+ *reject_reason = SAMR_REJECT_COMPLEXITY;
+ }
return NT_STATUS_PASSWORD_RESTRICTION;
}
}
if (pwdHistoryLength > 0) {
if (unicodePwd && new_pass && strcmp(unicodePwd, new_pass) == 0) {
+ if (reject_reason) {
+ *reject_reason = SAMR_REJECT_COMPLEXITY;
+ }
return NT_STATUS_PASSWORD_RESTRICTION;
}
if (lmNewHash && memcmp(lmNewHash->hash, lmPwdHash.hash, 16) == 0) {
+ if (reject_reason) {
+ *reject_reason = SAMR_REJECT_COMPLEXITY;
+ }
return NT_STATUS_PASSWORD_RESTRICTION;
}
if (ntNewHash && memcmp(ntNewHash->hash, ntPwdHash.hash, 16) == 0) {
+ if (reject_reason) {
+ *reject_reason = SAMR_REJECT_COMPLEXITY;
+ }
return NT_STATUS_PASSWORD_RESTRICTION;
}
}
for (i=0; lmNewHash && i<lmPwdHistory_len;i++) {
if (memcmp(lmNewHash->hash, lmPwdHistory[i].hash, 16) == 0) {
+ if (reject_reason) {
+ *reject_reason = SAMR_REJECT_COMPLEXITY;
+ }
return NT_STATUS_PASSWORD_RESTRICTION;
}
}
for (i=0; ntNewHash && i<ntPwdHistory_len;i++) {
if (memcmp(ntNewHash->hash, ntPwdHistory[i].hash, 16) == 0) {
+ if (reject_reason) {
+ *reject_reason = SAMR_REJECT_COMPLEXITY;
+ }
return NT_STATUS_PASSWORD_RESTRICTION;
}
}
CHECK_RET(samdb_msg_add_delete(ctx, mem_ctx, mod, "unicodePwd"));
}
- CHECK_RET(samdb_msg_add_double(ctx, mem_ctx, mod, "pwdLastSet", now_double));
+ CHECK_RET(samdb_msg_add_uint64(ctx, mem_ctx, mod, "pwdLastSet", now_nt));
if (pwdHistoryLength == 0) {
CHECK_RET(samdb_msg_add_delete(ctx, mem_ctx, mod, "lmPwdHistory"));
account_dn, domain_dn,
msg, new_pass,
NULL, NULL,
- False /* This is a password set, not change */);
+ False /* This is a password set, not change */,
+ NULL);
}
capabilities |= CAP_UNIX;
}
- if (lp_large_readwrite() && (SMB_OFF_T_BITS == 64)) {
+ if (lp_large_readwrite()) {
capabilities |= CAP_LARGE_READX | CAP_LARGE_WRITEX | CAP_W2K_SMBS;
}
- if (SMB_OFF_T_BITS >= 64) {
- capabilities |= CAP_LARGE_FILES;
- }
+ capabilities |= CAP_LARGE_FILES;
if (lp_readraw() && lp_writeraw()) {
capabilities |= CAP_RAW_MODE;
SIVAL(req->out.vwv+1, VWV(5), 0x10000); /* raw size. full 64k */
SIVAL(req->out.vwv+1, VWV(7), req->smb->pid); /* session key */
SIVAL(req->out.vwv+1, VWV(9), capabilities);
- push_nttime(req->out.vwv+1, VWV(11), &nttime);
+ push_nttime(req->out.vwv+1, VWV(11), nttime);
SSVALS(req->out.vwv+1,VWV(15), req->smb->negotiate.zone_offset/60);
if (!negotiate_spnego) {
/* the 64 bit varient */
if (req->in.wct == 10) {
uint32 offset_high = IVAL(req->in.vwv, VWV(8));
-#ifdef LARGE_SMB_OFF_T
io.readbraw.in.offset |= (((SMB_OFF_T)offset_high) << 32);
-#else
- if (offset_high != 0) {
- goto failed;
- }
-#endif
}
/* before calling the backend we setup the raw buffer. This
/* the 64 bit varient */
if (req->in.wct == 12) {
uint32 offset_high = IVAL(req->in.vwv, VWV(10));
-#ifdef LARGE_SMB_OFF_T
- io->readx.in.offset |= (((SMB_OFF_T)offset_high) << 32);
-#else
- if (offset_high != 0) {
- req_reply_error(req, NT_STATUS_FOOBAR);
- return;
- }
-#endif
+ io->readx.in.offset |= (((uint64_t)offset_high) << 32);
}
/* setup the reply packet assuming the maximum possible read */
if (req->in.wct == 14) {
uint32 offset_high = IVAL(req->in.vwv, VWV(12));
uint16 count_high = SVAL(req->in.vwv, VWV(9));
-#ifdef LARGE_SMB_OFF_T
- io->writex.in.offset |= (((SMB_OFF_T)offset_high) << 32);
-#else
- if (offset_high != 0) {
- req_reply_error(req, NT_STATUS_FOOBAR);
- return;
- }
-#endif
+ io->writex.in.offset |= (((uint64_t)offset_high) << 32);
io->writex.in.count |= ((uint32)count_high) << 16;
}
lck->lockx.in.locks[i].count = IVAL(p, 6);
}
if (ofs_high != 0 || count_high != 0) {
-#ifdef LARGE_SMB_OFF_T
- lck->lockx.in.locks[i].count |= ((SMB_OFF_T)count_high) << 32;
- lck->lockx.in.locks[i].offset |= ((SMB_OFF_T)ofs_high) << 32;
-#else
- req_reply_error(req, NT_STATUS_FOOBAR);
- return;
-#endif
+ lck->lockx.in.locks[i].count |= ((uint64_t)count_high) << 32;
+ lck->lockx.in.locks[i].offset |= ((uint64_t)ofs_high) << 32;
}
p += lck_size;
}
/* the rest of the parameters are not aligned! */
SSVAL(req->out.vwv, 5, io->ntcreatex.out.fnum);
SIVAL(req->out.vwv, 7, io->ntcreatex.out.create_action);
- push_nttime(req->out.vwv, 11, &io->ntcreatex.out.create_time);
- push_nttime(req->out.vwv, 19, &io->ntcreatex.out.access_time);
- push_nttime(req->out.vwv, 27, &io->ntcreatex.out.write_time);
- push_nttime(req->out.vwv, 35, &io->ntcreatex.out.change_time);
+ push_nttime(req->out.vwv, 11, io->ntcreatex.out.create_time);
+ push_nttime(req->out.vwv, 19, io->ntcreatex.out.access_time);
+ push_nttime(req->out.vwv, 27, io->ntcreatex.out.write_time);
+ push_nttime(req->out.vwv, 35, io->ntcreatex.out.change_time);
SIVAL(req->out.vwv, 43, io->ntcreatex.out.attrib);
SBVAL(req->out.vwv, 47, io->ntcreatex.out.alloc_size);
SBVAL(req->out.vwv, 55, io->ntcreatex.out.size);
trans2_setup_reply(req, trans, 0, 18, 0);
- push_nttime(trans->out.data.data, 0, &fsinfo.volume_info.out.create_time);
+ push_nttime(trans->out.data.data, 0, fsinfo.volume_info.out.create_time);
SIVAL(trans->out.data.data, 8, fsinfo.volume_info.out.serial_number);
trans2_append_data_string(req, trans,
&fsinfo.volume_info.out.volume_name,
trans2_setup_reply(req, trans, 2, 40, 0);
SSVAL(trans->out.params.data, 0, 0);
- push_nttime(trans->out.data.data, 0, &st->basic_info.out.create_time);
- push_nttime(trans->out.data.data, 8, &st->basic_info.out.access_time);
- push_nttime(trans->out.data.data, 16, &st->basic_info.out.write_time);
- push_nttime(trans->out.data.data, 24, &st->basic_info.out.change_time);
+ push_nttime(trans->out.data.data, 0, st->basic_info.out.create_time);
+ push_nttime(trans->out.data.data, 8, st->basic_info.out.access_time);
+ push_nttime(trans->out.data.data, 16, st->basic_info.out.write_time);
+ push_nttime(trans->out.data.data, 24, st->basic_info.out.change_time);
SIVAL(trans->out.data.data, 32, st->basic_info.out.attrib);
SIVAL(trans->out.data.data, 36, 0); /* padding */
return NT_STATUS_OK;
trans2_setup_reply(req, trans, 2, 56, 0);
SSVAL(trans->out.params.data, 0, 0);
- push_nttime(trans->out.data.data, 0, &st->network_open_information.out.create_time);
- push_nttime(trans->out.data.data, 8, &st->network_open_information.out.access_time);
- push_nttime(trans->out.data.data, 16, &st->network_open_information.out.write_time);
- push_nttime(trans->out.data.data, 24, &st->network_open_information.out.change_time);
+ push_nttime(trans->out.data.data, 0, st->network_open_information.out.create_time);
+ push_nttime(trans->out.data.data, 8, st->network_open_information.out.access_time);
+ push_nttime(trans->out.data.data, 16, st->network_open_information.out.write_time);
+ push_nttime(trans->out.data.data, 24, st->network_open_information.out.change_time);
SBVAL(trans->out.data.data, 32, st->network_open_information.out.alloc_size);
SBVAL(trans->out.data.data, 40, st->network_open_information.out.size);
SIVAL(trans->out.data.data, 48, st->network_open_information.out.attrib);
trans2_setup_reply(req, trans, 2, 72, 0);
SSVAL(trans->out.params.data, 0, 0);
- push_nttime(trans->out.data.data, 0, &st->all_info.out.create_time);
- push_nttime(trans->out.data.data, 8, &st->all_info.out.access_time);
- push_nttime(trans->out.data.data, 16, &st->all_info.out.write_time);
- push_nttime(trans->out.data.data, 24, &st->all_info.out.change_time);
+ push_nttime(trans->out.data.data, 0, st->all_info.out.create_time);
+ push_nttime(trans->out.data.data, 8, st->all_info.out.access_time);
+ push_nttime(trans->out.data.data, 16, st->all_info.out.write_time);
+ push_nttime(trans->out.data.data, 24, st->all_info.out.change_time);
SIVAL(trans->out.data.data, 32, st->all_info.out.attrib);
SBVAL(trans->out.data.data, 40, st->all_info.out.alloc_size);
SBVAL(trans->out.data.data, 48, st->all_info.out.size);
trans2_grow_data(req, trans, ofs + 64);
data = trans->out.data.data + ofs;
SIVAL(data, 4, file->directory_info.file_index);
- push_nttime(data, 8, &file->directory_info.create_time);
- push_nttime(data, 16, &file->directory_info.access_time);
- push_nttime(data, 24, &file->directory_info.write_time);
- push_nttime(data, 32, &file->directory_info.change_time);
+ push_nttime(data, 8, file->directory_info.create_time);
+ push_nttime(data, 16, file->directory_info.access_time);
+ push_nttime(data, 24, file->directory_info.write_time);
+ push_nttime(data, 32, file->directory_info.change_time);
SBVAL(data, 40, file->directory_info.size);
SBVAL(data, 48, file->directory_info.alloc_size);
SIVAL(data, 56, file->directory_info.attrib);
trans2_grow_data(req, trans, ofs + 68);
data = trans->out.data.data + ofs;
SIVAL(data, 4, file->full_directory_info.file_index);
- push_nttime(data, 8, &file->full_directory_info.create_time);
- push_nttime(data, 16, &file->full_directory_info.access_time);
- push_nttime(data, 24, &file->full_directory_info.write_time);
- push_nttime(data, 32, &file->full_directory_info.change_time);
+ push_nttime(data, 8, file->full_directory_info.create_time);
+ push_nttime(data, 16, file->full_directory_info.access_time);
+ push_nttime(data, 24, file->full_directory_info.write_time);
+ push_nttime(data, 32, file->full_directory_info.change_time);
SBVAL(data, 40, file->full_directory_info.size);
SBVAL(data, 48, file->full_directory_info.alloc_size);
SIVAL(data, 56, file->full_directory_info.attrib);
trans2_grow_data(req, trans, ofs + 94);
data = trans->out.data.data + ofs;
SIVAL(data, 4, file->both_directory_info.file_index);
- push_nttime(data, 8, &file->both_directory_info.create_time);
- push_nttime(data, 16, &file->both_directory_info.access_time);
- push_nttime(data, 24, &file->both_directory_info.write_time);
- push_nttime(data, 32, &file->both_directory_info.change_time);
+ push_nttime(data, 8, file->both_directory_info.create_time);
+ push_nttime(data, 16, file->both_directory_info.access_time);
+ push_nttime(data, 24, file->both_directory_info.write_time);
+ push_nttime(data, 32, file->both_directory_info.change_time);
SBVAL(data, 40, file->both_directory_info.size);
SBVAL(data, 48, file->both_directory_info.alloc_size);
SIVAL(data, 56, file->both_directory_info.attrib);
trans2_grow_data(req, trans, ofs + 80);
data = trans->out.data.data + ofs;
SIVAL(data, 4, file->id_full_directory_info.file_index);
- push_nttime(data, 8, &file->id_full_directory_info.create_time);
- push_nttime(data, 16, &file->id_full_directory_info.access_time);
- push_nttime(data, 24, &file->id_full_directory_info.write_time);
- push_nttime(data, 32, &file->id_full_directory_info.change_time);
+ push_nttime(data, 8, file->id_full_directory_info.create_time);
+ push_nttime(data, 16, file->id_full_directory_info.access_time);
+ push_nttime(data, 24, file->id_full_directory_info.write_time);
+ push_nttime(data, 32, file->id_full_directory_info.change_time);
SBVAL(data, 40, file->id_full_directory_info.size);
SBVAL(data, 48, file->id_full_directory_info.alloc_size);
SIVAL(data, 56, file->id_full_directory_info.attrib);
trans2_grow_data(req, trans, ofs + 104);
data = trans->out.data.data + ofs;
SIVAL(data, 4, file->id_both_directory_info.file_index);
- push_nttime(data, 8, &file->id_both_directory_info.create_time);
- push_nttime(data, 16, &file->id_both_directory_info.access_time);
- push_nttime(data, 24, &file->id_both_directory_info.write_time);
- push_nttime(data, 32, &file->id_both_directory_info.change_time);
+ push_nttime(data, 8, file->id_both_directory_info.create_time);
+ push_nttime(data, 16, file->id_both_directory_info.access_time);
+ push_nttime(data, 24, file->id_both_directory_info.write_time);
+ push_nttime(data, 32, file->id_both_directory_info.change_time);
SBVAL(data, 40, file->id_both_directory_info.size);
SBVAL(data, 48, file->id_both_directory_info.alloc_size);
SIVAL(data, 56, file->id_both_directory_info.attrib);
} while(0)
#define CHECK_NTTIMES_EQUAL(field) do { \
- if (ABS(nt_time_to_unix(&parm[0].field) - \
- nt_time_to_unix(&parm[1].field)) > time_skew() && \
+ if (ABS(nt_time_to_unix(parm[0].field) - \
+ nt_time_to_unix(parm[1].field)) > time_skew() && \
!ignore_pattern(#field)) { \
printf("Mismatch in %s - 0x%x 0x%x\n", #field, \
- (int)nt_time_to_unix(&parm[0].field), \
- (int)nt_time_to_unix(&parm[1].field)); \
+ (int)nt_time_to_unix(parm[0].field), \
+ (int)nt_time_to_unix(parm[1].field)); \
return False; \
} \
} while(0)
enum lock_op lock_op;
enum brl_type lock_type;
char conn, f;
- SMB_BIG_UINT start, len;
+ uint64_t start, len;
char needed;
};
{
unsigned conn = rec->conn;
unsigned f = rec->f;
- SMB_BIG_UINT start = rec->start;
- SMB_BIG_UINT len = rec->len;
+ uint64_t start = rec->start;
+ uint64_t len = rec->len;
enum brl_type op = rec->lock_type;
int server;
BOOL ret[NSERVERS];
status = smb_raw_pathinfo(cli->tree, mem_ctx, &finfo);
CHECK_STATUS(status, NT_STATUS_OK);
- if (basetime != nt_time_to_unix(&finfo.all_info.out.write_time)) {
+ if (basetime != nt_time_to_unix(finfo.all_info.out.write_time)) {
printf("Incorrect write time on file - %s - %s\n",
timestring(mem_ctx, basetime),
- nt_time_string(mem_ctx, &finfo.all_info.out.write_time));
+ nt_time_string(mem_ctx, finfo.all_info.out.write_time));
dump_all_info(mem_ctx, &finfo);
ret = False;
}
status = smb_raw_pathinfo(cli->tree, mem_ctx, &finfo); \
CHECK_STATUS(status, NT_STATUS_OK); \
t1 = t & ~1; \
- t2 = nt_time_to_unix(&finfo.all_info.out.field) & ~1; \
+ t2 = nt_time_to_unix(finfo.all_info.out.field) & ~1; \
if (ABS(t1-t2) > 2) { \
printf("(%d) wrong time for field %s %s - %s\n", \
__LINE__, #field, \
status = smb_raw_pathinfo(cli->tree, mem_ctx, &finfo); \
CHECK_STATUS(status, NT_STATUS_OK); \
t2 = finfo.all_info.out.field; \
- if (!nt_time_equal(&t, &t2)) { \
+ if (t != t2) { \
printf("(%d) wrong time for field %s %s - %s\n", \
__LINE__, #field, \
- nt_time_string(mem_ctx, &t), \
- nt_time_string(mem_ctx, &t2)); \
+ nt_time_string(mem_ctx, t), \
+ nt_time_string(mem_ctx, t2)); \
dump_all_info(mem_ctx, &finfo); \
ret = False; \
}} while (0)
/*
compare a dos time (2 second resolution) to a nt time
*/
-static int dos_nt_time_cmp(time_t t, const NTTIME *nt)
+static int dos_nt_time_cmp(time_t t, NTTIME nt)
{
time_t t2 = nt_time_to_unix(nt);
if (ABS(t2 - t) <= 2) return 0;
int fnum;
const char *fname = "\\torture_qfileinfo.txt";
NTTIME correct_time;
- large_t correct_size;
+ uint64_t correct_size;
uint32 correct_attrib;
const char *correct_name;
BOOL skip_streams = False;
s1 = fnum_find(sname); \
if (s1 && memcmp(&s1->stype.out.tfield, &correct_time, sizeof(correct_time)) != 0) { \
printf("(%d) handle %s/%s incorrect - %s should be %s\n", __LINE__, #stype, #tfield, \
- nt_time_string(mem_ctx, &s1->stype.out.tfield), \
- nt_time_string(mem_ctx, &correct_time)); \
+ nt_time_string(mem_ctx, s1->stype.out.tfield), \
+ nt_time_string(mem_ctx, correct_time)); \
ret = False; \
} \
s1 = fname_find(sname); \
if (s1 && memcmp(&s1->stype.out.tfield, &correct_time, sizeof(correct_time)) != 0) { \
printf("(%d) path %s/%s incorrect - %s should be %s\n", __LINE__, #stype, #tfield, \
- nt_time_string(mem_ctx, &s1->stype.out.tfield), \
- nt_time_string(mem_ctx, &correct_time)); \
+ nt_time_string(mem_ctx, s1->stype.out.tfield), \
+ nt_time_string(mem_ctx, correct_time)); \
ret = False; \
}} while (0)
#define TIME_CHECK_DOS(sname, stype, tfield) do { \
s1 = fnum_find(sname); \
- if (s1 && dos_nt_time_cmp(s1->stype.out.tfield, &correct_time) != 0) { \
+ if (s1 && dos_nt_time_cmp(s1->stype.out.tfield, correct_time) != 0) { \
printf("(%d) handle %s/%s incorrect - %s should be %s\n", __LINE__, #stype, #tfield, \
timestring(mem_ctx, s1->stype.out.tfield), \
- nt_time_string(mem_ctx, &correct_time)); \
+ nt_time_string(mem_ctx, correct_time)); \
ret = False; \
} \
s1 = fname_find(sname); \
- if (s1 && dos_nt_time_cmp(s1->stype.out.tfield, &correct_time) != 0) { \
+ if (s1 && dos_nt_time_cmp(s1->stype.out.tfield, correct_time) != 0) { \
printf("(%d) path %s/%s incorrect - %s should be %s\n", __LINE__, #stype, #tfield, \
timestring(mem_ctx, s1->stype.out.tfield), \
- nt_time_string(mem_ctx, &correct_time)); \
+ nt_time_string(mem_ctx, correct_time)); \
ret = False; \
}} while (0)
#define TIME_CHECK_UNX(sname, stype, tfield) do { \
s1 = fnum_find(sname); \
- if (s1 && unx_nt_time_cmp(s1->stype.out.tfield, &correct_time) != 0) { \
+ if (s1 && unx_nt_time_cmp(s1->stype.out.tfield, correct_time) != 0) { \
printf("(%d) handle %s/%s incorrect - %s should be %s\n", __LINE__, #stype, #tfield, \
timestring(mem_ctx, s1->stype.out.tfield), \
- nt_time_string(mem_ctx, &correct_time)); \
+ nt_time_string(mem_ctx, correct_time)); \
ret = False; \
} \
s1 = fname_find(sname); \
- if (s1 && unx_nt_time_cmp(s1->stype.out.tfield, &correct_time) != 0) { \
+ if (s1 && unx_nt_time_cmp(s1->stype.out.tfield, correct_time) != 0) { \
printf("(%d) path %s/%s incorrect - %s should be %s\n", __LINE__, #stype, #tfield, \
timestring(mem_ctx, s1->stype.out.tfield), \
- nt_time_string(mem_ctx, &correct_time)); \
+ nt_time_string(mem_ctx, correct_time)); \
ret = False; \
}} while (0)
/* now check that all the times that are supposed to be equal are correct */
s1 = fnum_find("BASIC_INFO");
correct_time = s1->basic_info.out.create_time;
- printf("create_time: %s\n", nt_time_string(mem_ctx, &correct_time));
+ printf("create_time: %s\n", nt_time_string(mem_ctx, correct_time));
TIME_CHECK_NT ("BASIC_INFO", basic_info, create_time);
TIME_CHECK_NT ("BASIC_INFORMATION", basic_info, create_time);
s1 = fnum_find("BASIC_INFO");
correct_time = s1->basic_info.out.access_time;
- printf("access_time: %s\n", nt_time_string(mem_ctx, &correct_time));
+ printf("access_time: %s\n", nt_time_string(mem_ctx, correct_time));
TIME_CHECK_NT ("BASIC_INFO", basic_info, access_time);
TIME_CHECK_NT ("BASIC_INFORMATION", basic_info, access_time);
s1 = fnum_find("BASIC_INFO");
correct_time = s1->basic_info.out.write_time;
- printf("write_time : %s\n", nt_time_string(mem_ctx, &correct_time));
+ printf("write_time : %s\n", nt_time_string(mem_ctx, correct_time));
TIME_CHECK_NT ("BASIC_INFO", basic_info, write_time);
TIME_CHECK_NT ("BASIC_INFORMATION", basic_info, write_time);
s1 = fnum_find("BASIC_INFO");
correct_time = s1->basic_info.out.change_time;
- printf("change_time: %s\n", nt_time_string(mem_ctx, &correct_time));
+ printf("change_time: %s\n", nt_time_string(mem_ctx, correct_time));
TIME_CHECK_NT ("BASIC_INFO", basic_info, change_time);
TIME_CHECK_NT ("BASIC_INFORMATION", basic_info, change_time);
status = smb_raw_read(cli->tree, &io);
CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
-#ifdef LARGE_SMB_OFF_T
printf("Trying large offset read\n");
- io.readx.in.offset = ((SMB_BIG_UINT)0x2) << 32;
+ io.readx.in.offset = ((uint64_t)0x2) << 32;
io.readx.in.mincnt = 10;
io.readx.in.maxcnt = 10;
status = smb_raw_read(cli->tree, &io);
status = smb_raw_read(cli->tree, &io);
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_VALUE(io.readx.out.nread, 0);
-#endif
done:
cli_close(cli->tree, fnum);
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_VALUE(io.readbraw.out.nread, 0);
-#ifdef LARGE_SMB_OFF_T
printf("Trying large offset read\n");
- io.readbraw.in.offset = ((SMB_BIG_UINT)0x2) << 32;
+ io.readbraw.in.offset = ((uint64_t)0x2) << 32;
io.readbraw.in.mincnt = 10;
io.readbraw.in.maxcnt = 10;
io.readbraw.in.timeout = 0;
status = smb_raw_read(cli->tree, &io);
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_VALUE(io.readbraw.out.nread, 0);
-#endif
done:
cli_close(cli->tree, fnum);
#define CHECK_TIME(name, sname1, field1, v, sname2, field2) do { \
s = find(name); \
if (s) { \
- if (s->sname1.field1 != (~1 & nt_time_to_unix(&v.sname2.out.field2))) { \
+ if (s->sname1.field1 != (~1 & nt_time_to_unix(v.sname2.out.field2))) { \
printf("(%d) %s/%s [%s] != %s/%s [%s]\n", \
__LINE__, \
#sname1, #field1, timestring(mem_ctx, s->sname1.field1), \
- #sname2, #field2, nt_time_string(mem_ctx, &v.sname2.out.field2)); \
+ #sname2, #field2, nt_time_string(mem_ctx, v.sname2.out.field2)); \
ret = False; \
} \
}} while (0)
#define CHECK_NTTIME(name, sname1, field1, v, sname2, field2) do { \
s = find(name); \
if (s) { \
- if (memcmp(&s->sname1.field1, &v.sname2.out.field2, sizeof(NTTIME))) { \
+ if (s->sname1.field1 != v.sname2.out.field2) { \
printf("(%d) %s/%s [%s] != %s/%s [%s]\n", \
__LINE__, \
- #sname1, #field1, nt_time_string(mem_ctx, &s->sname1.field1), \
- #sname2, #field2, nt_time_string(mem_ctx, &v.sname2.out.field2)); \
+ #sname1, #field1, nt_time_string(mem_ctx, s->sname1.field1), \
+ #sname2, #field2, nt_time_string(mem_ctx, v.sname2.out.field2)); \
ret = False; \
} \
}} while (0)
#define CHECK_TIME(call, stype, field, value) do { \
CHECK1(call); \
- if (NT_STATUS_IS_OK(status) && NT_STATUS_IS_OK(status2) && nt_time_to_unix(&finfo2.stype.out.field) != value) { \
+ if (NT_STATUS_IS_OK(status) && NT_STATUS_IS_OK(status2) && nt_time_to_unix(finfo2.stype.out.field) != value) { \
printf("(%d) %s - %s/%s should be 0x%x - 0x%x\n", __LINE__, \
call_name, #stype, #field, \
(uint_t)value, \
- (uint_t)nt_time_to_unix(&finfo2.stype.out.field)); \
+ (uint_t)nt_time_to_unix(finfo2.stype.out.field)); \
printf("\t%s", timestring(mem_ctx, value)); \
- printf("\t%s\n", nt_time_string(mem_ctx, &finfo2.stype.out.field)); \
+ printf("\t%s\n", nt_time_string(mem_ctx, finfo2.stype.out.field)); \
dump_all_info(mem_ctx, &finfo1); \
}} while (0)
status = smb_raw_write(cli->tree, &io);
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_VALUE(io.write.out.nwritten, 4000);
- CHECK_ALL_INFO(io.write.in.count + (SMB_BIG_UINT)io.write.in.offset, size);
+ CHECK_ALL_INFO(io.write.in.count + (uint64_t)io.write.in.offset, size);
memset(buf, 0, maxsize);
if (cli_read(cli->tree, fnum, buf, io.write.in.offset, 4000) != 4000) {
status = smb_raw_write(cli->tree, &io);
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_VALUE(io.writex.out.nwritten, 4000);
- CHECK_ALL_INFO(io.writex.in.count + (SMB_BIG_UINT)io.writex.in.offset, size);
+ CHECK_ALL_INFO(io.writex.in.count + (uint64_t)io.writex.in.offset, size);
memset(buf, 0, maxsize);
if (cli_read(cli->tree, fnum, buf, io.writex.in.offset, 4000) != 4000) {
setup_buffer(buf, seed+1, maxsize);
io.writex.in.fnum = fnum;
io.writex.in.count = 4000;
- io.writex.in.offset = ((SMB_BIG_UINT)1) << i;
+ io.writex.in.offset = ((uint64_t)1) << i;
io.writex.in.data = buf;
status = smb_raw_write(cli->tree, &io);
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_VALUE(io.writex.out.nwritten, 4000);
- CHECK_ALL_INFO(io.writex.in.count + (SMB_BIG_UINT)io.writex.in.offset, size);
+ CHECK_ALL_INFO(io.writex.in.count + (uint64_t)io.writex.in.offset, size);
memset(buf, 0, maxsize);
if (cli_read(cli->tree, fnum, buf, io.writex.in.offset, 4000) != 4000) {
status = smb_raw_write(cli->tree, &io);
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_VALUE(io.writeunlock.out.nwritten, 4000);
- CHECK_ALL_INFO(io.writeunlock.in.count + (SMB_BIG_UINT)io.writeunlock.in.offset, size);
+ CHECK_ALL_INFO(io.writeunlock.in.count + (uint64_t)io.writeunlock.in.offset, size);
memset(buf, 0, maxsize);
if (cli_read(cli->tree, fnum, buf, io.writeunlock.in.offset, 4000) != 4000) {
status = smb_raw_write(cli->tree, &io);
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_VALUE(io.writeclose.out.nwritten, 4000);
- CHECK_ALL_INFO(io.writeclose.in.count + (SMB_BIG_UINT)io.writeclose.in.offset, size);
+ CHECK_ALL_INFO(io.writeclose.in.count + (uint64_t)io.writeclose.in.offset, size);
fnum = cli_open(cli->tree, fname, O_RDWR, DENY_NONE);
io.writeclose.in.fnum = fnum;
/* we remember the sequence numbers so we can easily do a DatabaseDelta */
-static struct ULONG8 sequence_nums[3];
+static uint64_t sequence_nums[3];
/*
try a netlogon DatabaseSync
r.out.delta_enum_array->delta_enum[0].delta_union.domain) {
sequence_nums[r.in.database_id] =
r.out.delta_enum_array->delta_enum[0].delta_union.domain->sequence_num;
- printf("\tsequence_nums[%d]=0x%08x%08x\n",
+ printf("\tsequence_nums[%d]=%llu\n",
r.in.database_id,
- sequence_nums[r.in.database_id].high,
- sequence_nums[r.in.database_id].low);
+ sequence_nums[r.in.database_id]);
}
} while (NT_STATUS_EQUAL(status, STATUS_MORE_ENTRIES));
}
r.in.database_id = database_ids[i];
r.in.sequence_num = sequence_nums[r.in.database_id];
- if (r.in.sequence_num.low == 0) continue;
+ if (r.in.sequence_num == 0) continue;
- r.in.sequence_num.low -= 1;
+ r.in.sequence_num -= 1;
- printf("Testing DatabaseDeltas of id %d at %d\n",
- r.in.database_id, r.in.sequence_num.low);
+ printf("Testing DatabaseDeltas of id %d at %llu\n",
+ r.in.database_id, r.in.sequence_num);
do {
creds_client_authenticator(&creds, &r.in.credential);
printf("Credential chaining failed\n");
}
- r.in.sequence_num.low++;
- r.in.sequence_num.high = 0;
+ r.in.sequence_num++;
} while (NT_STATUS_EQUAL(status, STATUS_MORE_ENTRIES));
}
struct samr_CryptPassword nt_pass, lm_pass;
struct samr_Hash nt_verifier, lm_verifier;
char *oldpass = *password;
- char *newpass = samr_rand_pass(mem_ctx);
+ char *newpass = samr_rand_pass(mem_ctx);
uint8 old_nt_hash[16], new_nt_hash[16];
uint8 old_lm_hash[16], new_lm_hash[16];
E_deshash(newpass, new_lm_hash);
encode_pw_buffer(lm_pass.data, newpass, STR_UNICODE);
- SamOEMhash(lm_pass.data, old_lm_hash, 516);
+ SamOEMhash(lm_pass.data, old_nt_hash, 516);
E_old_pw_hash(new_lm_hash, old_lm_hash, lm_verifier.hash);
encode_pw_buffer(nt_pass.data, newpass, STR_UNICODE);
*/
BOOL nt_time_equal(NTTIME *t1, NTTIME *t2)
{
- return t1->low == t2->low && t1->high == t2->high;
+ return *t1 == *t2;
}
/*
*/
void dump_all_info(TALLOC_CTX *mem_ctx, union smb_fileinfo *finfo)
{
- d_printf("\tcreate_time: %s\n", nt_time_string(mem_ctx, &finfo->all_info.out.create_time));
- d_printf("\taccess_time: %s\n", nt_time_string(mem_ctx, &finfo->all_info.out.access_time));
- d_printf("\twrite_time: %s\n", nt_time_string(mem_ctx, &finfo->all_info.out.write_time));
- d_printf("\tchange_time: %s\n", nt_time_string(mem_ctx, &finfo->all_info.out.change_time));
+ d_printf("\tcreate_time: %s\n", nt_time_string(mem_ctx, finfo->all_info.out.create_time));
+ d_printf("\taccess_time: %s\n", nt_time_string(mem_ctx, finfo->all_info.out.access_time));
+ d_printf("\twrite_time: %s\n", nt_time_string(mem_ctx, finfo->all_info.out.write_time));
+ d_printf("\tchange_time: %s\n", nt_time_string(mem_ctx, finfo->all_info.out.change_time));
d_printf("\tattrib: 0x%x\n", finfo->all_info.out.attrib);
d_printf("\talloc_size: %llu\n", (unsigned long long)finfo->all_info.out.alloc_size);
d_printf("\tsize: %llu\n", (unsigned long long)finfo->all_info.out.size);
git.samba.org / bbaumbach / samba-autobuild / .git / commitdiff