/src/samba/librpc/ndr/ndr_claims.c

Source
#include "includes.h"
#include "librpc/gen_ndr/ndr_claims.h"
#include "librpc/ndr/ndr_claims.h"

#include "librpc/ndr/ndr_compression.h"
#include "lib/compression/lzxpress_huffman.h"

enum ndr_compression_alg ndr_claims_compression_alg(enum CLAIMS_COMPRESSION_FORMAT wire_alg)
{
  switch (wire_alg) {
  case CLAIMS_COMPRESSION_FORMAT_NONE:
    return NDR_COMPRESSION_NONE;

  case CLAIMS_COMPRESSION_FORMAT_LZNT1:
    return NDR_COMPRESSION_INVALID;

  case CLAIMS_COMPRESSION_FORMAT_XPRESS:
    return NDR_COMPRESSION_INVALID;

  case CLAIMS_COMPRESSION_FORMAT_XPRESS_HUFF:
    return NDR_COMPRESSION_XPRESS_HUFF_RAW;
  }
  return NDR_COMPRESSION_INVALID;
}

static void ndr_claims_compressed_sizes(struct CLAIMS_SET_NDR *claims_set,
          enum CLAIMS_COMPRESSION_FORMAT wire_alg,
          int flags,
          ssize_t *_uncompressed_size,
          enum CLAIMS_COMPRESSION_FORMAT *_used_alg,
          ssize_t *_compressed_size)
{
  TALLOC_CTX *frame = NULL;
  DATA_BLOB tmp_blob;
  uint8_t * tmp_compressed;
  ssize_t compressed_size;
  enum ndr_err_code ndr_err;

  if (claims_set == NULL) {
    *_uncompressed_size = 0;
    *_used_alg = CLAIMS_COMPRESSION_FORMAT_NONE;
    *_compressed_size = 0;
    return;
  }

  frame = talloc_stackframe();

  ndr_err = ndr_push_struct_blob(&tmp_blob,
               frame,
               claims_set,
               (ndr_push_flags_fn_t)ndr_push_CLAIMS_SET_NDR);
  if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
    DBG_ERR("Failed to push claims while determining compressed size\n");
    *_uncompressed_size = -1;
    *_used_alg = CLAIMS_COMPRESSION_FORMAT_NONE;
    *_compressed_size = -1;
    TALLOC_FREE(frame);
    return;
  }

  if (tmp_blob.length < CLAIM_UPPER_COMPRESSION_THRESHOLD) {
    *_uncompressed_size = tmp_blob.length;
    *_used_alg = CLAIMS_COMPRESSION_FORMAT_NONE;
    *_compressed_size = tmp_blob.length;
    TALLOC_FREE(frame);
    return;
  }

  switch (wire_alg) {
  case CLAIMS_COMPRESSION_FORMAT_NONE:
    *_uncompressed_size = tmp_blob.length;
    *_used_alg = CLAIMS_COMPRESSION_FORMAT_NONE;
    *_compressed_size = tmp_blob.length;
    TALLOC_FREE(frame);
    return;

  case CLAIMS_COMPRESSION_FORMAT_XPRESS_HUFF:
    compressed_size = lzxpress_huffman_compress_talloc(frame,
                   tmp_blob.data,
                   tmp_blob.length,
                   &tmp_compressed);

    if (compressed_size < 0) {
      DBG_ERR("Failed to compress claims (for determining compressed size)\n");
      *_uncompressed_size = -1;
      *_used_alg = CLAIMS_COMPRESSION_FORMAT_NONE;
      *_compressed_size = -1;
      TALLOC_FREE(frame);
      return;
    }
    if (compressed_size >= tmp_blob.length) {
      *_uncompressed_size = tmp_blob.length;
      *_used_alg = CLAIMS_COMPRESSION_FORMAT_NONE;
      *_compressed_size = tmp_blob.length;
      TALLOC_FREE(frame);
      return;
    }

    *_uncompressed_size = tmp_blob.length;
    *_used_alg = CLAIMS_COMPRESSION_FORMAT_XPRESS_HUFF;
    *_compressed_size = compressed_size;
    TALLOC_FREE(frame);
    return;

  default:
    DBG_ERR("Invalid chosen compression algorithm while determining compressed claim size\n");
    *_uncompressed_size = -1;
    *_used_alg = CLAIMS_COMPRESSION_FORMAT_NONE;
    *_compressed_size = -1;
    TALLOC_FREE(frame);
    return;
  }
}

