/* timing globals */
static uint64_t get_total_size = 0;
-static uint_t get_total_time_ms = 0;
+static unsigned int get_total_time_ms = 0;
static uint64_t put_total_size = 0;
-static uint_t put_total_time_ms = 0;
+static unsigned int put_total_time_ms = 0;
/* Unfortunately, there is no way to pass the a context to the completion function as an argument */
static struct smbclient_context *rl_ctx;
/*
search the sam for a single integer attribute in exactly 1 record
*/
-uint_t samdb_search_uint(struct ldb_context *sam_ldb,
+unsigned int samdb_search_uint(struct ldb_context *sam_ldb,
TALLOC_CTX *mem_ctx,
- uint_t default_value,
+ unsigned int default_value,
struct ldb_dn *basedn,
const char *attr_name,
const char *format, ...) _PRINTF_ATTRIBUTE(6,7)
/*
pull a uint from a result set.
*/
-uint_t samdb_result_uint(const struct ldb_message *msg, const char *attr, uint_t default_value)
+unsigned int samdb_result_uint(const struct ldb_message *msg, const char *attr, unsigned int default_value)
{
return ldb_msg_find_attr_as_uint(msg, attr, default_value);
}
/*
pull an array of samr_Password structutres from a result set.
*/
-uint_t samdb_result_hashes(TALLOC_CTX *mem_ctx, const struct ldb_message *msg,
+unsigned int samdb_result_hashes(TALLOC_CTX *mem_ctx, const struct ldb_message *msg,
const char *attr, struct samr_Password **hashes)
{
- uint_t count, i;
+ unsigned int count, i;
const struct ldb_val *val = ldb_msg_find_ldb_val(msg, attr);
*hashes = NULL;
}
/*
- add a uint_t element to a message
+ add a unsigned int element to a message
*/
int samdb_msg_add_uint(struct ldb_context *sam_ldb, TALLOC_CTX *mem_ctx, struct ldb_message *msg,
- const char *attr_name, uint_t v)
+ const char *attr_name, unsigned int v)
{
return samdb_msg_add_int(sam_ldb, mem_ctx, msg, attr_name, (int)v);
}
add a samr_Password array to a message
*/
int samdb_msg_add_hashes(TALLOC_CTX *mem_ctx, struct ldb_message *msg,
- const char *attr_name, struct samr_Password *hashes, uint_t count)
+ const char *attr_name, struct samr_Password *hashes, unsigned int count)
{
struct ldb_val val;
int i;
struct domain_data {
bool store_cleartext;
- uint_t pwdProperties;
- uint_t pwdHistoryLength;
+ unsigned int pwdProperties;
+ unsigned int pwdHistoryLength;
const char *netbios_domain;
const char *dns_domain;
const char *realm;
uint32_t msg_type, struct server_id src, DATA_BLOB *data)
{
DEBUG(1,("INFO: Received PING message from server %u.%u [%.*s]\n",
- (uint_t)src.node, (uint_t)src.id, (int)data->length,
+ (unsigned int)src.node, (unsigned int)src.id, (int)data->length,
data->data?(const char *)data->data:""));
messaging_send(msg, src, MSG_PONG, data);
}
****************************************************************************/
uint32_t unix_perms_to_wire(mode_t perms)
{
- uint_t ret = 0;
+ unsigned int ret = 0;
ret |= ((perms & S_IXOTH) ? UNIX_X_OTH : 0);
ret |= ((perms & S_IWOTH) ? UNIX_W_OTH : 0);
int share_mode)
{
union smb_open open_parms;
- uint_t openfn=0;
- uint_t accessmode=0;
+ unsigned int openfn=0;
+ unsigned int accessmode=0;
TALLOC_CTX *mem_ctx;
NTSTATUS status;
enum smb_mkdir_level level;
struct {
const char *path;
- uint_t num_eas;
+ unsigned int num_eas;
struct ea_struct *eas;
} in;
} t2mkdir;
struct {
uint32_t attrib;
uint32_t ea_size;
- uint_t num_eas;
+ unsigned int num_eas;
struct ea_struct {
uint8_t flags;
struct smb_wire_string name;
uint32_t mode;
uint32_t alignment_requirement;
uint32_t reparse_tag;
- uint_t num_streams;
+ unsigned int num_streams;
struct stream_struct {
uint64_t size;
uint64_t alloc_size;
enum smb_fileinfo_level level;
struct {
union smb_handle_or_path file;
- uint_t num_names;
+ unsigned int num_names;
struct ea_name {
struct smb_wire_string name;
} *ea_names;
} in;
struct smb_ea_list {
- uint_t num_eas;
+ unsigned int num_eas;
struct ea_struct *eas;
} out;
} ea_list;
union smb_handle_or_path file;
} in;
struct stream_information {
- uint_t num_streams;
+ unsigned int num_streams;
struct stream_struct *streams;
} out;
} stream_info;
enum smb_setfileinfo_level level;
struct {
union smb_handle_or_path file;
- uint_t num_eas;
+ unsigned int num_eas;
struct ea_struct *eas;
} in;
} ea_set;
uint32_t size;
uint32_t timeout;
const char *fname;
- uint_t num_eas;
+ unsigned int num_eas;
struct ea_struct *eas;
} in;
struct {
const char *pattern;
/* the ea names are only used for RAW_SEARCH_EA_LIST */
- uint_t num_names;
+ unsigned int num_names;
struct ea_name *ea_names;
} in;
struct {
const char *last_name;
/* the ea names are only used for RAW_SEARCH_EA_LIST */
- uint_t num_names;
+ unsigned int num_names;
struct ea_name *ea_names;
} in;
struct {
int server_zone;
time_t server_time;
- uint_t readbraw_supported:1;
- uint_t writebraw_supported:1;
- uint_t lockread_supported:1;
+ unsigned int readbraw_supported:1;
+ unsigned int writebraw_supported:1;
+ unsigned int lockread_supported:1;
char *server_domain;
};
client library
*/
struct smbcli_options {
- uint_t use_oplocks:1;
- uint_t use_level2_oplocks:1;
- uint_t use_spnego:1;
- uint_t unicode:1;
- uint_t ntstatus_support:1;
+ unsigned int use_oplocks:1;
+ unsigned int use_level2_oplocks:1;
+ unsigned int use_spnego:1;
+ unsigned int unicode:1;
+ unsigned int ntstatus_support:1;
int max_protocol;
uint32_t max_xmit;
uint16_t max_mux;
/* is a readbraw pending? we need to handle that case
specially on receiving packets */
- uint_t readbraw_pending:1;
+ unsigned int readbraw_pending:1;
/* an idle function - if this is defined then it will be
called once every period microseconds while we are waiting
struct {
void (*func)(struct smbcli_transport *, void *);
void *private_data;
- uint_t period;
+ unsigned int period;
} idle;
/* the error fields from the last message */
SOCKET_READ_ERROR,
SOCKET_WRITE_ERROR,
SOCKET_READ_BAD_SIG} socket_error;
- uint_t nbt_error;
+ unsigned int nbt_error;
} e;
} error;
struct gensec_security *gensec;
struct smbcli_session_options {
- uint_t lanman_auth:1;
- uint_t ntlmv2_auth:1;
- uint_t plaintext_auth:1;
+ unsigned int lanman_auth:1;
+ unsigned int ntlmv2_auth:1;
+ unsigned int plaintext_auth:1;
} options;
const char *os;
NTSTATUS status;
/* the sequence number of this packet - used for signing */
- uint_t seq_num;
+ unsigned int seq_num;
/* list of ntcancel request for this requests */
struct smbcli_request *ntcancel;
/* set if this is a one-way request, meaning we are not
expecting a reply from the server. */
- uint_t one_way_request:1;
+ unsigned int one_way_request:1;
/* set this when the request should only increment the signing
counter by one */
- uint_t sign_single_increment:1;
+ unsigned int sign_single_increment:1;
/* the caller wants to do the signing check */
bool sign_caller_checks;
This assumes the names are strict ascii, which should be a
reasonable assumption
*/
-size_t ea_list_size(uint_t num_eas, struct ea_struct *eas)
+size_t ea_list_size(unsigned int num_eas, struct ea_struct *eas)
{
- uint_t total = 4;
+ unsigned int total = 4;
int i;
for (i=0;i<num_eas;i++) {
total += 4 + strlen(eas[i].name.s)+1 + eas[i].value.length;
/*
work out how many bytes on the wire a ea name list will consume.
*/
-static uint_t ea_name_list_size(uint_t num_names, struct ea_name *eas)
+static unsigned int ea_name_list_size(unsigned int num_names, struct ea_name *eas)
{
- uint_t total = 4;
+ unsigned int total = 4;
int i;
for (i=0;i<num_names;i++) {
total += 1 + strlen(eas[i].name.s) + 1;
This assumes the names are strict ascii, which should be a
reasonable assumption
*/
-size_t ea_list_size_chained(uint_t num_eas, struct ea_struct *eas, unsigned alignment)
+size_t ea_list_size_chained(unsigned int num_eas, struct ea_struct *eas, unsigned alignment)
{
- uint_t total = 0;
+ unsigned int total = 0;
int i;
for (i=0;i<num_eas;i++) {
- uint_t len = 8 + strlen(eas[i].name.s)+1 + eas[i].value.length;
+ unsigned int len = 8 + strlen(eas[i].name.s)+1 + eas[i].value.length;
len = (len + (alignment-1)) & ~(alignment-1);
total += len;
}
put a ea_list into a pre-allocated buffer - buffer must be at least
of size ea_list_size()
*/
-void ea_put_list(uint8_t *data, uint_t num_eas, struct ea_struct *eas)
+void ea_put_list(uint8_t *data, unsigned int num_eas, struct ea_struct *eas)
{
int i;
uint32_t ea_size;
data += 4;
for (i=0;i<num_eas;i++) {
- uint_t nlen = strlen(eas[i].name.s);
+ unsigned int nlen = strlen(eas[i].name.s);
SCVAL(data, 0, eas[i].flags);
SCVAL(data, 1, nlen);
SSVAL(data, 2, eas[i].value.length);
put a chained ea_list into a pre-allocated buffer - buffer must be
at least of size ea_list_size()
*/
-void ea_put_list_chained(uint8_t *data, uint_t num_eas, struct ea_struct *eas,
+void ea_put_list_chained(uint8_t *data, unsigned int num_eas, struct ea_struct *eas,
unsigned alignment)
{
int i;
for (i=0;i<num_eas;i++) {
- uint_t nlen = strlen(eas[i].name.s);
+ unsigned int nlen = strlen(eas[i].name.s);
uint32_t len = 8+nlen+1+eas[i].value.length;
- uint_t pad = ((len + (alignment-1)) & ~(alignment-1)) - len;
+ unsigned int pad = ((len + (alignment-1)) & ~(alignment-1)) - len;
if (i == num_eas-1) {
SIVAL(data, 0, 0);
} else {
/*
pull a ea_struct from a buffer. Return the number of bytes consumed
*/
-uint_t ea_pull_struct(const DATA_BLOB *blob,
+unsigned int ea_pull_struct(const DATA_BLOB *blob,
TALLOC_CTX *mem_ctx,
struct ea_struct *ea)
{
*/
NTSTATUS ea_pull_list(const DATA_BLOB *blob,
TALLOC_CTX *mem_ctx,
- uint_t *num_eas, struct ea_struct **eas)
+ unsigned int *num_eas, struct ea_struct **eas)
{
int n;
uint32_t ea_size, ofs;
*eas = NULL;
while (ofs < ea_size) {
- uint_t len;
+ unsigned int len;
DATA_BLOB blob2;
blob2.data = blob->data + ofs;
*/
NTSTATUS ea_pull_list_chained(const DATA_BLOB *blob,
TALLOC_CTX *mem_ctx,
- uint_t *num_eas, struct ea_struct **eas)
+ unsigned int *num_eas, struct ea_struct **eas)
{
int n;
uint32_t ofs;
*eas = NULL;
while (ofs < blob->length) {
- uint_t len;
+ unsigned int len;
DATA_BLOB blob2;
uint32_t next_ofs = IVAL(blob->data, ofs);
/*
pull a ea_name from a buffer. Return the number of bytes consumed
*/
-static uint_t ea_pull_name(const DATA_BLOB *blob,
+static unsigned int ea_pull_name(const DATA_BLOB *blob,
TALLOC_CTX *mem_ctx,
struct ea_name *ea)
{
*/
NTSTATUS ea_pull_name_list(const DATA_BLOB *blob,
TALLOC_CTX *mem_ctx,
- uint_t *num_names, struct ea_name **ea_names)
+ unsigned int *num_names, struct ea_name **ea_names)
{
int n;
uint32_t ea_size, ofs;
*ea_names = NULL;
while (ofs < ea_size) {
- uint_t len;
+ unsigned int len;
DATA_BLOB blob2;
blob2.data = blob->data + ofs;
put a ea_name list into a data blob
*/
bool ea_push_name_list(TALLOC_CTX *mem_ctx,
- DATA_BLOB *data, uint_t num_names, struct ea_name *eas)
+ DATA_BLOB *data, unsigned int num_names, struct ea_name *eas)
{
int i;
uint32_t ea_size;
off = 4;
for (i=0;i<num_names;i++) {
- uint_t nlen = strlen(eas[i].name.s);
+ unsigned int nlen = strlen(eas[i].name.s);
SCVAL(data->data, off, nlen);
memcpy(data->data+off+1, eas[i].name.s, nlen+1);
off += 1+nlen+1;
case RAW_LOCK_LOCKX: {
struct smb_lock_entry *lockp;
- uint_t lck_size = (parms->lockx.in.mode & LOCKING_ANDX_LARGE_FILES)? 20 : 10;
- uint_t lock_count = parms->lockx.in.ulock_cnt + parms->lockx.in.lock_cnt;
+ unsigned int lck_size = (parms->lockx.in.mode & LOCKING_ANDX_LARGE_FILES)? 20 : 10;
+ unsigned int lock_count = parms->lockx.in.ulock_cnt + parms->lockx.in.lock_cnt;
int i;
SETUP_REQUEST(SMBlockingX, 8, lck_size * lock_count);
io->streams = NULL;
while (blob.length - ofs >= 24) {
- uint_t n = io->num_streams;
+ unsigned int n = io->num_streams;
uint32_t nlen, len;
bool ret;
void *vstr;
setup a SMB packet at transport level
*/
struct smbcli_request *smbcli_request_setup_transport(struct smbcli_transport *transport,
- uint8_t command, uint_t wct, uint_t buflen)
+ uint8_t command, unsigned int wct, unsigned int buflen)
{
struct smbcli_request *req;
way. This interface is used before a session is setup.
*/
struct smbcli_request *smbcli_request_setup_session(struct smbcli_session *session,
- uint8_t command, uint_t wct, size_t buflen)
+ uint8_t command, unsigned int wct, size_t buflen)
{
struct smbcli_request *req;
*/
struct smbcli_request *smbcli_request_setup(struct smbcli_tree *tree,
uint8_t command,
- uint_t wct, uint_t buflen)
+ unsigned int wct, unsigned int buflen)
{
struct smbcli_request *req;
To cope with this req->out.ptr is supplied. This will be updated to
point at the same offset into the packet as before this call
*/
-static void smbcli_req_grow_allocation(struct smbcli_request *req, uint_t new_size)
+static void smbcli_req_grow_allocation(struct smbcli_request *req, unsigned int new_size)
{
int delta;
uint8_t *buf2;
To cope with this req->out.ptr is supplied. This will be updated to
point at the same offset into the packet as before this call
*/
-static void smbcli_req_grow_data(struct smbcli_request *req, uint_t new_size)
+static void smbcli_req_grow_data(struct smbcli_request *req, unsigned int new_size)
{
int delta;
*/
NTSTATUS smbcli_chained_request_setup(struct smbcli_request *req,
uint8_t command,
- uint_t wct, size_t buflen)
+ unsigned int wct, size_t buflen)
{
- uint_t new_size = 1 + (wct*2) + 2 + buflen;
+ unsigned int new_size = 1 + (wct*2) + 2 + buflen;
SSVAL(req->out.vwv, VWV(0), command);
SSVAL(req->out.vwv, VWV(1), req->out.size - NBT_HDR_SIZE);
handle oplock break requests from the server - return true if the request was
an oplock break
*/
-bool smbcli_handle_oplock_break(struct smbcli_transport *transport, uint_t len, const uint8_t *hdr, const uint8_t *vwv)
+bool smbcli_handle_oplock_break(struct smbcli_transport *transport, unsigned int len, const uint8_t *hdr, const uint8_t *vwv)
{
/* we must be very fussy about what we consider an oplock break to avoid
matching readbraw replies */
return the number of bytes added to the packet
*/
-size_t smbcli_req_append_string(struct smbcli_request *req, const char *str, uint_t flags)
+size_t smbcli_req_append_string(struct smbcli_request *req, const char *str, unsigned int flags)
{
size_t len;
this is used in places where the non-terminated string byte length is
placed in the packet as a separate field
*/
-size_t smbcli_req_append_string_len(struct smbcli_request *req, const char *str, uint_t flags, int *len)
+size_t smbcli_req_append_string_len(struct smbcli_request *req, const char *str, unsigned int flags, int *len)
{
int diff = 0;
size_t ret;
if dest_len is -1 then no limit applies
*/
-size_t smbcli_req_append_ascii4(struct smbcli_request *req, const char *str, uint_t flags)
+size_t smbcli_req_append_ascii4(struct smbcli_request *req, const char *str, unsigned int flags)
{
size_t size;
smbcli_req_append_bytes(req, (const uint8_t *)"\4", 1);
of bytes consumed in the packet is returned
*/
static size_t smbcli_req_pull_ucs2(struct request_bufinfo *bufinfo, TALLOC_CTX *mem_ctx,
- char **dest, const uint8_t *src, int byte_len, uint_t flags)
+ char **dest, const uint8_t *src, int byte_len, unsigned int flags)
{
int src_len, src_len2, alignment=0;
bool ret;
of bytes consumed in the packet is returned
*/
size_t smbcli_req_pull_ascii(struct request_bufinfo *bufinfo, TALLOC_CTX *mem_ctx,
- char **dest, const uint8_t *src, int byte_len, uint_t flags)
+ char **dest, const uint8_t *src, int byte_len, unsigned int flags)
{
int src_len, src_len2;
bool ret;
of bytes consumed in the packet is returned
*/
size_t smbcli_req_pull_string(struct request_bufinfo *bufinfo, TALLOC_CTX *mem_ctx,
- char **dest, const uint8_t *src, int byte_len, uint_t flags)
+ char **dest, const uint8_t *src, int byte_len, unsigned int flags)
{
if (!(flags & STR_ASCII) &&
(((flags & STR_UNICODE) || (bufinfo->flags & BUFINFO_FLAG_UNICODE)))) {
*/
size_t smbcli_blob_pull_ucs2(TALLOC_CTX* mem_ctx,
const DATA_BLOB *blob, const char **dest,
- const uint8_t *src, int byte_len, uint_t flags)
+ const uint8_t *src, int byte_len, unsigned int flags)
{
int src_len, src_len2, alignment=0;
size_t ret_size;
*/
static size_t smbcli_blob_pull_ascii(TALLOC_CTX *mem_ctx,
const DATA_BLOB *blob, const char **dest,
- const uint8_t *src, int byte_len, uint_t flags)
+ const uint8_t *src, int byte_len, unsigned int flags)
{
int src_len, src_len2;
size_t ret_size;
const DATA_BLOB *blob,
struct smb_wire_string *dest,
uint16_t len_offset, uint16_t str_offset,
- uint_t flags)
+ unsigned int flags)
{
int extra;
dest->s = NULL;
DATA_BLOB *blob,
const char **dest,
uint16_t str_offset,
- uint_t flags)
+ unsigned int flags)
{
int extra = 0;
*dest = NULL;
*/
size_t smbcli_blob_append_string(struct smbcli_session *session,
TALLOC_CTX *mem_ctx, DATA_BLOB *blob,
- const char *str, uint_t flags)
+ const char *str, unsigned int flags)
{
size_t max_len;
int len;
enum smb_search_data_level level,
const DATA_BLOB *blob,
union smb_search_data *data,
- uint_t *next_ofs,
- uint_t str_flags)
+ unsigned int *next_ofs,
+ unsigned int str_flags)
{
- uint_t len, blen;
+ unsigned int len, blen;
if (blob->length < 4) {
return NT_STATUS_INFO_LENGTH_MISMATCH;
DATA_BLOB *blob,
union smb_search_data *data)
{
- uint_t len, ofs;
+ unsigned int len, ofs;
uint32_t ea_size;
DATA_BLOB eablob;
NTSTATUS status;
case RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO:
case RAW_SEARCH_DATA_ID_FULL_DIRECTORY_INFO:
case RAW_SEARCH_DATA_ID_BOTH_DIRECTORY_INFO: {
- uint_t str_flags = STR_UNICODE;
+ unsigned int str_flags = STR_UNICODE;
if (!(tree->session->transport->negotiate.capabilities & CAP_UNICODE)) {
str_flags = STR_ASCII;
}
for (i=0; i < count; i++) {
union smb_search_data search_data;
- uint_t len;
+ unsigned int len;
len = parse_trans2_search(tree, mem_ctx, level, flags, &blob2, &search_data);
if (len == -1) {
union smb_setfileinfo *parms,
DATA_BLOB *blob)
{
- uint_t len;
+ unsigned int len;
#define NEED_BLOB(n) do { \
*blob = data_blob_talloc(mem_ctx, NULL, n); \
check out of bounds for incoming data
*/
static bool raw_trans_oob(struct smbcli_request *req,
- uint_t offset, uint_t count)
+ unsigned int offset, unsigned int count)
{
uint8_t *ptr;
/* the command words and command word count. vwv points
into the raw buffer */
uint8_t *vwv;
- uint_t wct;
+ unsigned int wct;
/* the data buffer and size. data points into the raw buffer */
uint8_t *data;
Uncomment this to test if the remote server actually verifies signitures...*/
}
-bool check_signed_incoming_message(struct smb_request_buffer *in, DATA_BLOB *mac_key, uint_t seq_num)
+bool check_signed_incoming_message(struct smb_request_buffer *in, DATA_BLOB *mac_key, unsigned int seq_num)
{
bool good;
uint8_t calc_md5_mac[16];
if (token->privilege_mask) {
int i = 0;
- uint_t privilege;
+ unsigned int privilege;
for (privilege = 1; privilege <= 64; privilege++) {
uint64_t mask = sec_privilege_mask(privilege);
smb_search_data structures
*/
NTSTATUS smb2_find_level_recv(struct smb2_request *req, TALLOC_CTX *mem_ctx,
- uint8_t level, uint_t *count,
+ uint8_t level, unsigned int *count,
union smb_search_data **io)
{
struct smb2_find f;
NTSTATUS status;
DATA_BLOB b;
enum smb_search_data_level smb_level;
- uint_t next_ofs=0;
+ unsigned int next_ofs=0;
switch (level) {
case SMB2_FIND_DIRECTORY_INFO:
*/
NTSTATUS smb2_find_level(struct smb2_tree *tree, TALLOC_CTX *mem_ctx,
struct smb2_find *f,
- uint_t *count, union smb_search_data **io)
+ unsigned int *count, union smb_search_data **io)
{
struct smb2_request *req;
struct {
void (*func)(struct smb2_transport *, void *);
void *private_data;
- uint_t period;
+ unsigned int period;
} idle;
struct {
{
NTSTATUS status;
uint32_t total_deleted = 0;
- uint_t count, i;
+ unsigned int count, i;
union smb_search_data *list;
TALLOC_CTX *tmp_ctx = talloc_new(tree);
struct smb2_find f;
DATA_BLOB *raw_packet, struct ncacn_packet *pkt)
{
struct rpc_request *req;
- uint_t length;
+ unsigned int length;
NTSTATUS status = NT_STATUS_OK;
/*
NTSTATUS status;
DATA_BLOB response;
struct ndr_pull *pull;
- uint_t flags;
+ unsigned int flags;
TALLOC_CTX *mem_ctx = req->ndr.mem_ctx;
void *r = req->ndr.struct_ptr;
uint32_t opnum = req->ndr.opnum;
struct cifspsx_dir *dir;
DIR *odir;
struct dirent *dent;
- uint_t allocated = 0;
+ unsigned int allocated = 0;
char *low_mask;
dir = talloc(mem_ctx, struct cifspsx_dir);
if (!odir) { return NULL; }
while ((dent = readdir(odir))) {
- uint_t i = dir->count;
+ unsigned int i = dir->count;
char *full_name;
char *low_name;
struct cifspsx_private *p = ntvfs->private_data;
struct search_state *search;
union smb_search_data file;
- uint_t max_count;
+ unsigned int max_count;
if (io->generic.level != RAW_SEARCH_TRANS2) {
return NT_STATUS_NOT_SUPPORTED;
struct cifspsx_private *p = ntvfs->private_data;
struct search_state *search;
union smb_search_data file;
- uint_t max_count;
+ unsigned int max_count;
if (io->generic.level != RAW_SEARCH_TRANS2) {
return NT_STATUS_NOT_SUPPORTED;
time_t write_time = 0;
uint32_t set_size = 0;
union smb_setfileinfo *sf;
- uint_t state;
+ unsigned int state;
if (!NT_STATUS_IS_OK(status)) {
return status;
case RAW_QFS_DSKATTR: {
/* map from generic to DSKATTR */
- uint_t bpunit = 64;
+ unsigned int bpunit = 64;
/* we need to scale the sizes to fit */
for (bpunit=64; bpunit<0x10000; bpunit *= 2) {
{
union smb_lock *lck;
union smb_close *cl;
- uint_t state;
+ unsigned int state;
if (NT_STATUS_IS_ERR(status)) {
return status;
union smb_read *rd2;
union smb_lock *lck;
NTSTATUS status;
- uint_t state;
+ unsigned int state;
rd2 = talloc(req, union smb_read);
if (rd2 == NULL) {
fill in the dos file attributes for a file
*/
NTSTATUS pvfs_fill_dos_info(struct pvfs_state *pvfs, struct pvfs_filename *name,
- uint_t flags, int fd)
+ unsigned int flags, int fd)
{
NTSTATUS status;
DATA_BLOB lkey;
struct pvfs_state *pvfs = talloc_get_type(ntvfs->private_data,
struct pvfs_state);
uint64_t blocks_free, blocks_total;
- uint_t bpunit;
+ unsigned int bpunit;
struct stat st;
const uint16_t block_size = 512;
*/
NTSTATUS pvfs_query_ea_list(struct pvfs_state *pvfs, TALLOC_CTX *mem_ctx,
struct pvfs_filename *name, int fd,
- uint_t num_names,
+ unsigned int num_names,
struct ea_name *names,
struct smb_ea_list *eas)
{
*/
static NTSTATUS pvfs_case_search(struct pvfs_state *pvfs,
struct pvfs_filename *name,
- uint_t flags)
+ unsigned int flags)
{
/* break into a series of components */
int num_components;
errors are returned if the filename is illegal given the flags
*/
static NTSTATUS pvfs_unix_path(struct pvfs_state *pvfs, const char *cifs_name,
- uint_t flags, struct pvfs_filename *name)
+ unsigned int flags, struct pvfs_filename *name)
{
char *ret, *p, *p_start;
struct smb_iconv_convenience *ic = NULL;
*/
static NTSTATUS pvfs_reduce_name(TALLOC_CTX *mem_ctx,
struct smb_iconv_convenience *iconv_convenience,
- const char **fname, uint_t flags)
+ const char **fname, unsigned int flags)
{
codepoint_t c;
size_t c_size, len;
NTSTATUS pvfs_resolve_name(struct pvfs_state *pvfs,
struct ntvfs_request *req,
const char *cifs_name,
- uint_t flags, struct pvfs_filename **name)
+ unsigned int flags, struct pvfs_filename **name)
{
NTSTATUS status;
*/
NTSTATUS pvfs_resolve_partial(struct pvfs_state *pvfs, TALLOC_CTX *mem_ctx,
const char *unix_dir, const char *fname,
- uint_t flags, struct pvfs_filename **name)
+ unsigned int flags, struct pvfs_filename **name)
{
NTSTATUS status;
to update the pvfs_filename stat information, and by pvfs_open()
*/
NTSTATUS pvfs_resolve_name_fd(struct pvfs_state *pvfs, int fd,
- struct pvfs_filename *name, uint_t flags)
+ struct pvfs_filename *name, unsigned int flags)
{
dev_t device = (dev_t)0;
ino_t inode = 0;
the search fill loop
*/
static NTSTATUS pvfs_search_fill(struct pvfs_state *pvfs, TALLOC_CTX *mem_ctx,
- uint_t max_count,
+ unsigned int max_count,
struct pvfs_search_state *search,
enum smb_search_data_level level,
- uint_t *reply_count,
+ unsigned int *reply_count,
void *search_private,
bool (*callback)(void *, const union smb_search_data *))
{
struct pvfs_state *pvfs = talloc_get_type(ntvfs->private_data,
struct pvfs_state);
struct pvfs_search_state *search;
- uint_t reply_count;
+ unsigned int reply_count;
uint16_t search_attrib;
const char *pattern;
NTSTATUS status;
void *p;
struct pvfs_search_state *search;
struct pvfs_dir *dir;
- uint_t reply_count, max_count;
+ unsigned int reply_count, max_count;
uint16_t handle;
NTSTATUS status;
struct pvfs_state *pvfs = talloc_get_type(ntvfs->private_data,
struct pvfs_state);
struct pvfs_search_state *search;
- uint_t reply_count;
+ unsigned int reply_count;
uint16_t search_attrib, max_count;
const char *pattern;
NTSTATUS status;
void *p;
struct pvfs_search_state *search;
struct pvfs_dir *dir;
- uint_t reply_count;
+ unsigned int reply_count;
uint16_t handle;
NTSTATUS status;
struct pvfs_state *pvfs = talloc_get_type(ntvfs->private_data,
struct pvfs_state);
struct pvfs_search_state *search;
- uint_t reply_count;
+ unsigned int reply_count;
uint16_t max_count;
const char *pattern;
NTSTATUS status;
struct pvfs_state *pvfs = talloc_get_type(ntvfs->private_data,
struct pvfs_state);
struct pvfs_search_state *search;
- uint_t reply_count;
+ unsigned int reply_count;
uint16_t max_count;
NTSTATUS status;
struct pvfs_file *f;
struct GUID *base_fs_uuid;
const char *share_name;
- uint_t flags;
+ unsigned int flags;
struct pvfs_mangle_context *mangle_ctx;
struct pvfs_wait *wait_list;
/* the sharing violation timeout (nsecs) */
- uint_t sharing_violation_delay;
+ unsigned int sharing_violation_delay;
/* the oplock break timeout (secs) */
- uint_t oplock_break_timeout;
+ unsigned int oplock_break_timeout;
/* the write time update delay (nsecs) */
- uint_t writetime_delay;
+ unsigned int writetime_delay;
/* filesystem attributes (see FS_ATTR_*) */
uint32_t fs_attribs;
struct pvfs_search_state *list;
/* how long to keep inactive searches around for */
- uint_t inactivity_time;
+ unsigned int inactivity_time;
} search;
/* used to accelerate acl mapping */
uint16_t must_attrib;
struct pvfs_dir *dir;
time_t last_used;
- uint_t num_ea_names;
+ unsigned int num_ea_names;
struct ea_name *ea_names;
struct tevent_timer *te;
};
struct svfs_dir *dir;
DIR *odir;
struct dirent *dent;
- uint_t allocated = 0;
+ unsigned int allocated = 0;
char *low_mask;
dir = talloc(mem_ctx, struct svfs_dir);
if (!odir) { return NULL; }
while ((dent = readdir(odir))) {
- uint_t i = dir->count;
+ unsigned int i = dir->count;
char *full_name;
char *low_name;
struct svfs_private *p = ntvfs->private_data;
struct search_state *search;
union smb_search_data file;
- uint_t max_count;
+ unsigned int max_count;
if (io->generic.level != RAW_SEARCH_TRANS2) {
return NT_STATUS_NOT_SUPPORTED;
struct svfs_private *p = ntvfs->private_data;
struct search_state *search;
union smb_search_data file;
- uint_t max_count;
+ unsigned int max_count;
if (io->generic.level != RAW_SEARCH_TRANS2) {
return NT_STATUS_NOT_SUPPORTED;
struct cvfs_private *p = ntvfs->private_data;
struct smb2_find f;
enum smb_search_data_level smb2_level;
- uint_t count, i;
+ unsigned int count, i;
union smb_search_data *data;
NTSTATUS status;
struct unix_sec_ctx {
uid_t uid;
gid_t gid;
- uint_t ngroups;
+ unsigned int ngroups;
gid_t *groups;
};
NTSTATUS smbsrv_blob_append_string(TALLOC_CTX *mem_ctx,
DATA_BLOB *blob,
const char *str,
- uint_t len_offset,
+ unsigned int len_offset,
int default_flags,
int flags)
{
union smb_fsinfo *fsinfo,
int default_str_flags)
{
- uint_t i;
+ unsigned int i;
DATA_BLOB guid_blob;
switch (level) {
union smb_fileinfo *st,
int default_str_flags)
{
- uint_t i;
+ unsigned int i;
size_t list_size;
switch (level) {
int default_str_flags)
{
uint8_t *data;
- uint_t ofs = blob->length;
+ unsigned int ofs = blob->length;
switch (level) {
case RAW_SEARCH_DATA_DIRECTORY_INFO:
the negotiated buffer size */
do {
uint32_t this_data, this_param, max_bytes;
- uint_t align1 = 1, align2 = (params_left ? 2 : 0);
+ unsigned int align1 = 1, align2 = (params_left ? 2 : 0);
struct smbsrv_request *this_req;
max_bytes = req_max_data(req) - (align1 + align2);
struct smbsrv_request *req;
union smb_lpq *lpq;
int i, maxcount;
- const uint_t el_size = 28;
+ const unsigned int el_size = 28;
SMBSRV_CHECK_ASYNC_STATUS(lpq,union smb_lpq);
void smbsrv_reply_lockingX(struct smbsrv_request *req)
{
union smb_lock *lck;
- uint_t total_locks, i;
- uint_t lck_size;
+ unsigned int total_locks, i;
+ unsigned int lck_size;
uint8_t *p;
/* parse request */
/*
setup a chained reply in req->out with the given word count and initial data buffer size.
*/
-static void req_setup_chain_reply(struct smbsrv_request *req, uint_t wct, uint_t buflen)
+static void req_setup_chain_reply(struct smbsrv_request *req, unsigned int wct, unsigned int buflen)
{
uint32_t chain_base_size = req->out.size;
the caller will then fill in the command words and data before calling req_send_reply() to
send the reply on its way
*/
-void smbsrv_setup_reply(struct smbsrv_request *req, uint_t wct, size_t buflen)
+void smbsrv_setup_reply(struct smbsrv_request *req, unsigned int wct, size_t buflen)
{
uint16_t flags2;
To cope with this req->out.ptr is supplied. This will be updated to
point at the same offset into the packet as before this call
*/
-static void req_grow_allocation(struct smbsrv_request *req, uint_t new_size)
+static void req_grow_allocation(struct smbsrv_request *req, unsigned int new_size)
{
int delta;
uint8_t *buf2;
size_t req_push_str(struct smbsrv_request *req, uint8_t *dest, const char *str, int dest_len, size_t flags)
{
size_t len;
- uint_t grow_size;
+ unsigned int grow_size;
uint8_t *buf0;
const int max_bytes_per_char = 3;
on failure zero is returned and *dest is set to NULL, otherwise the number
of bytes consumed in the packet is returned
*/
-static size_t req_pull_ucs2(struct request_bufinfo *bufinfo, const char **dest, const uint8_t *src, int byte_len, uint_t flags)
+static size_t req_pull_ucs2(struct request_bufinfo *bufinfo, const char **dest, const uint8_t *src, int byte_len, unsigned int flags)
{
int src_len, src_len2, alignment=0;
bool ret;
on failure zero is returned and *dest is set to NULL, otherwise the number
of bytes consumed in the packet is returned
*/
-static size_t req_pull_ascii(struct request_bufinfo *bufinfo, const char **dest, const uint8_t *src, int byte_len, uint_t flags)
+static size_t req_pull_ascii(struct request_bufinfo *bufinfo, const char **dest, const uint8_t *src, int byte_len, unsigned int flags)
{
int src_len, src_len2;
bool ret;
on failure zero is returned and *dest is set to NULL, otherwise the number
of bytes consumed in the packet is returned
*/
-size_t req_pull_string(struct request_bufinfo *bufinfo, const char **dest, const uint8_t *src, int byte_len, uint_t flags)
+size_t req_pull_string(struct request_bufinfo *bufinfo, const char **dest, const uint8_t *src, int byte_len, unsigned int flags)
{
if (!(flags & STR_ASCII) &&
(((flags & STR_UNICODE) || (bufinfo->flags & BUFINFO_FLAG_UNICODE)))) {
on failure *dest is set to the zero length string. This seems to
match win2000 behaviour
*/
-size_t req_pull_ascii4(struct request_bufinfo *bufinfo, const char **dest, const uint8_t *src, uint_t flags)
+size_t req_pull_ascii4(struct request_bufinfo *bufinfo, const char **dest, const uint8_t *src, unsigned int flags)
{
ssize_t ret;
/*
pull an open file handle from a packet, taking account of the chained_fnum
*/
-static uint16_t req_fnum(struct smbsrv_request *req, const uint8_t *base, uint_t offset)
+static uint16_t req_fnum(struct smbsrv_request *req, const uint8_t *base, unsigned int offset)
{
if (req->chained_fnum != -1) {
return req->chained_fnum;
return SVAL(base, offset);
}
-struct ntvfs_handle *smbsrv_pull_fnum(struct smbsrv_request *req, const uint8_t *base, uint_t offset)
+struct ntvfs_handle *smbsrv_pull_fnum(struct smbsrv_request *req, const uint8_t *base, unsigned int offset)
{
struct smbsrv_handle *handle;
uint16_t fnum = req_fnum(req, base, offset);
return handle->ntvfs;
}
-void smbsrv_push_fnum(uint8_t *base, uint_t offset, struct ntvfs_handle *ntvfs)
+void smbsrv_push_fnum(uint8_t *base, unsigned int offset, struct ntvfs_handle *ntvfs)
{
struct smbsrv_handle *handle = talloc_get_type(ntvfs->frontend_data.private_data,
struct smbsrv_handle);
struct smbsrv_request *req = state->op->req;
struct smb_trans2 *trans = state->op->trans;
uint8_t *data;
- uint_t ofs = trans->out.data.length;
+ unsigned int ofs = trans->out.data.length;
uint32_t ea_size;
switch (state->data_level) {
{
struct find_state *state = talloc_get_type(private_data, struct find_state);
struct smb_trans2 *trans = state->op->trans;
- uint_t old_length;
+ unsigned int old_length;
old_length = trans->out.data.length;
the negotiated buffer size */
do {
uint16_t this_data, this_param, max_bytes;
- uint_t align1 = 1, align2 = (params_left ? 2 : 0);
+ unsigned int align1 = 1, align2 = (params_left ? 2 : 0);
struct smbsrv_request *this_req;
max_bytes = req_max_data(req) - (align1 + align2);
return NT_STATUS_OK;
}
-struct ntvfs_handle *smb2srv_pull_handle(struct smb2srv_request *req, const uint8_t *base, uint_t offset)
+struct ntvfs_handle *smb2srv_pull_handle(struct smb2srv_request *req, const uint8_t *base, unsigned int offset)
{
struct smbsrv_tcon *tcon;
struct smbsrv_handle *handle;
return handle->ntvfs;
}
-void smb2srv_push_handle(uint8_t *base, uint_t offset, struct ntvfs_handle *ntvfs)
+void smb2srv_push_handle(uint8_t *base, unsigned int offset, struct ntvfs_handle *ntvfs)
{
struct smbsrv_handle *handle = talloc_get_type(ntvfs->frontend_data.private_data,
struct smbsrv_handle);
};
struct trunc_open_results {
- uint_t num;
+ unsigned int num;
uint32_t init_attr;
uint32_t trunc_attr;
uint32_t result_attr;
const char *fname = "\\openattr.file";
int fnum1;
uint16_t attr;
- uint_t i, j, k, l;
+ unsigned int i, j, k, l;
int failures = 0;
for (k = 0, i = 0; i < sizeof(open_attrs_table)/sizeof(uint32_t); i++) {
torture_comment(tctx, "[%d] getatr check failed. [0x%x] trunc [0x%x] got attr 0x%x, should be 0x%x\n",
k, open_attrs_table[i],
open_attrs_table[j],
- (uint_t)attr,
+ (unsigned int)attr,
attr_results[l].result_attr);
CHECK_MAX_FAILURES(error_exit);
}
for (i=0;i<torture_numops;i++)
{
- size_t buf_size = ((uint_t)random()%(sizeof(buf)-1))+ 1;
+ size_t buf_size = ((unsigned int)random()%(sizeof(buf)-1))+ 1;
if (i % 10 == 0) {
if (torture_setting_bool(tctx, "progress", true)) {
torture_comment(tctx, "%d\r", i); fflush(stdout);
};
-static void progress_bar(struct torture_context *tctx, uint_t i, uint_t total)
+static void progress_bar(struct torture_context *tctx, unsigned int i, unsigned int total)
{
if (torture_setting_bool(tctx, "progress", true)) {
torture_comment(tctx, "%5d/%5d\r", i, total);
/* TODO When redirecting stdout to a file, the progress bar really screws up
* the output. Could use a switch "--noprogress", or direct the progress bar to
* stderr? No other solution? */
-static void createx_progress_bar(struct torture_context *tctx, uint_t i,
- uint_t total, uint_t skipped)
+static void createx_progress_bar(struct torture_context *tctx, unsigned int i,
+ unsigned int total, unsigned int skipped)
{
if (torture_setting_bool(tctx, "progress", true)) {
torture_comment(tctx, "%5d/%5d (%d skipped)\r", i, total,
const char *fname = BASEDIR "\\lockt1.lck";
int fnum1, fnum2, fnum3;
time_t t1, t2;
- uint_t lock_timeout;
+ unsigned int lock_timeout;
if (!torture_setup_dir(cli1, BASEDIR)) {
return false;
"error: This server appears not to support timed lock requests");
}
torture_comment(tctx, "server slept for %u seconds for a %u second timeout\n",
- (uint_t)(t2-t1), lock_timeout);
+ (unsigned int)(t2-t1), lock_timeout);
torture_assert_ntstatus_ok(tctx, smbcli_close(cli1->tree, fnum2),
talloc_asprintf(tctx, "close1 failed (%s)", smbcli_errstr(cli1->tree)));
#define NAME_LENGTH 20
-static uint_t total, collisions, failures;
+static unsigned int total, collisions, failures;
static bool test_one(struct torture_context *tctx ,struct smbcli_state *cli,
const char *name)
static char *gen_name(TALLOC_CTX *mem_ctx)
{
const char *chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz._-$~...";
- uint_t max_idx = strlen(chars);
- uint_t len;
+ unsigned int max_idx = strlen(chars);
+ unsigned int len;
int i;
char *p;
char *name;
generate_random_buffer(buf, sizeof(buf));
for (i=0;i<torture_numops;i++) {
- uint_t n = (uint_t)random()%10;
+ unsigned int n = (unsigned int)random()%10;
if (i % 10 == 0) {
if (torture_setting_bool(tctx, "progress", true)) {
torture_comment(tctx, "%d\r", i);
int analyze;
int analyze_always;
int analyze_continuous;
- uint_t max_open_handles;
- uint_t seed;
- uint_t numops;
+ unsigned int max_open_handles;
+ unsigned int seed;
+ unsigned int numops;
int use_oplocks;
char **ignore_patterns;
const char *seeds_file;
/* mapping between open handles on the server and local handles */
static struct {
bool active;
- uint_t instance;
+ unsigned int instance;
struct smb2_handle smb2_handle[NSERVERS]; /* SMB2 */
uint16_t smb_handle[NSERVERS]; /* SMB */
const char *name;
} *open_handles;
-static uint_t num_open_handles;
+static unsigned int num_open_handles;
/* state information for the servers. We open NINSTANCES connections to
each server */
/* the seeds and flags for each operation */
static struct {
- uint_t seed;
+ unsigned int seed;
bool disabled;
} *op_parms;
/* info relevant to the current operation */
static struct {
const char *name;
- uint_t seed;
+ unsigned int seed;
NTSTATUS status;
- uint_t opnum;
+ unsigned int opnum;
TALLOC_CTX *mem_ctx;
const char *mismatch;
} current_op;
/*
work out the time skew between the servers - be conservative
*/
-static uint_t time_skew(void)
+static unsigned int time_skew(void)
{
- uint_t ret;
+ unsigned int ret;
if (options.smb2) {
ret = labs(servers[0].smb2_tree[0]->session->transport->negotiate.system_time -
servers[1].smb2_tree[0]->session->transport->negotiate.system_time);
/*
turn a server handle into a local handle
*/
-static uint_t fnum_to_handle_smb2(int server, int instance, struct smb2_handle server_handle)
+static unsigned int fnum_to_handle_smb2(int server, int instance, struct smb2_handle server_handle)
{
- uint_t i;
+ unsigned int i;
for (i=0;i<options.max_open_handles;i++) {
if (!open_handles[i].active ||
instance != open_handles[i].instance) continue;
/*
turn a server handle into a local handle
*/
-static uint_t fnum_to_handle_smb(int server, int instance, uint16_t server_handle)
+static unsigned int fnum_to_handle_smb(int server, int instance, uint16_t server_handle)
{
- uint_t i;
+ unsigned int i;
for (i=0;i<options.max_open_handles;i++) {
if (!open_handles[i].active ||
instance != open_handles[i].instance) continue;
/*
return true with 'chance' probability as a percentage
*/
-static bool gen_chance(uint_t chance)
+static bool gen_chance(unsigned int chance)
{
return ((random() % 100) <= chance);
}
*/
static int gen_int_range(uint64_t min, uint64_t max)
{
- uint_t r = random();
+ unsigned int r = random();
return min + (r % (1+max-min));
}
/*
generate a bitmask
*/
-static uint32_t gen_bits_mask(uint_t mask)
+static uint32_t gen_bits_mask(unsigned int mask)
{
- uint_t ret = random();
+ unsigned int ret = random();
return ret & mask;
}
/*
generate a file allocation size
*/
-static uint_t gen_alloc_size(void)
+static unsigned int gen_alloc_size(void)
{
- uint_t ret;
+ unsigned int ret;
if (gen_chance(30)) return 0;
static int analyze;
static int hide_unlock_fails;
static int use_oplocks;
-static uint_t lock_range = 100;
-static uint_t lock_base = 0;
-static uint_t min_length = 0;
+static unsigned int lock_range = 100;
+static unsigned int lock_base = 0;
+static unsigned int min_length = 0;
static int exact_error_codes;
static int zero_zero;
int fnum[NSERVERS][NCONNECTIONS][NFILES],
struct record *rec)
{
- uint_t conn = rec->conn;
- uint_t f = rec->f;
+ unsigned int conn = rec->conn;
+ unsigned int f = rec->f;
uint64_t start = rec->start;
uint64_t len = rec->len;
enum brl_type op = rec->lock_type;
#endif
recorded[n].conn = random() % NCONNECTIONS;
recorded[n].f = random() % NFILES;
- recorded[n].start = lock_base + ((uint_t)random() % (lock_range-1));
+ recorded[n].start = lock_base + ((unsigned int)random() % (lock_range-1));
recorded[n].len = min_length +
random() % (lock_range-(recorded[n].start-lock_base));
recorded[n].start *= RANGE_MULTIPLE;
struct record {
char r1, r2;
char conn, f, fstype;
- uint_t start, len;
+ unsigned int start, len;
char needed;
};
}
static bool try_lock(struct smbcli_state *c, int fstype,
- int fd, uint_t start, uint_t len,
+ int fd, unsigned int start, unsigned int len,
enum brl_type op)
{
struct flock lock;
}
static bool try_unlock(struct smbcli_state *c, int fstype,
- int fd, uint_t start, uint_t len)
+ int fd, unsigned int start, unsigned int len)
{
struct flock lock;
int fnum[NSERVERS][NUMFSTYPES][NCONNECTIONS][NFILES],
struct record *rec)
{
- uint_t conn = rec->conn;
- uint_t f = rec->f;
- uint_t fstype = rec->fstype;
- uint_t start = rec->start;
- uint_t len = rec->len;
- uint_t r1 = rec->r1;
- uint_t r2 = rec->r2;
+ unsigned int conn = rec->conn;
+ unsigned int f = rec->f;
+ unsigned int fstype = rec->fstype;
+ unsigned int start = rec->start;
+ unsigned int len = rec->len;
+ unsigned int r1 = rec->r1;
+ unsigned int r2 = rec->r2;
enum brl_type op;
int server;
bool ret[NSERVERS];
recorded[n].conn = random() % NCONNECTIONS;
recorded[n].fstype = random() % NUMFSTYPES;
recorded[n].f = random() % NFILES;
- recorded[n].start = LOCKBASE + ((uint_t)random() % (LOCKRANGE-1));
+ recorded[n].start = LOCKBASE + ((unsigned int)random() % (LOCKRANGE-1));
recorded[n].len = 1 +
random() % (LOCKRANGE-(recorded[n].start-LOCKBASE));
recorded[n].start *= RANGE_MULTIPLE;
struct createx_params {
char *fname;
- uint_t create_options;
- uint_t create_disposition;
+ unsigned int create_options;
+ unsigned int create_disposition;
int handle;
};
static bool nb_do_createx(struct ftable *f,
const char *fname,
- uint_t create_options,
- uint_t create_disposition,
+ unsigned int create_options,
+ unsigned int create_disposition,
int handle,
NTSTATUS status,
bool retry);
static void nb_set_createx_params(struct ftable *f,
const char *fname,
- uint_t create_options,
- uint_t create_disposition,
+ unsigned int create_options,
+ unsigned int create_disposition,
int handle)
{
struct createx_params *cp = &f->cp;
static bool nb_do_createx(struct ftable *f,
const char *fname,
- uint_t create_options,
- uint_t create_disposition,
+ unsigned int create_options,
+ unsigned int create_disposition,
int handle,
NTSTATUS status,
bool retry)
uint32_t desired_access;
NTSTATUS ret;
TALLOC_CTX *mem_ctx;
- uint_t flags = 0;
+ unsigned int flags = 0;
mem_ctx = talloc_init("raw_open");
}
bool nb_createx(const char *fname,
- uint_t create_options, uint_t create_disposition, int handle,
+ unsigned int create_options, unsigned int create_disposition, int handle,
NTSTATUS status)
{
return nb_do_createx(NULL, fname, create_options, create_disposition, handle, status, false);
return nb_do_lockx(false, handle, offset, size, status);
}
-bool nb_unlockx(int handle, uint_t offset, int size, NTSTATUS status)
+bool nb_unlockx(int handle, unsigned int offset, int size, NTSTATUS status)
{
union smb_lock io;
int i;
static struct {
const char *name;
enum smb_fileinfo_level level;
- uint_t only_paths:1;
- uint_t only_handles:1;
+ unsigned int only_paths:1;
+ unsigned int only_handles:1;
uint32_t capability_mask;
- uint_t expected_ipc_access_denied:1;
+ unsigned int expected_ipc_access_denied:1;
NTSTATUS expected_ipc_fnum_status;
NTSTATUS fnum_status, fname_status;
union smb_fileinfo fnum_finfo, fname_finfo;
/* local macros to make the code below more readable */
#define VAL_EQUAL(n1, v1, n2, v2) do {if (s1->n1.out.v1 != s2->n2.out.v2) { \
printf("%s/%s [%u] != %s/%s [%u] at %s(%d)\n", \
- #n1, #v1, (uint_t)s1->n1.out.v1, \
- #n2, #v2, (uint_t)s2->n2.out.v2, \
+ #n1, #v1, (unsigned int)s1->n1.out.v1, \
+ #n2, #v2, (unsigned int)s2->n2.out.v2, \
__FILE__, __LINE__); \
ret = false; \
}} while(0)
#define VAL_UNKNOWN(n1, v1) do {if (s1->n1.out.v1 != 0) { \
printf("%s/%s non-zero unknown - %u (0x%x) at %s(%d)\n", \
#n1, #v1, \
- (uint_t)s1->n1.out.v1, \
- (uint_t)s1->n1.out.v1, \
+ (unsigned int)s1->n1.out.v1, \
+ (unsigned int)s1->n1.out.v1, \
__FILE__, __LINE__); \
ret = false; \
}} while(0)
s1 = fnum_find(sname); \
if (s1 && s1->stype.out.tfield != correct_size) { \
printf("(%d) handle %s/%s incorrect - %u should be %u\n", __LINE__, #stype, #tfield, \
- (uint_t)s1->stype.out.tfield, \
- (uint_t)correct_size); \
+ (unsigned int)s1->stype.out.tfield, \
+ (unsigned int)correct_size); \
ret = false; \
} \
s1 = fname_find(is_ipc, sname); \
if (s1 && s1->stype.out.tfield != correct_size) { \
printf("(%d) path %s/%s incorrect - %u should be %u\n", __LINE__, #stype, #tfield, \
- (uint_t)s1->stype.out.tfield, \
- (uint_t)correct_size); \
+ (unsigned int)s1->stype.out.tfield, \
+ (unsigned int)correct_size); \
ret = false; \
}} while (0)
s1 = fnum_find("STANDARD_INFO");
correct_size = s1->standard_info.out.size;
- torture_comment(torture, "size: %u\n", (uint_t)correct_size);
+ torture_comment(torture, "size: %u\n", (unsigned int)correct_size);
SIZE_CHECK("GETATTR", getattr, size);
SIZE_CHECK("GETATTRE", getattre, size);
s1 = fnum_find("STANDARD_INFO");
correct_size = s1->standard_info.out.alloc_size;
- torture_comment(torture, "alloc_size: %u\n", (uint_t)correct_size);
+ torture_comment(torture, "alloc_size: %u\n", (unsigned int)correct_size);
SIZE_CHECK("GETATTRE", getattre, alloc_size);
SIZE_CHECK("STANDARD", standard, alloc_size);
s1 = fnum_find(sname); \
if (s1 && s1->stype.out.tfield != correct_attrib) { \
printf("(%d) handle %s/%s incorrect - 0x%x should be 0x%x\n", __LINE__, #stype, #tfield, \
- (uint_t)s1->stype.out.tfield, \
- (uint_t)correct_attrib); \
+ (unsigned int)s1->stype.out.tfield, \
+ (unsigned int)correct_attrib); \
ret = false; \
} \
s1 = fname_find(is_ipc, sname); \
if (s1 && s1->stype.out.tfield != correct_attrib) { \
printf("(%d) path %s/%s incorrect - 0x%x should be 0x%x\n", __LINE__, #stype, #tfield, \
- (uint_t)s1->stype.out.tfield, \
- (uint_t)correct_attrib); \
+ (unsigned int)s1->stype.out.tfield, \
+ (unsigned int)correct_attrib); \
ret = false; \
}} while (0)
s1 = fnum_find("BASIC_INFO");
correct_attrib = s1->basic_info.out.attrib;
- torture_comment(torture, "attrib: 0x%x\n", (uint_t)correct_attrib);
+ torture_comment(torture, "attrib: 0x%x\n", (unsigned int)correct_attrib);
ATTRIB_CHECK("GETATTR", getattr, attrib);
if (!is_ipc) {
if (s1 && s1->stype.out.tfield != 0) { \
printf("(%d) handle %s/%s unknown != 0 (0x%x)\n", __LINE__, \
#stype, #tfield, \
- (uint_t)s1->stype.out.tfield); \
+ (unsigned int)s1->stype.out.tfield); \
} \
s1 = fname_find(is_ipc, sname); \
if (s1 && s1->stype.out.tfield != 0) { \
printf("(%d) path %s/%s unknown != 0 (0x%x)\n", __LINE__, \
#stype, #tfield, \
- (uint_t)s1->stype.out.tfield); \
+ (unsigned int)s1->stype.out.tfield); \
}} while (0)
#endif
/* now get a bit fancier .... */
/* local macros to make the code below more readable */
#define VAL_EQUAL(n1, v1, n2, v2) do {if (s1->n1.out.v1 != s2->n2.out.v2) { \
printf("%s/%s [%u] != %s/%s [%u] at %s(%d)\n", \
- #n1, #v1, (uint_t)s1->n1.out.v1, \
- #n2, #v2, (uint_t)s2->n2.out.v2, \
+ #n1, #v1, (unsigned int)s1->n1.out.v1, \
+ #n2, #v2, (unsigned int)s2->n2.out.v2, \
__FILE__, __LINE__); \
ret = false; \
}} while(0)
#define VAL_APPROX_EQUAL(n1, v1, n2, v2) do {if (abs((int)(s1->n1.out.v1) - (int)(s2->n2.out.v2)) > 0.1*s1->n1.out.v1) { \
printf("%s/%s [%u] != %s/%s [%u] at %s(%d)\n", \
- #n1, #v1, (uint_t)s1->n1.out.v1, \
- #n2, #v2, (uint_t)s2->n2.out.v2, \
+ #n1, #v1, (unsigned int)s1->n1.out.v1, \
+ #n2, #v2, (unsigned int)s2->n2.out.v2, \
__FILE__, __LINE__); \
ret = false; \
}} while(0)
#define VAL_UNKNOWN(n1, v1) do {if (s1->n1.out.v1 != 0) { \
printf("%s/%s non-zero unknown - %u (0x%x) at %s(%d)\n", \
#n1, #v1, \
- (uint_t)s1->n1.out.v1, \
- (uint_t)s1->n1.out.v1, \
+ (unsigned int)s1->n1.out.v1, \
+ (unsigned int)s1->n1.out.v1, \
__FILE__, __LINE__); \
ret = false; \
}} while(0)
/*
setup a random buffer based on a seed
*/
-static void setup_buffer(uint8_t *buf, uint_t seed, int len)
+static void setup_buffer(uint8_t *buf, unsigned int seed, int len)
{
int i;
srandom(seed);
/*
check a random buffer based on a seed
*/
-static bool check_buffer(uint8_t *buf, uint_t seed, int len, int line)
+static bool check_buffer(uint8_t *buf, unsigned int seed, int len, int line)
{
int i;
srandom(seed);
const int maxsize = 90000;
const char *fname = BASEDIR "\\test.txt";
const char *test_data = "TEST DATA";
- uint_t seed = time(NULL);
+ unsigned int seed = time(NULL);
buf = talloc_zero_array(tctx, uint8_t, maxsize);
const int maxsize = 90000;
const char *fname = BASEDIR "\\test.txt";
const char *test_data = "TEST DATA";
- uint_t seed = time(NULL);
+ unsigned int seed = time(NULL);
if (!cli->transport->negotiate.lockread_supported) {
printf("Server does not support lockread - skipping\n");
const int maxsize = 90000;
const char *fname = BASEDIR "\\test.txt";
const char *test_data = "TEST DATA";
- uint_t seed = time(NULL);
+ unsigned int seed = time(NULL);
buf = talloc_zero_array(tctx, uint8_t, maxsize);
const int maxsize = 90000;
const char *fname = BASEDIR "\\test.txt";
const char *test_data = "TEST DATA";
- uint_t seed = time(NULL);
+ unsigned int seed = time(NULL);
if (!cli->transport->negotiate.readbraw_supported) {
printf("Server does not support readbraw - skipping\n");
static NTSTATUS raw_smbcli_open(struct smbcli_tree *tree, const char *fname, int flags, int share_mode, int *fnum)
{
union smb_open open_parms;
- uint_t openfn=0;
- uint_t accessmode=0;
+ unsigned int openfn=0;
+ unsigned int accessmode=0;
TALLOC_CTX *mem_ctx;
NTSTATUS status;
static NTSTATUS raw_smbcli_t2open(struct smbcli_tree *tree, const char *fname, int flags, int share_mode, int *fnum)
{
union smb_open io;
- uint_t openfn=0;
- uint_t accessmode=0;
+ unsigned int openfn=0;
+ unsigned int accessmode=0;
TALLOC_CTX *mem_ctx;
NTSTATUS status;
if (NT_STATUS_IS_OK(status) && NT_STATUS_IS_OK(status2) && finfo2.stype.out.field != value) { \
printf("(%s) %s - %s/%s should be 0x%x - 0x%x\n", __location__, \
call_name, #stype, #field, \
- (uint_t)value, (uint_t)finfo2.stype.out.field); \
+ (unsigned int)value, (unsigned int)finfo2.stype.out.field); \
dump_all_info(torture, &finfo1); \
ret = false; \
}} while (0)
if (NT_STATUS_IS_OK(status) && NT_STATUS_IS_OK(status2) && nt_time_to_unix(finfo2.stype.out.field) != value) { \
printf("(%s) %s - %s/%s should be 0x%x - 0x%x\n", __location__, \
call_name, #stype, #field, \
- (uint_t)value, \
- (uint_t)nt_time_to_unix(finfo2.stype.out.field)); \
+ (unsigned int)value, \
+ (unsigned int)nt_time_to_unix(finfo2.stype.out.field)); \
printf("\t%s", timestring(torture, value)); \
printf("\t%s\n", nt_time_string(torture, finfo2.stype.out.field)); \
dump_all_info(torture, &finfo1); \
/*
setup a random buffer based on a seed
*/
-static void setup_buffer(uint8_t *buf, uint_t seed, int len)
+static void setup_buffer(uint8_t *buf, unsigned int seed, int len)
{
int i;
srandom(seed);
/*
check a random buffer based on a seed
*/
-static bool check_buffer(uint8_t *buf, uint_t seed, int len, const char *location)
+static bool check_buffer(uint8_t *buf, unsigned int seed, int len, const char *location)
{
int i;
srandom(seed);
uint8_t *buf;
const int maxsize = 90000;
const char *fname = BASEDIR "\\test.txt";
- uint_t seed = time(NULL);
+ unsigned int seed = time(NULL);
union smb_fileinfo finfo;
buf = talloc_zero_array(tctx, uint8_t, maxsize);
uint8_t *buf;
const int maxsize = 90000;
const char *fname = BASEDIR "\\test.txt";
- uint_t seed = time(NULL);
+ unsigned int seed = time(NULL);
union smb_fileinfo finfo;
int max_bits=63;
uint8_t *buf;
const int maxsize = 90000;
const char *fname = BASEDIR "\\test.txt";
- uint_t seed = time(NULL);
+ unsigned int seed = time(NULL);
union smb_fileinfo finfo;
buf = talloc_zero_array(tctx, uint8_t, maxsize);
uint8_t *buf;
const int maxsize = 90000;
const char *fname = BASEDIR "\\test.txt";
- uint_t seed = time(NULL);
+ unsigned int seed = time(NULL);
union smb_fileinfo finfo;
buf = talloc_zero_array(tctx, uint8_t, maxsize);
talloc_asprintf(tctx, "TestSleep(%d) failed", i));
torture_assert(tctx, r[i].out.result == r[i].in.seconds,
talloc_asprintf(tctx, "Failed - Asked to sleep for %u seconds (server replied with %u seconds and the reply takes only %u seconds)",
- r[i].out.result, r[i].in.seconds, (uint_t)diff[i].tv_sec));
+ r[i].out.result, r[i].in.seconds, (unsigned int)diff[i].tv_sec));
torture_assert(tctx, r[i].out.result <= rounded_tdiff,
talloc_asprintf(tctx, "Failed - Slept for %u seconds (but reply takes only %u.%06u seconds)",
- r[i].out.result, (uint_t)diff[i].tv_sec, (uint_t)diff[i].tv_usec));
+ r[i].out.result, (unsigned int)diff[i].tv_sec, (unsigned int)diff[i].tv_usec));
if (r[i].out.result+1 == rounded_tdiff) {
torture_comment(tctx, "Slept for %u seconds (but reply takes %u.%06u seconds - busy server?)\n",
- r[i].out.result, (uint_t)diff[i].tv_sec, (uint_t)diff[i].tv_usec);
+ r[i].out.result, (unsigned int)diff[i].tv_sec, (unsigned int)diff[i].tv_usec);
} else if (r[i].out.result == rounded_tdiff) {
torture_comment(tctx, "Slept for %u seconds (reply takes %u.%06u seconds - ok)\n",
- r[i].out.result, (uint_t)diff[i].tv_sec, (uint_t)diff[i].tv_usec);
+ r[i].out.result, (unsigned int)diff[i].tv_sec, (unsigned int)diff[i].tv_usec);
} else {
torture_comment(tctx, "(Failed) - Not async - Slept for %u seconds (but reply takes %u.%06u seconds)",
- r[i].out.result, (uint_t)diff[i].tv_sec, (uint_t)diff[i].tv_usec);
+ r[i].out.result, (unsigned int)diff[i].tv_sec, (unsigned int)diff[i].tv_usec);
/* TODO: let the test fail here, when we support async rpc on ncacn_np */
}
}
const int LOCAL = 0;
const int GLOBAL = 1;
- secname[LOCAL] = talloc_asprintf(tctx, "torturesecret-%u", (uint_t)random());
- secname[GLOBAL] = talloc_asprintf(tctx, "G$torturesecret-%u", (uint_t)random());
+ secname[LOCAL] = talloc_asprintf(tctx, "torturesecret-%u", (unsigned int)random());
+ secname[GLOBAL] = talloc_asprintf(tctx, "G$torturesecret-%u", (unsigned int)random());
for (i=0; i< 2; i++) {
torture_comment(tctx, "\nTesting CreateSecret of %s\n", secname[i]);
char *secret2;
char *secname;
- secname = talloc_asprintf(tctx, "torturesecret-%u", (uint_t)random());
+ secname = talloc_asprintf(tctx, "torturesecret-%u", (unsigned int)random());
torture_comment(tctx, "Testing CreateSecret of %s\n", secname);
struct file_elem files[NFILES] = {};
NTSTATUS status;
bool ret = true;
- uint_t count;
+ unsigned int count;
int i, j, file_count = 0;
status = populate_tree(tctx, mem_ctx, tree, files, NFILES, &h);
struct file_elem files[NFILES] = {};
NTSTATUS status;
bool ret = true;
- uint_t count;
+ unsigned int count;
int i;
status = populate_tree(tctx, mem_ctx, tree, files, NFILES, &h);
static bool fill_level_data(TALLOC_CTX *mem_ctx,
union smb_search_data *data,
union smb_search_data *d,
- uint_t count,
+ unsigned int count,
uint8_t level,
enum smb_search_data_level data_level)
{
enum smb_search_data_level data_level,
int idx,
union smb_search_data *d,
- uint_t *count,
+ unsigned int *count,
struct smb2_handle *h)
{
struct smb2_find f;
const char *fname = "torture_search.txt";
NTSTATUS status;
int i;
- uint_t count;
+ unsigned int count;
union smb_fileinfo all_info2, alt_info, internal_info;
union smb_search_data *s;
union smb_search_data d;
{
struct smb2_find f;
bool ret = true;
- uint_t count = 0;
+ unsigned int count = 0;
union smb_search_data *d;
NTSTATUS status;
struct multiple_result *result = (struct multiple_result *)data;
NTSTATUS status;
bool ret = true;
int i;
- uint_t count;
+ unsigned int count;
smb2_deltree(tree, DNAME);
if (NT_STATUS_IS_OK(status) && NT_STATUS_IS_OK(status2) && finfo2.stype.out.field != value) { \
torture_result(tctx, TORTURE_FAIL, "(%s) %s - %s/%s should be 0x%x - 0x%x\n", __location__, \
call_name, #stype, #field, \
- (uint_t)value, (uint_t)finfo2.stype.out.field); \
+ (unsigned int)value, (unsigned int)finfo2.stype.out.field); \
torture_smb2_all_info(tree, handle); \
ret = false; \
goto done; \
if (NT_STATUS_IS_OK(status) && NT_STATUS_IS_OK(status2) && nt_time_to_unix(finfo2.stype.out.field) != value) { \
torture_result(tctx, TORTURE_FAIL, "(%s) %s - %s/%s should be 0x%x - 0x%x\n", __location__, \
call_name, #stype, #field, \
- (uint_t)value, \
- (uint_t)nt_time_to_unix(finfo2.stype.out.field)); \
+ (unsigned int)value, \
+ (unsigned int)nt_time_to_unix(finfo2.stype.out.field)); \
torture_warning(tctx, "\t%s", timestring(tctx, value)); \
torture_warning(tctx, "\t%s\n", nt_time_string(tctx, finfo2.stype.out.field)); \
torture_smb2_all_info(tree, handle); \
git.samba.org / samba.git / commitdiff