Exemple #1
0
NTSTATUS ndr_pull_CIMSTRING(struct ndr_pull *ndr, int ndr_flags, CIMSTRING *r)
{
	uint8_t u;
	NTSTATUS status;

        if (!(ndr_flags & NDR_SCALARS)) return NT_STATUS_OK;

        NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &u));
	switch (u) {
	case 0:
		u = ndr->flags;
		ndr->flags |= LIBNDR_FLAG_STR_ASCII | LIBNDR_FLAG_STR_NULLTERM;
		status = ndr_pull_string(ndr, NDR_SCALARS, r);
		DEBUG(9, ("%08X: Pull string: %s\n", ndr->offset, *r));
		ndr->flags = u;
		return status;
	case 1:
		u = ndr->flags;
		ndr->flags |= LIBNDR_FLAG_STR_NULLTERM;
		status = ndr_pull_string(ndr, NDR_SCALARS, r);
		DEBUG(9, ("%08X: Pull string: %s\n", ndr->offset, *r));
		ndr->flags = u;
		return status;
	default: return NT_STATUS_NOT_SUPPORTED;
	}
}
Exemple #2
0
_PUBLIC_ enum ndr_err_code ndr_pull_TRUSTED_DOM_PASS(struct ndr_pull *ndr, int ndr_flags, struct TRUSTED_DOM_PASS *r)
{
	{
		uint32_t _flags_save_STRUCT = ndr->flags;
		ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
		if (ndr_flags & NDR_SCALARS) {
			NDR_CHECK(ndr_pull_align(ndr, 4));
			NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->uni_name_len));
			NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->uni_name, 32, sizeof(uint16_t), CH_UTF16));
			NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pass_len));
			{
				uint32_t _flags_save_string = ndr->flags;
				ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
				NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->pass));
				ndr->flags = _flags_save_string;
			}
			NDR_CHECK(ndr_pull_time_t(ndr, NDR_SCALARS, &r->mod_time));
			NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, &r->domain_sid));
			NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
		}
		if (ndr_flags & NDR_BUFFERS) {
		}
		ndr->flags = _flags_save_STRUCT;
	}
	return NDR_ERR_SUCCESS;
}
Exemple #3
0
/**
  pull a general string array from the wire
*/
NTSTATUS ndr_pull_string_array(struct ndr_pull *ndr, int ndr_flags, const char ***_a)
{
	const char **a = *_a;
	uint32_t count;

	if (!(ndr_flags & NDR_SCALARS)) {
		return NT_STATUS_OK;
	}

	for (count = 0;; count++) {
		TALLOC_CTX *tmp_ctx;
		const char *s = NULL;
		a = talloc_realloc(ndr->current_mem_ctx, a, const char *, count + 2);
		NT_STATUS_HAVE_NO_MEMORY(a);
		a[count]   = NULL;
		a[count+1]   = NULL;

		tmp_ctx = ndr->current_mem_ctx;
		ndr->current_mem_ctx = a;
		NDR_CHECK(ndr_pull_string(ndr, ndr_flags, &s));
		ndr->current_mem_ctx = tmp_ctx;
		if (strcmp("", s)==0) {
			a[count] = NULL;
			break;
		} else {
			a[count] = s;
		}
	}

	*_a =a;
	return NT_STATUS_OK;
}
Exemple #4
0
/* Manually modified to handle the dom_sid being optional based on if it is present (size is non-zero) or not */
enum ndr_err_code ndr_pull_NETLOGON_SAM_LOGON_REQUEST(struct ndr_pull *ndr, int ndr_flags, struct NETLOGON_SAM_LOGON_REQUEST *r)
{
    if (ndr_flags & NDR_SCALARS) {
        NDR_CHECK(ndr_pull_align(ndr, 4));
        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->request_count));
        {
            uint32_t _flags_save_string = ndr->flags;
            ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
            NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->computer_name));
            ndr->flags = _flags_save_string;
        }
        {
            uint32_t _flags_save_string = ndr->flags;
            ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
            NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
            ndr->flags = _flags_save_string;
        }
        {
            uint32_t _flags_save_string = ndr->flags;
            ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
            NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->mailslot_name));
            ndr->flags = _flags_save_string;
        }
        NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_control));
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sid_size));
        if (r->sid_size) {
            uint32_t _flags_save_DATA_BLOB = ndr->flags;
            struct ndr_pull *_ndr_sid;
            ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
            NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->_pad));
            ndr->flags = _flags_save_DATA_BLOB;
            NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_sid, 0, r->sid_size));
            NDR_CHECK(ndr_pull_dom_sid0(_ndr_sid, NDR_SCALARS|NDR_BUFFERS, &r->sid));
            NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_sid, 0, r->sid_size));
        } else {
            ZERO_STRUCT(r->sid);
        }
        NDR_CHECK(ndr_pull_netlogon_nt_version_flags(ndr, NDR_SCALARS, &r->nt_version));
        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lmnt_token));
        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lm20_token));
    }
    if (ndr_flags & NDR_BUFFERS) {
    }
    return NDR_ERR_SUCCESS;
}
_PUBLIC_ enum ndr_err_code ndr_pull_tdb_xattr(struct ndr_pull *ndr, int ndr_flags, struct tdb_xattr *r)
{
	if (ndr_flags & NDR_SCALARS) {
		NDR_CHECK(ndr_pull_align(ndr, 4));
		{
			uint32_t _flags_save_string = ndr->flags;
			ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_UTF8|LIBNDR_FLAG_STR_NULLTERM);
			NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
			ndr->flags = _flags_save_string;
		}
		NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->value));
	}
	if (ndr_flags & NDR_BUFFERS) {
	}
	return NDR_ERR_SUCCESS;
}
_PUBLIC_ enum ndr_err_code ndr_pull_notify_event(struct ndr_pull *ndr, int ndr_flags, struct notify_event *r)
{
	if (ndr_flags & NDR_SCALARS) {
		NDR_CHECK(ndr_pull_align(ndr, 8));
		NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->action));
		{
			uint32_t _flags_save_string = ndr->flags;
			ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_UTF8|LIBNDR_FLAG_STR_NULLTERM);
			NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->path));
			ndr->flags = _flags_save_string;
		}
		NDR_CHECK(ndr_pull_pointer(ndr, NDR_SCALARS, &r->private_data));
	}
	if (ndr_flags & NDR_BUFFERS) {
	}
	return NDR_ERR_SUCCESS;
}
Exemple #7
0
static enum ndr_err_code ndr_pull_xattr_DosStream(struct ndr_pull *ndr, int ndr_flags, struct xattr_DosStream *r)
{
	if (ndr_flags & NDR_SCALARS) {
		NDR_CHECK(ndr_pull_align(ndr, 4));
		NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
		NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->size));
		NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->alloc_size));
		{
			uint32_t _flags_save_string = ndr->flags;
			ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_UTF8|LIBNDR_FLAG_STR_NULLTERM);
			NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
			ndr->flags = _flags_save_string;
		}
	}
	if (ndr_flags & NDR_BUFFERS) {
	}
	return NDR_ERR_SUCCESS;
}
Exemple #8
0
_PUBLIC_ enum ndr_err_code ndr_pull_xattr_DOSATTRIB(struct ndr_pull *ndr, int ndr_flags, struct xattr_DOSATTRIB *r)
{
	if (ndr_flags & NDR_SCALARS) {
		NDR_CHECK(ndr_pull_align(ndr, 4));
		{
			uint32_t _flags_save_string = ndr->flags;
			ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
			NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->attrib_hex));
			ndr->flags = _flags_save_string;
		}
		if (ndr->offset >= ndr->data_size) {
			unsigned int dosattr;
			int ret;

			if (r->attrib_hex[0] != '0') {

			}
			if (r->attrib_hex[1] != 'x') {

			}
			ret = sscanf(r->attrib_hex, "%x", &dosattr);
			if (ret != 1) {
			}
			r->version = 0xFFFF;
			r->info.compatinfoFFFF.attrib = dosattr;
			return NDR_ERR_SUCCESS;
		}
		NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->version));
		if (r->version == 0xFFFF) {
			return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH,
					"ndr_pull_xattr_DOSATTRIB: "
					"invalid level 0x%02X",
					r->version);
		}
		NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->version));
		NDR_CHECK(ndr_pull_xattr_DosInfo(ndr, NDR_SCALARS, &r->info));
	}
	if (ndr_flags & NDR_BUFFERS) {
	}
	return NDR_ERR_SUCCESS;
}
Exemple #9
0
_PUBLIC_ enum ndr_err_code ndr_pull_notify_entry(struct ndr_pull *ndr, int ndr_flags, struct notify_entry *r)
{
	if (ndr_flags & NDR_SCALARS) {
		NDR_CHECK(ndr_pull_align(ndr, 8));
		NDR_CHECK(ndr_pull_server_id(ndr, NDR_SCALARS, &r->server));
		NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->filter));
		NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->subdir_filter));
		NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dir_fd));
		NDR_CHECK(ndr_pull_file_id(ndr, NDR_SCALARS, &r->dir_id));
		{
			uint32_t _flags_save_string = ndr->flags;
			ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_UTF8|LIBNDR_FLAG_STR_NULLTERM);
			NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->path));
			ndr->flags = _flags_save_string;
		}
		NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->path_len));
		NDR_CHECK(ndr_pull_pointer(ndr, NDR_SCALARS, &r->private_data));
		NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
	}
	if (ndr_flags & NDR_BUFFERS) {
	}
	return NDR_ERR_SUCCESS;
}
Exemple #10
0
_PUBLIC_ enum ndr_err_code ndr_pull_winreg_Data(struct ndr_pull *ndr, int ndr_flags, union winreg_Data *r)
{
	int level;
	{
		uint32_t _flags_save_UNION = ndr->flags;
		ndr_set_flags(&ndr->flags, LIBNDR_FLAG_LITTLE_ENDIAN);
		level = ndr_pull_get_switch_value(ndr, r);
		if (ndr_flags & NDR_SCALARS) {
			NDR_CHECK(ndr_pull_union_align(ndr, 4));
			switch (level) {
				case REG_NONE: {
				break; }

				case REG_SZ: {
					{
						uint32_t _flags_save_string = ndr->flags;
						ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
						NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
						ndr->flags = _flags_save_string;
					}
				break; }

				case REG_EXPAND_SZ: {
					{
						uint32_t _flags_save_string = ndr->flags;
						ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
						NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
						ndr->flags = _flags_save_string;
					}
				break; }

				case REG_BINARY: {
					{
						uint32_t _flags_save_DATA_BLOB = ndr->flags;
						ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
						NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
						ndr->flags = _flags_save_DATA_BLOB;
					}
				break; }

				case REG_DWORD: {
					NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value));
				break; }

				case REG_DWORD_BIG_ENDIAN: {
					{
						uint32_t _flags_save_uint32 = ndr->flags;
						ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
						NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value));
						ndr->flags = _flags_save_uint32;
					}
				break; }

				case REG_MULTI_SZ: {
					{
						uint32_t _flags_save_string_array = ndr->flags;
						ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
						NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
						ndr->flags = _flags_save_string_array;
					}
				break; }

				default: {
					{
						uint32_t _flags_save_DATA_BLOB = ndr->flags;
						ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
						NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
						ndr->flags = _flags_save_DATA_BLOB;
					}
				break; }

			}
		}
		if (ndr_flags & NDR_BUFFERS) {
			switch (level) {
				case REG_NONE:
				break;

				case REG_SZ:
				break;

				case REG_EXPAND_SZ:
				break;

				case REG_BINARY:
				break;

				case REG_DWORD:
				break;

				case REG_DWORD_BIG_ENDIAN:
				break;

				case REG_MULTI_SZ:
				break;

				default:
				break;

			}
		}
		ndr->flags = _flags_save_UNION;
	}
	return NDR_ERR_SUCCESS;
}