enum CLAIMS_COMPRESSION_FORMAT ndr_claims_actual_wire_compression_alg(enum CLAIMS_COMPRESSION_FORMAT specified_compression,
                      struct CLAIMS_SET_NDR *claims_set,
                      int flags)
{
  ssize_t uncompressed_size = -1;
  enum CLAIMS_COMPRESSION_FORMAT used_alg = CLAIMS_COMPRESSION_FORMAT_NONE;
  ssize_t compressed_size = -1;

  ndr_claims_compressed_sizes(claims_set,
            specified_compression,
            flags,
            &uncompressed_size,
            &used_alg,
            &compressed_size);

  return used_alg;
}

size_t ndr_claims_compressed_size(struct CLAIMS_SET_NDR *claims_set,
          enum CLAIMS_COMPRESSION_FORMAT wire_alg,
          int flags)
{
  ssize_t uncompressed_size = -1;
  enum CLAIMS_COMPRESSION_FORMAT used_alg = CLAIMS_COMPRESSION_FORMAT_NONE;
  ssize_t compressed_size = -1;

  ndr_claims_compressed_sizes(claims_set,
            wire_alg,
            flags,
            &uncompressed_size,
            &used_alg,
            &compressed_size);
  if (uncompressed_size == -1) {
    DBG_ERR("Failed to push claims while determining compressed size\n");
    return 0;
  }

  return compressed_size;
}

_PUBLIC_ enum ndr_err_code ndr_push_claims_tf_rule_set(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct claims_tf_rule_set *r)
{
  return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER,
            "ndr_push_claims_tf_rule_set() not implemented");
}

_PUBLIC_ enum ndr_err_code ndr_pull_claims_tf_rule_set(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct claims_tf_rule_set *r)
{
  return ndr_pull_error(ndr, NDR_ERR_INVALID_POINTER,
            "ndr_pull_claims_tf_rule_set() not implemented");
}

