|
1 /* |
|
2 * Copyright (c) 2000 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: Implementation of policymanagement components |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 #ifndef XACML_CONSTANTS_HEADER__ |
|
20 #define XACML_CONSTANTS_HEADER__ |
|
21 |
|
22 #include "PolicyEngineXACML.h" |
|
23 |
|
24 |
|
25 namespace PolicyLanguage |
|
26 { |
|
27 namespace Constants |
|
28 { |
|
29 //namespace attributes |
|
30 // _LIT8( NamespaceAttr, "target-namespace"); |
|
31 // _LIT8( CertificateAttr, "certificate_attr"); |
|
32 _LIT8( ValidCertificateAttr, "valid_certificate"); |
|
33 _LIT8( PolicyTargetAttr, "policy_target"); |
|
34 _LIT8( TargetTrustedSubject, "target_trusted_subject"); |
|
35 |
|
36 _LIT8( MetaPolicySetNamespace, "meta_policy_set_namespace"); |
|
37 _LIT8( SettingSetNamespace, "setting_set_namespace"); |
|
38 |
|
39 _LIT8( SettingControlNamespace, "setting_control_namespace"); |
|
40 |
|
41 _LIT8( CorporateMetaPolicy, "corporate_meta_policy"); |
|
42 |
|
43 |
|
44 _LIT8( AddPolicy, "add"); |
|
45 _LIT8( RemovePolicy, "remove"); |
|
46 _LIT8( ReplacePolicy, "replace"); |
|
47 |
|
48 //Pre-defined policies and policy sets |
|
49 _LIT8( RootElement, "root_element"); |
|
50 _LIT8( RolesMappingPolicy, "roles_mapping_policy"); |
|
51 _LIT8( CertMappingPolicy, "cert_mapping_policy"); |
|
52 _LIT8( AutoCertificate, "auto_certificate"); |
|
53 const TInt AutoCertificateLength = 16; |
|
54 |
|
55 //Pre-defined policies for setting enforcement |
|
56 _LIT8( EMailEnforcementPolicy, "email_enforcement_policy"); |
|
57 _LIT8( EWLANEnforcementPolicy, "wlan_enforcement_policy"); |
|
58 _LIT8( EAPEnforcementPolicy, "ap_enforcement_policy"); |
|
59 _LIT8( EDataSyncEnforcementPolicy, "datasync_enforcement_policy"); |
|
60 _LIT8( ESyncMLEnforcementPolicy, "syncml_enforcement_policy"); |
|
61 _LIT8( EIMEnforcementPolicy, "im_enforcement_policy"); |
|
62 |
|
63 //values used in RuleTargetCheck functions |
|
64 _LIT8( Any, "any"); |
|
65 _LIT8( Subject, "subject"); |
|
66 _LIT8( Resource, "resource"); |
|
67 _LIT8( Action, "action"); |
|
68 _LIT8( Environment, "environment"); |
|
69 |
|
70 } |
|
71 |
|
72 namespace XACML |
|
73 { |
|
74 _LIT8(CharacterSetUTF8, "UTF-8"); |
|
75 |
|
76 |
|
77 |
|
78 |
|
79 namespace AttributeDesignators |
|
80 { |
|
81 _LIT8(SubjectAttributeDesignator, "SubjectAttributeDesignator"); |
|
82 _LIT8(ActionAttributeDesignator, "ActionAttributeDesignator"); |
|
83 _LIT8(ResourceAttributeDesignator, "ResourceAttributeDesignator"); |
|
84 _LIT8(EnvironmentAttributeDesignator, "EnvironmentAttributeDesignator"); |
|
85 |
|
86 _LIT8(AttributeId, "AttributeId"); |
|
87 _LIT8(DataType, "DataType"); |
|
88 } |
|
89 |
|
90 namespace AttributeValues |
|
91 { |
|
92 _LIT8(AttributeValue, "AttributeValue"); |
|
93 _LIT8(DataType, "DataType"); |
|
94 } |
|
95 |
|
96 namespace MatchObject |
|
97 { |
|
98 _LIT8(SubjectMatch, "SubjectMatch"); |
|
99 _LIT8(ActionMatch, "ActionMatch"); |
|
100 _LIT8(EnvironmentMatch, "EnvironmentMatch"); |
|
101 _LIT8(ResourceMatch, "ResourceMatch"); |
|
102 _LIT8(MatchId, "MatchId"); |
|
103 } |
|
104 |
|
105 namespace MatchContainers |
|
106 { |
|
107 _LIT8(Subject, "Subject"); |
|
108 _LIT8(Subjects, "Subjects"); |
|
109 _LIT8(Action, "Action"); |
|
110 _LIT8(Actions, "Actions"); |
|
111 _LIT8(Environment, "Environment"); |
|
112 _LIT8(Environments, "Environments"); |
|
113 _LIT8(Resource, "Resource"); |
|
114 _LIT8(Resources, "Resources"); |
|
115 } |
|
116 |
|
117 namespace Rule |
|
118 { |
|
119 _LIT8(Rule, "Rule"); |
|
120 _LIT8(RuleId, "RuleId"); |
|
121 _LIT8(Effect, "Effect"); |
|
122 _LIT8(Permit, "Permit"); |
|
123 _LIT8(Deny, "Deny"); |
|
124 |
|
125 _LIT8(Target, "Target"); |
|
126 } |
|
127 |
|
128 namespace Policy |
|
129 { |
|
130 _LIT8(Policy, "Policy"); |
|
131 _LIT8(PolicyId, "PolicyId"); |
|
132 _LIT8(RuleCombiningAlgId, "RuleCombiningAlgId"); |
|
133 } |
|
134 |
|
135 namespace PolicySet |
|
136 { |
|
137 _LIT8(PolicySet, "PolicySet"); |
|
138 _LIT8(PolicySetId, "PolicySetId"); |
|
139 _LIT8(PolicyCombiningAlgId, "PolicyCombiningAlgId"); |
|
140 } |
|
141 |
|
142 namespace Expressions |
|
143 { |
|
144 _LIT8(Apply, "Apply"); |
|
145 _LIT8(Condition, "Condition"); |
|
146 _LIT8(FunctionId, "FunctionId"); |
|
147 } |
|
148 |
|
149 namespace Functions |
|
150 { |
|
151 _LIT8(TrustedRoleMatch, "urn:nokia:names:s60:corporate:1.0:function:TrustedRoleMatch"); |
|
152 _LIT8(TrustedSubjectMatch, "urn:nokia:names:s60:corporate:1.0:function:TrustedSubjectMatch"); |
|
153 |
|
154 _LIT8(FunctionStringEqualId, "urn:oasis:names:tc:xacml:1.0:function:string-equal"); |
|
155 _LIT8(FunctionStringNotEqualId, "urn:oasis:names:tc:xacml:1.0:function:string-not-equal"); |
|
156 _LIT8(FunctionBooleanEqualId, "urn:oasis:names:tc:xacml:1.0:function:boolean-equal"); |
|
157 |
|
158 _LIT8(FunctionOr, "urn:oasis:names:tc:xacml:1.0:function:or"); |
|
159 _LIT8(FunctionAnd, "urn:oasis:names:tc:xacml:1.0:function:and"); |
|
160 _LIT8(FunctionNot, "urn:oasis:names:tc:xacml:1.0:function:not"); |
|
161 |
|
162 _LIT8(FunctionCertificatedSession, "urn:nokia:names:s60:corporate:1.0:function:CertificatedSession"); |
|
163 _LIT8(FunctionUserAcceptCorpPolicy, "urn:nokia:names:s60:corporate:1.0:function:user-accepts-initial-trustedadmin-policy"); |
|
164 _LIT8(FunctionRuleTargetStructure, "urn:nokia:names:s60:corporate:1.0:function:rule-target-structure"); |
|
165 |
|
166 } |
|
167 |
|
168 namespace CombiningAlgorithms |
|
169 { |
|
170 _LIT8(RuleDenyOverrides, "urn:oasis:names:tc:xacml:1.0:rule-combining-algorithm:deny-overrides"); |
|
171 _LIT8(PolicyDenyOverrides, "urn:oasis:names:tc:xacml:1.0:policy-combining-algorithm:deny-overrides"); |
|
172 _LIT8(RulePermitOverrides, "urn:oasis:names:tc:xacml:1.0:rule-combining-algorithm:permit-overrides"); |
|
173 _LIT8(PolicyPermitOverrides, "urn:oasis:names:tc:xacml:1.0:policy-combining-algorithm:permit-overrides"); |
|
174 } |
|
175 |
|
176 namespace Description |
|
177 { |
|
178 _LIT8(Description, "Description"); |
|
179 } |
|
180 } |
|
181 |
|
182 namespace NativeLanguage |
|
183 { |
|
184 namespace AttributeDesignators |
|
185 { |
|
186 _LIT8(SubjectAttributeDesignator, "sa"); |
|
187 _LIT8(ActionAttributeDesignator, "aa"); |
|
188 _LIT8(ResourceAttributeDesignator, "ra"); |
|
189 _LIT8(EnvironmentAttributeDesignator, "ea"); |
|
190 |
|
191 _LIT8(AttributeId, "aid"); |
|
192 _LIT8(DataType, "dt"); |
|
193 } |
|
194 |
|
195 namespace AttributeValues |
|
196 { |
|
197 _LIT8(AttributeValue, "av"); |
|
198 _LIT8(DataType, "dt"); |
|
199 |
|
200 _LIT8(StringDataType, "str"); |
|
201 _LIT8(BooleanDataType, "boo"); |
|
202 _LIT8(BooleanTrue, "tru"); |
|
203 _LIT8(BooleanFalse, "fal"); |
|
204 } |
|
205 |
|
206 namespace MatchObject |
|
207 { |
|
208 _LIT8(SubjectMatch, "sm"); |
|
209 _LIT8(ActionMatch, "am"); |
|
210 _LIT8(EnvironmentMatch, "em"); |
|
211 _LIT8(ResourceMatch, "rm"); |
|
212 _LIT8(MatchId, "mid"); |
|
213 } |
|
214 |
|
215 |
|
216 namespace MatchContainers |
|
217 { |
|
218 _LIT8(Subject, "su"); |
|
219 _LIT8(Subjects, "sus"); |
|
220 _LIT8(Action, "ac"); |
|
221 _LIT8(Actions, "acs"); |
|
222 _LIT8(Environment, "en"); |
|
223 _LIT8(Environments, "ens"); |
|
224 _LIT8(Resource, "re"); |
|
225 _LIT8(Resources, "res"); |
|
226 } |
|
227 |
|
228 namespace Rule |
|
229 { |
|
230 _LIT8(Rule, "ru"); |
|
231 _LIT8(RuleId, "ruid"); |
|
232 _LIT8(Effect, "ef"); |
|
233 _LIT8(Permit, "pe"); |
|
234 _LIT8(Deny, "de"); |
|
235 |
|
236 _LIT8(Target, "ta"); |
|
237 } |
|
238 |
|
239 namespace Policy |
|
240 { |
|
241 _LIT8(Policy, "po"); |
|
242 _LIT8(PolicyId, "poid"); |
|
243 _LIT8(RuleCombiningAlgId, "rcaid"); |
|
244 } |
|
245 |
|
246 namespace PolicySet |
|
247 { |
|
248 _LIT8(PolicySet, "ps"); |
|
249 _LIT8(PolicySetId, "psid"); |
|
250 _LIT8(PolicyCombiningAlgId, "pcid"); |
|
251 } |
|
252 |
|
253 namespace Expressions |
|
254 { |
|
255 _LIT8(Apply, "app"); |
|
256 _LIT8(FunctionId, "fid"); |
|
257 _LIT8(Condition, "con"); |
|
258 } |
|
259 |
|
260 |
|
261 namespace Functions |
|
262 { |
|
263 _LIT8(TrustedRoleMatch, "trm"); |
|
264 _LIT8(TrustedSubjectMatch, "tsm"); |
|
265 |
|
266 _LIT8(FunctionStringEqualId, "seid"); |
|
267 _LIT8(FunctionStringNotEqualId, "sneid"); |
|
268 _LIT8(FunctionBooleanEqualId, "beid"); |
|
269 |
|
270 _LIT8(FunctionOr, "orid"); |
|
271 _LIT8(FunctionAnd, "andid"); |
|
272 _LIT8(FunctionNot, "notid"); |
|
273 |
|
274 _LIT8(FunctionCertificatedSession, "csid"); |
|
275 _LIT8(FunctionUserAcceptCorpPolicy, "uaicpid"); |
|
276 _LIT8(FunctionRuleTargetStructure, "rtsid"); |
|
277 } |
|
278 |
|
279 namespace CombiningAlgorithms |
|
280 { |
|
281 _LIT8(RuleDenyOverrides, "rdor"); |
|
282 _LIT8(PolicyDenyOverrides, "pdor"); |
|
283 _LIT8(RulePermitOverrides, "rpor"); |
|
284 _LIT8(PolicyPermitOverrides, "ppor"); |
|
285 } |
|
286 |
|
287 namespace Description |
|
288 { |
|
289 _LIT8(Description, "desc"); |
|
290 } |
|
291 } |
|
292 |
|
293 namespace AttributeDesignators |
|
294 { |
|
295 const TPtrC8 SubjectAttributeDesignator[2] = |
|
296 { XACML::AttributeDesignators::SubjectAttributeDesignator(), NativeLanguage::AttributeDesignators::SubjectAttributeDesignator()}; |
|
297 const TPtrC8 ActionAttributeDesignator[2] = |
|
298 { XACML::AttributeDesignators::ActionAttributeDesignator(), NativeLanguage::AttributeDesignators::ActionAttributeDesignator()}; |
|
299 const TPtrC8 ResourceAttributeDesignator[2] = |
|
300 { XACML::AttributeDesignators::ResourceAttributeDesignator(), NativeLanguage::AttributeDesignators::ResourceAttributeDesignator()}; |
|
301 const TPtrC8 EnvironmentAttributeDesignator[2] = |
|
302 { XACML::AttributeDesignators::EnvironmentAttributeDesignator(), NativeLanguage::AttributeDesignators::EnvironmentAttributeDesignator()}; |
|
303 const TPtrC8 AttributeId[2] = |
|
304 { XACML::AttributeDesignators::AttributeId(), NativeLanguage::AttributeDesignators::AttributeId()}; |
|
305 const TPtrC8 DataType[2] = |
|
306 { XACML::AttributeDesignators::DataType(), NativeLanguage::AttributeDesignators::DataType()}; |
|
307 } |
|
308 |
|
309 namespace AttributeValues |
|
310 { |
|
311 const TPtrC8 AttributeValue[2] = |
|
312 { XACML::AttributeValues::AttributeValue(), NativeLanguage::AttributeValues::AttributeValue()}; |
|
313 const TPtrC8 DataType[2] = |
|
314 { XACML::AttributeValues::DataType(), NativeLanguage::AttributeValues::DataType()}; |
|
315 const TPtrC8 StringDataType[2] = |
|
316 { PolicyEngineXACML::KStringDataType(), NativeLanguage::AttributeValues::StringDataType()}; |
|
317 const TPtrC8 BooleanDataType[2] = |
|
318 { PolicyEngineXACML::KBooleanDataType(), NativeLanguage::AttributeValues::BooleanDataType()}; |
|
319 const TPtrC8 BooleanTrue[2] = |
|
320 { PolicyEngineXACML::KBooleanTrue(), NativeLanguage::AttributeValues::BooleanTrue()}; |
|
321 const TPtrC8 BooleanFalse[2] = |
|
322 { PolicyEngineXACML::KBooleanFalse(), NativeLanguage::AttributeValues::BooleanFalse()}; |
|
323 } |
|
324 |
|
325 namespace MatchObject |
|
326 { |
|
327 const TPtrC8 SubjectMatch[2] = |
|
328 { XACML::MatchObject::SubjectMatch(), NativeLanguage::MatchObject::SubjectMatch()}; |
|
329 const TPtrC8 ActionMatch[2] = |
|
330 { XACML::MatchObject::ActionMatch(), NativeLanguage::MatchObject::ActionMatch()}; |
|
331 const TPtrC8 EnvironmentMatch[2] = |
|
332 { XACML::MatchObject::EnvironmentMatch(), NativeLanguage::MatchObject::EnvironmentMatch()}; |
|
333 const TPtrC8 ResourceMatch[2] = |
|
334 { XACML::MatchObject::ResourceMatch(), NativeLanguage::MatchObject::ResourceMatch()}; |
|
335 const TPtrC8 MatchId[2] = |
|
336 { XACML::MatchObject::MatchId(), NativeLanguage::MatchObject::MatchId()}; |
|
337 } |
|
338 |
|
339 namespace MatchContainers |
|
340 { |
|
341 const TPtrC8 Subject[2] = |
|
342 { XACML::MatchContainers::Subject(), NativeLanguage::MatchContainers::Subject()}; |
|
343 const TPtrC8 Subjects[2] = |
|
344 { XACML::MatchContainers::Subjects(), NativeLanguage::MatchContainers::Subjects()}; |
|
345 const TPtrC8 Action[2] = |
|
346 { XACML::MatchContainers::Action(), NativeLanguage::MatchContainers::Action()}; |
|
347 const TPtrC8 Actions[2] = |
|
348 { XACML::MatchContainers::Actions(), NativeLanguage::MatchContainers::Actions()}; |
|
349 const TPtrC8 Environment[2] = |
|
350 { XACML::MatchContainers::Environment(), NativeLanguage::MatchContainers::Environment()}; |
|
351 const TPtrC8 Environments[2] = |
|
352 { XACML::MatchContainers::Environments(), NativeLanguage::MatchContainers::Environments()}; |
|
353 const TPtrC8 Resource[2] = |
|
354 { XACML::MatchContainers::Resource(), NativeLanguage::MatchContainers::Resource()}; |
|
355 const TPtrC8 Resources[2] = |
|
356 { XACML::MatchContainers::Resources(), NativeLanguage::MatchContainers::Resources()}; |
|
357 } |
|
358 |
|
359 namespace Rule |
|
360 { |
|
361 const TPtrC8 Rule[2] = |
|
362 { XACML::Rule::Rule(), NativeLanguage::Rule::Rule()}; |
|
363 const TPtrC8 RuleId[2] = |
|
364 { XACML::Rule::RuleId(), NativeLanguage::Rule::RuleId()}; |
|
365 const TPtrC8 Effect[2] = |
|
366 { XACML::Rule::Effect(), NativeLanguage::Rule::Effect()}; |
|
367 const TPtrC8 Permit[2] = |
|
368 { XACML::Rule::Permit(), NativeLanguage::Rule::Permit()}; |
|
369 const TPtrC8 Deny[2] = |
|
370 { XACML::Rule::Deny(), NativeLanguage::Rule::Deny()}; |
|
371 const TPtrC8 Target[2] = |
|
372 { XACML::Rule::Target(), NativeLanguage::Rule::Target()}; |
|
373 } |
|
374 |
|
375 namespace Policy |
|
376 { |
|
377 const TPtrC8 Policy[2] = |
|
378 { XACML::Policy::Policy(), NativeLanguage::Policy::Policy()}; |
|
379 const TPtrC8 PolicyId[2] = |
|
380 { XACML::Policy::PolicyId(), NativeLanguage::Policy::PolicyId()}; |
|
381 const TPtrC8 RuleCombiningAlgId[2] = |
|
382 { XACML::Policy::RuleCombiningAlgId(), NativeLanguage::Policy::RuleCombiningAlgId()}; |
|
383 } |
|
384 |
|
385 namespace PolicySet |
|
386 { |
|
387 const TPtrC8 PolicySet[2] = |
|
388 { XACML::PolicySet::PolicySet(), NativeLanguage::PolicySet::PolicySet()}; |
|
389 const TPtrC8 PolicySetId[2] = |
|
390 { XACML::PolicySet::PolicySetId(), NativeLanguage::PolicySet::PolicySetId()}; |
|
391 const TPtrC8 PolicyCombiningAlgId[2] = |
|
392 { XACML::PolicySet::PolicyCombiningAlgId(), NativeLanguage::PolicySet::PolicyCombiningAlgId()}; |
|
393 } |
|
394 |
|
395 namespace Expressions |
|
396 { |
|
397 const TPtrC8 Apply[2] = |
|
398 { XACML::Expressions::Apply(), NativeLanguage::Expressions::Apply()}; |
|
399 const TPtrC8 Condition[2] = |
|
400 { XACML::Expressions::Condition(), NativeLanguage::Expressions::Condition()}; |
|
401 const TPtrC8 FunctionId[2] = |
|
402 { XACML::Expressions::FunctionId(), NativeLanguage::Expressions::FunctionId()}; |
|
403 } |
|
404 |
|
405 namespace Functions |
|
406 { |
|
407 const TPtrC8 TrustedRoleMatch[2] = |
|
408 { XACML::Functions::TrustedRoleMatch(), NativeLanguage::Functions::TrustedRoleMatch()}; |
|
409 const TPtrC8 TrustedSubjectMatch[2] = |
|
410 { XACML::Functions::TrustedSubjectMatch(), NativeLanguage::Functions::TrustedSubjectMatch()}; |
|
411 const TPtrC8 FunctionStringEqualId[2] = |
|
412 { XACML::Functions::FunctionStringEqualId(), NativeLanguage::Functions::FunctionStringEqualId()}; |
|
413 const TPtrC8 FunctionStringNotEqualId[2] = |
|
414 { XACML::Functions::FunctionStringNotEqualId(), NativeLanguage::Functions::FunctionStringNotEqualId()}; |
|
415 const TPtrC8 FunctionBooleanEqualId[2] = |
|
416 { XACML::Functions::FunctionBooleanEqualId(), NativeLanguage::Functions::FunctionBooleanEqualId()}; |
|
417 |
|
418 const TPtrC8 FunctionOr[2] = |
|
419 { XACML::Functions::FunctionOr(), NativeLanguage::Functions::FunctionOr()}; |
|
420 const TPtrC8 FunctionAnd[2] = |
|
421 { XACML::Functions::FunctionAnd(), NativeLanguage::Functions::FunctionAnd()}; |
|
422 const TPtrC8 FunctionNot[2] = |
|
423 { XACML::Functions::FunctionNot(), NativeLanguage::Functions::FunctionNot()}; |
|
424 |
|
425 |
|
426 const TPtrC8 FunctionCertificatedSession[2] = |
|
427 { XACML::Functions::FunctionCertificatedSession(), NativeLanguage::Functions::FunctionCertificatedSession()}; |
|
428 const TPtrC8 FunctionUserAcceptCorpPolicy[2] = |
|
429 { XACML::Functions::FunctionUserAcceptCorpPolicy(), NativeLanguage::Functions::FunctionUserAcceptCorpPolicy()}; |
|
430 const TPtrC8 FunctionRuleTargetStructure[2] = |
|
431 { XACML::Functions::FunctionRuleTargetStructure(), NativeLanguage::Functions::FunctionRuleTargetStructure()}; |
|
432 } |
|
433 |
|
434 |
|
435 namespace CombiningAlgorithms |
|
436 { |
|
437 const TPtrC8 RuleDenyOverrides[2] = |
|
438 { XACML::CombiningAlgorithms::RuleDenyOverrides(), NativeLanguage::CombiningAlgorithms::RuleDenyOverrides ()}; |
|
439 const TPtrC8 PolicyDenyOverrides[2] = |
|
440 { XACML::CombiningAlgorithms::PolicyDenyOverrides(), NativeLanguage::CombiningAlgorithms::PolicyDenyOverrides ()}; |
|
441 const TPtrC8 RulePermitOverrides[2] = |
|
442 { XACML::CombiningAlgorithms::RulePermitOverrides(), NativeLanguage::CombiningAlgorithms::RulePermitOverrides ()}; |
|
443 const TPtrC8 PolicyPermitOverrides[2] = |
|
444 { XACML::CombiningAlgorithms::PolicyPermitOverrides(), NativeLanguage::CombiningAlgorithms::PolicyPermitOverrides ()}; |
|
445 } |
|
446 |
|
447 namespace Description |
|
448 { |
|
449 const TPtrC8 Description[2] = |
|
450 { XACML::Description::Description(), NativeLanguage::Description::Description()}; |
|
451 } |
|
452 |
|
453 } |
|
454 |
|
455 |
|
456 |
|
457 |
|
458 #endif |