/**
\details Push a int32_t
int32_t is a signed long which values goes from -2147483647 to 2147483647
\param push Pointer to the mapirops_push structure
\param v int32_t value to push
\return MAPIROPS_ERR_SUCCESS on success, otherwise MAPIROPS error
*/
enum mapirops_err_code mapirops_push_int32(struct mapirops_push *push, int32_t v)
{
MAPIROPS_PUSH_NEED_BYTES(push, 4);
SIVALS(push->data.data, push->offset, v);
push->offset += 4;
return MAPIROPS_ERR_SUCCESS;
}
BOOL cli_lock64(struct cli_state *cli, int fnum,
SMB_BIG_UINT offset, SMB_BIG_UINT len, int timeout, enum brl_type lock_type)
{
char *p;
int saved_timeout = cli->timeout;
int ltype;
if (! (cli->capabilities & CAP_LARGE_FILES)) {
return cli_lock(cli, fnum, offset, len, timeout, lock_type);
}
ltype = (lock_type == READ_LOCK? 1 : 0);
ltype |= LOCKING_ANDX_LARGE_FILES;
memset(cli->outbuf,'\0',smb_size);
memset(cli->inbuf,'\0', smb_size);
set_message(cli->outbuf,8,0,True);
SCVAL(cli->outbuf,smb_com,SMBlockingX);
SSVAL(cli->outbuf,smb_tid,cli->cnum);
cli_setup_packet(cli);
SCVAL(cli->outbuf,smb_vwv0,0xFF);
SSVAL(cli->outbuf,smb_vwv2,fnum);
SCVAL(cli->outbuf,smb_vwv3,ltype);
SIVALS(cli->outbuf, smb_vwv4, timeout);
SSVAL(cli->outbuf,smb_vwv6,0);
SSVAL(cli->outbuf,smb_vwv7,1);
p = smb_buf(cli->outbuf);
SIVAL(p, 0, cli->pid);
SOFF_T_R(p, 4, offset);
SOFF_T_R(p, 12, len);
p += 20;
cli_setup_bcc(cli, p);
cli_send_smb(cli);
if (timeout != 0) {
cli->timeout = (timeout == -1) ? 0x7FFFFFFF : (timeout + 5*1000);
}
if (!cli_receive_smb(cli)) {
cli->timeout = saved_timeout;
return False;
}
cli->timeout = saved_timeout;
if (cli_is_error(cli)) {
return False;
}
return True;
}
/****************************************************************************
Lock a file.
note that timeout is in units of 2 milliseconds
****************************************************************************/
BOOL cli_lock(struct cli_state *cli, int fnum,
uint32 offset, uint32 len, int timeout, enum brl_type lock_type)
{
char *p;
int saved_timeout = cli->timeout;
memset(cli->outbuf,'\0',smb_size);
memset(cli->inbuf,'\0', smb_size);
set_message(cli->outbuf,8,0,True);
SCVAL(cli->outbuf,smb_com,SMBlockingX);
SSVAL(cli->outbuf,smb_tid,cli->cnum);
cli_setup_packet(cli);
SCVAL(cli->outbuf,smb_vwv0,0xFF);
SSVAL(cli->outbuf,smb_vwv2,fnum);
SCVAL(cli->outbuf,smb_vwv3,(lock_type == READ_LOCK? 1 : 0));
SIVALS(cli->outbuf, smb_vwv4, timeout);
SSVAL(cli->outbuf,smb_vwv6,0);
SSVAL(cli->outbuf,smb_vwv7,1);
p = smb_buf(cli->outbuf);
SSVAL(p, 0, cli->pid);
SIVAL(p, 2, offset);
SIVAL(p, 6, len);
p += 10;
cli_setup_bcc(cli, p);
cli_send_smb(cli);
if (timeout != 0) {
cli->timeout = (timeout == -1) ? 0x7FFFFFFF : (timeout*2 + 5*1000);
}
if (!cli_receive_smb(cli)) {
cli->timeout = saved_timeout;
return False;
}
cli->timeout = saved_timeout;
if (cli_is_error(cli)) {
return False;
}
return True;
}
int cli_ctemp(struct cli_state *cli, const char *path, char **tmp_path)
{
int len;
char *p;
memset(cli->outbuf,'\0',smb_size);
memset(cli->inbuf,'\0',smb_size);
set_message(cli->outbuf,3,0,True);
SCVAL(cli->outbuf,smb_com,SMBctemp);
SSVAL(cli->outbuf,smb_tid,cli->cnum);
cli_setup_packet(cli);
SSVAL(cli->outbuf,smb_vwv0,0);
SIVALS(cli->outbuf,smb_vwv1,-1);
p = smb_buf(cli->outbuf);
*p++ = 4;
p += clistr_push(cli, p, path, -1, STR_TERMINATE);
cli_setup_bcc(cli, p);
cli_send_smb(cli);
if (!cli_receive_smb(cli)) {
return -1;
}
if (cli_is_error(cli)) {
return -1;
}
/* despite the spec, the result has a -1, followed by
length, followed by name */
p = smb_buf(cli->inbuf);
p += 4;
len = smb_buflen(cli->inbuf) - 4;
if (len <= 0) return -1;
if (tmp_path) {
pstring path2;
clistr_pull(cli, path2, p,
sizeof(path2), len, STR_ASCII);
*tmp_path = strdup(path2);
}
return SVAL(cli->inbuf,smb_vwv0);
}
/****************************************************************************
send a lock with a specified locktype
this is used for testing LOCKING_ANDX_CANCEL_LOCK
****************************************************************************/
NTSTATUS cli_locktype(struct cli_state *cli, int fnum,
uint32 offset, uint32 len, int timeout, unsigned char locktype)
{
char *p;
int saved_timeout = cli->timeout;
memset(cli->outbuf,'\0',smb_size);
memset(cli->inbuf,'\0', smb_size);
set_message(cli->outbuf,8,0,True);
SCVAL(cli->outbuf,smb_com,SMBlockingX);
SSVAL(cli->outbuf,smb_tid,cli->cnum);
cli_setup_packet(cli);
SCVAL(cli->outbuf,smb_vwv0,0xFF);
SSVAL(cli->outbuf,smb_vwv2,fnum);
SCVAL(cli->outbuf,smb_vwv3,locktype);
SIVALS(cli->outbuf, smb_vwv4, timeout);
SSVAL(cli->outbuf,smb_vwv6,0);
SSVAL(cli->outbuf,smb_vwv7,1);
p = smb_buf(cli->outbuf);
SSVAL(p, 0, cli->pid);
SIVAL(p, 2, offset);
SIVAL(p, 6, len);
p += 10;
cli_setup_bcc(cli, p);
cli_send_smb(cli);
if (timeout != 0) {
cli->timeout = (timeout == -1) ? 0x7FFFFFFF : (timeout + 2*1000);
}
if (!cli_receive_smb(cli)) {
cli->timeout = saved_timeout;
return NT_STATUS_UNSUCCESSFUL;
}
cli->timeout = saved_timeout;
return cli_nt_error(cli);
}
BOOL cli_unlock64(struct cli_state *cli, int fnum, SMB_BIG_UINT offset, SMB_BIG_UINT len)
{
char *p;
if (! (cli->capabilities & CAP_LARGE_FILES)) {
return cli_unlock(cli, fnum, offset, len);
}
memset(cli->outbuf,'\0',smb_size);
memset(cli->inbuf,'\0',smb_size);
set_message(cli->outbuf,8,0,True);
SCVAL(cli->outbuf,smb_com,SMBlockingX);
SSVAL(cli->outbuf,smb_tid,cli->cnum);
cli_setup_packet(cli);
SCVAL(cli->outbuf,smb_vwv0,0xFF);
SSVAL(cli->outbuf,smb_vwv2,fnum);
SCVAL(cli->outbuf,smb_vwv3,LOCKING_ANDX_LARGE_FILES);
SIVALS(cli->outbuf, smb_vwv4, 0);
SSVAL(cli->outbuf,smb_vwv6,1);
SSVAL(cli->outbuf,smb_vwv7,0);
p = smb_buf(cli->outbuf);
SIVAL(p, 0, cli->pid);
SOFF_T_R(p, 4, offset);
SOFF_T_R(p, 12, len);
p += 20;
cli_setup_bcc(cli, p);
cli_send_smb(cli);
if (!cli_receive_smb(cli)) {
return False;
}
if (cli_is_error(cli)) {
return False;
}
return True;
}
BOOL cli_close(struct cli_state *cli, int fnum)
{
memset(cli->outbuf,'\0',smb_size);
memset(cli->inbuf,'\0',smb_size);
set_message(cli->outbuf,3,0,True);
SCVAL(cli->outbuf,smb_com,SMBclose);
SSVAL(cli->outbuf,smb_tid,cli->cnum);
cli_setup_packet(cli);
SSVAL(cli->outbuf,smb_vwv0,fnum);
SIVALS(cli->outbuf,smb_vwv1,-1);
cli_send_smb(cli);
if (!cli_receive_smb(cli)) {
return False;
}
return !cli_is_error(cli);
}
static WERROR dsdb_syntax_INT32_ldb_to_drsuapi(struct ldb_context *ldb,
const struct dsdb_schema *schema,
const struct dsdb_attribute *attr,
const struct ldb_message_element *in,
TALLOC_CTX *mem_ctx,
struct drsuapi_DsReplicaAttribute *out)
{
uint32_t i;
DATA_BLOB *blobs;
if (attr->attributeID_id == 0xFFFFFFFF) {
return WERR_FOOBAR;
}
out->attid = attr->attributeID_id;
out->value_ctr.num_values = in->num_values;
out->value_ctr.values = talloc_array(mem_ctx,
struct drsuapi_DsAttributeValue,
in->num_values);
W_ERROR_HAVE_NO_MEMORY(out->value_ctr.values);
blobs = talloc_array(mem_ctx, DATA_BLOB, in->num_values);
W_ERROR_HAVE_NO_MEMORY(blobs);
for (i=0; i < in->num_values; i++) {
int32_t v;
out->value_ctr.values[i].blob = &blobs[i];
blobs[i] = data_blob_talloc(blobs, NULL, 4);
W_ERROR_HAVE_NO_MEMORY(blobs[i].data);
v = strtol((const char *)in->values[i].data, NULL, 10);
SIVALS(blobs[i].data, 0, v);
}
return WERR_OK;
}
int buffer_add_int32(xrtp_buffer_t * buf, int32 dword)
{
if(buf->len_data + sizeof(int32) > buf->len)
{
return OS_EREFUSE;
}
if(buf->byte_order == BIGEND_ORDER)
{
buffer_log(("buffer_add_int32: Add BE(%d) to buf[%d]@%d\n", dword, buf->pos, (int)buf->data));
RSIVALS(buf->data, buf->len_data, dword);
}
else
{
buffer_log(("buffer_add_int32: Add LE(%d) to buf[%d]@%d\n", dword, buf->pos, (int)buf->data));
SIVALS(buf->data, buf->len_data, dword);
}
buf->len_data += sizeof(int32);
buf->pos += sizeof(int32);
return OS_OK;
}
BOOL cli_unlock(struct cli_state *cli, int fnum, uint32 offset, uint32 len)
{
char *p;
memset(cli->outbuf,'\0',smb_size);
memset(cli->inbuf,'\0',smb_size);
set_message(cli->outbuf,8,0,True);
SCVAL(cli->outbuf,smb_com,SMBlockingX);
SSVAL(cli->outbuf,smb_tid,cli->cnum);
cli_setup_packet(cli);
SCVAL(cli->outbuf,smb_vwv0,0xFF);
SSVAL(cli->outbuf,smb_vwv2,fnum);
SCVAL(cli->outbuf,smb_vwv3,0);
SIVALS(cli->outbuf, smb_vwv4, 0);
SSVAL(cli->outbuf,smb_vwv6,1);
SSVAL(cli->outbuf,smb_vwv7,0);
p = smb_buf(cli->outbuf);
SSVAL(p, 0, cli->pid);
SIVAL(p, 2, offset);
SIVAL(p, 6, len);
p += 10;
cli_setup_bcc(cli, p);
cli_send_smb(cli);
if (!cli_receive_smb(cli)) {
return False;
}
if (cli_is_error(cli)) {
return False;
}
return True;
}
bool prs_int32(const char *name, prs_struct *ps, int depth, int32 *data32)
{
char *q = prs_mem_get(ps, sizeof(int32));
if (q == NULL)
return False;
if (UNMARSHALLING(ps)) {
if (ps->bigendian_data)
*data32 = RIVALS(q,0);
else
*data32 = IVALS(q,0);
} else {
if (ps->bigendian_data)
RSIVALS(q,0,*data32);
else
SIVALS(q,0,*data32);
}
DEBUGADD(5,("%s%04x %s: %08x\n", tab_depth(5,depth), ps->data_offset, name, *data32));
ps->data_offset += sizeof(int32);
return True;
}