Line	Count	Source
1		#include "includes.h"
2		#include "librpc/gen_ndr/ndr_claims.h"
3		#include "librpc/ndr/ndr_claims.h"
4
5		#include "librpc/ndr/ndr_compression.h"
6		#include "lib/compression/lzxpress_huffman.h"
7
8		enum ndr_compression_alg ndr_claims_compression_alg(enum CLAIMS_COMPRESSION_FORMAT wire_alg)
9	869	{
10	869	switch (wire_alg) {
11	175	case CLAIMS_COMPRESSION_FORMAT_NONE:
12	175	return NDR_COMPRESSION_NONE;
13
14	0	case CLAIMS_COMPRESSION_FORMAT_LZNT1:
15	0	return NDR_COMPRESSION_INVALID;
16
17	0	case CLAIMS_COMPRESSION_FORMAT_XPRESS:
18	0	return NDR_COMPRESSION_INVALID;
19
20	666	case CLAIMS_COMPRESSION_FORMAT_XPRESS_HUFF:
21	666	return NDR_COMPRESSION_XPRESS_HUFF_RAW;
22	869	}
23	28	return NDR_COMPRESSION_INVALID;
24	869	}
25
26		static void ndr_claims_compressed_sizes(struct CLAIMS_SET_NDR *claims_set,
27		enum CLAIMS_COMPRESSION_FORMAT wire_alg,
28		int flags,
29		ssize_t *_uncompressed_size,
30		enum CLAIMS_COMPRESSION_FORMAT *_used_alg,
31		ssize_t *_compressed_size)
32	120	{
33	120	TALLOC_CTX *frame = NULL;
34	120	DATA_BLOB tmp_blob;
35	120	uint8_t * tmp_compressed;
36	120	ssize_t compressed_size;
37	120	enum ndr_err_code ndr_err;
38
39	120	if (claims_set == NULL) {
40	72	*_uncompressed_size = 0;
41	72	*_used_alg = CLAIMS_COMPRESSION_FORMAT_NONE;
42	72	*_compressed_size = 0;
43	72	return;
44	72	}
45
46	48	frame = talloc_stackframe();
47
48	48	ndr_err = ndr_push_struct_blob(&tmp_blob,
49	48	frame,
50	48	claims_set,
51	48	(ndr_push_flags_fn_t)ndr_push_CLAIMS_SET_NDR);
52	48	if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
53	0	DBG_ERR("Failed to push claims while determining compressed size\n");
54	0	*_uncompressed_size = -1;
55	0	*_used_alg = CLAIMS_COMPRESSION_FORMAT_NONE;
56	0	*_compressed_size = -1;
57	0	TALLOC_FREE(frame);
58	0	return;
59	0	}
60
61	48	if (tmp_blob.length < CLAIM_UPPER_COMPRESSION_THRESHOLD) {
62	30	*_uncompressed_size = tmp_blob.length;
63	30	*_used_alg = CLAIMS_COMPRESSION_FORMAT_NONE;
64	30	*_compressed_size = tmp_blob.length;
65	30	TALLOC_FREE(frame);
66	30	return;
67	30	}
68
69	18	switch (wire_alg) {
70	18	case CLAIMS_COMPRESSION_FORMAT_NONE:
71	18	*_uncompressed_size = tmp_blob.length;
72	18	*_used_alg = CLAIMS_COMPRESSION_FORMAT_NONE;
73	18	*_compressed_size = tmp_blob.length;
74	18	TALLOC_FREE(frame);
75	18	return;
76
77	0	case CLAIMS_COMPRESSION_FORMAT_XPRESS_HUFF:
78	0	compressed_size = lzxpress_huffman_compress_talloc(frame,
79	0	tmp_blob.data,
80	0	tmp_blob.length,
81	0	&tmp_compressed);
82
83	0	if (compressed_size < 0) {
84	0	DBG_ERR("Failed to compress claims (for determining compressed size)\n");
85	0	*_uncompressed_size = -1;
86	0	*_used_alg = CLAIMS_COMPRESSION_FORMAT_NONE;
87	0	*_compressed_size = -1;
88	0	TALLOC_FREE(frame);
89	0	return;
90	0	}
91	0	if (compressed_size >= tmp_blob.length) {
92	0	*_uncompressed_size = tmp_blob.length;
93	0	*_used_alg = CLAIMS_COMPRESSION_FORMAT_NONE;
94	0	*_compressed_size = tmp_blob.length;
95	0	TALLOC_FREE(frame);
96	0	return;
97	0	}
98
99	0	*_uncompressed_size = tmp_blob.length;
100	0	*_used_alg = CLAIMS_COMPRESSION_FORMAT_XPRESS_HUFF;
101	0	*_compressed_size = compressed_size;
102	0	TALLOC_FREE(frame);
103	0	return;
104
105	0	default:
106	0	DBG_ERR("Invalid chosen compression algorithm while determining compressed claim size\n");
107	0	*_uncompressed_size = -1;
108	0	*_used_alg = CLAIMS_COMPRESSION_FORMAT_NONE;
109	0	*_compressed_size = -1;
110	0	TALLOC_FREE(frame);
111	0	return;
112	18	}
113	18	}
114
115		enum CLAIMS_COMPRESSION_FORMAT ndr_claims_actual_wire_compression_alg(enum CLAIMS_COMPRESSION_FORMAT specified_compression,
116		struct CLAIMS_SET_NDR *claims_set,
117		int flags)
118	68	{
119	68	ssize_t uncompressed_size = -1;
120	68	enum CLAIMS_COMPRESSION_FORMAT used_alg = CLAIMS_COMPRESSION_FORMAT_NONE;
121	68	ssize_t compressed_size = -1;
122
123	68	ndr_claims_compressed_sizes(claims_set,
124	68	specified_compression,
125	68	flags,
126	68	&uncompressed_size,
127	68	&used_alg,
128	68	&compressed_size);
129
130	68	return used_alg;
131	68	}
132
133		size_t ndr_claims_compressed_size(struct CLAIMS_SET_NDR *claims_set,
134		enum CLAIMS_COMPRESSION_FORMAT wire_alg,
135		int flags)
136	52	{
137	52	ssize_t uncompressed_size = -1;
138	52	enum CLAIMS_COMPRESSION_FORMAT used_alg = CLAIMS_COMPRESSION_FORMAT_NONE;
139	52	ssize_t compressed_size = -1;
140
141	52	ndr_claims_compressed_sizes(claims_set,
142	52	wire_alg,
143	52	flags,
144	52	&uncompressed_size,
145	52	&used_alg,
146	52	&compressed_size);
147	52	if (uncompressed_size == -1) {
148	0	DBG_ERR("Failed to push claims while determining compressed size\n");
149	0	return 0;
150	0	}
151
152	52	return compressed_size;
153	52	}
154
155		_PUBLIC_ enum ndr_err_code ndr_push_claims_tf_rule_set(struct ndr_push ndr, ndr_flags_type ndr_flags, const struct claims_tf_rule_set r)
156	0	{
157	0	return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER,
158	0	"ndr_push_claims_tf_rule_set() not implemented");
159	0	}
160
161		_PUBLIC_ enum ndr_err_code ndr_pull_claims_tf_rule_set(struct ndr_pull ndr, ndr_flags_type ndr_flags, struct claims_tf_rule_set r)
162	1	{
163		return ndr_pull_error(ndr, NDR_ERR_INVALID_POINTER,
164	1	"ndr_pull_claims_tf_rule_set() not implemented");
165	1	}

Coverage Report

Created: 2026-05-24 06:47