This file is indexed.

/usr/include/globus/globus_rsl.h is in libglobus-rsl-dev 9.1-4.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
/*
 * Copyright 1999-2006 University of Chicago
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef _GLOBUS_INCLUDE_GLOBUS_RSL_H
#define _GLOBUS_INCLUDE_GLOBUS_RSL_H

#include "globus_list.h"
#include "globus_symboltable.h"
#include "globus_hashtable.h"

#ifndef EXTERN_C_BEGIN
#ifdef __cplusplus
#define EXTERN_C_BEGIN extern "C" {
#define EXTERN_C_END }
#else
#define EXTERN_C_BEGIN
#define EXTERN_C_END
#endif
#endif

EXTERN_C_BEGIN

#define GLOBUS_RSL_BOOLEAN  1
#define GLOBUS_RSL_RELATION 2

#define GLOBUS_RSL_EQ             1 
#define GLOBUS_RSL_NEQ            2 
#define GLOBUS_RSL_GT             3 
#define GLOBUS_RSL_GTEQ           4 
#define GLOBUS_RSL_LT             5 
#define GLOBUS_RSL_LTEQ           6 
#define GLOBUS_RSL_AND            8
#define GLOBUS_RSL_OR             9
#define GLOBUS_RSL_MULTIREQ      10

#define GLOBUS_RSL_VALUE_LITERAL       1
#define GLOBUS_RSL_VALUE_SEQUENCE      2
#define GLOBUS_RSL_VALUE_VARIABLE      3
#define GLOBUS_RSL_VALUE_CONCATENATION 4

#define GLOBUS_RSL_PARAM_SINGLE_LITERAL 1
#define GLOBUS_RSL_PARAM_MULTI_LITERAL  2
#define GLOBUS_RSL_PARAM_SEQUENCE       3

/**********************************************************************
 *
 *  Module activation structure
 *
 **********************************************************************
*/
extern globus_module_descriptor_t       globus_i_rsl_module;

#define GLOBUS_RSL_MODULE (&globus_i_rsl_module)

/***********************************************************************/


typedef struct _globus_rsl_value_t globus_rsl_value_t;

struct _globus_rsl_value_t
{
  int type;

  union
  {
    struct
    {
      char * string;
    } literal;

    struct
    {
      globus_list_t * value_list;
    } sequence;

    struct
    {
      globus_rsl_value_t * sequence;
    } variable;

    struct
    {
      globus_rsl_value_t * left_value;
      globus_rsl_value_t * right_value;
    } concatenation;

  } value;
};

typedef struct _globus_rsl_t globus_rsl_t;

struct _globus_rsl_t
{
  int type; /* GLOBUS_RSL_BOOLEAN || GLOBUS_RSL_RELATION */
  union
  {
    struct
    {
      /* bison reserves "operator" hence my_operator */
      int my_operator;
      /* each element of the list has type globus_rsl_t *... 
       */
      globus_list_t *operand_list;
    } boolean;

    struct
    {
      int my_operator;
      char * attribute_name;
      globus_rsl_value_t * value_sequence;
    } relation;
  } req;
};

/*************************************************************************
 *                   is functions
 *
 ************************************************************************/

int 
globus_rsl_is_relation (globus_rsl_t *ast);

int
globus_rsl_is_boolean (globus_rsl_t *ast);

int 
globus_rsl_is_relation_eq (globus_rsl_t *ast);

/* return true only for relations w/ the specific operator */
int 
globus_rsl_is_relation_lessthan (globus_rsl_t *ast);

/* return true if relation attribute is equal to attribute arg */
int
globus_rsl_is_relation_attribute_equal (globus_rsl_t *ast, char * attribute);

/* return true only for booleans w/ the specific operator */
int
globus_rsl_is_boolean_and (globus_rsl_t *ast);

/* return true only for booleans w/ the specific operator */
int
globus_rsl_is_boolean_or (globus_rsl_t *ast);

int
globus_rsl_is_boolean_multi (globus_rsl_t *ast);

int
globus_rsl_value_is_literal (globus_rsl_value_t *ast);

int
globus_rsl_value_is_sequence (globus_rsl_value_t *ast);

int
globus_rsl_value_is_variable (globus_rsl_value_t *ast);

int
globus_rsl_value_is_concatenation (globus_rsl_value_t *ast);


/*************************************************************************
 *                   constructor functions
 *
 ************************************************************************/

globus_rsl_t *
globus_rsl_make_boolean (int my_operator,
                       globus_list_t *children);

globus_rsl_t *
globus_rsl_make_relation (int my_operator,
                        char *attributename,
                        globus_rsl_value_t *value_sequence);

globus_rsl_value_t *
globus_rsl_value_make_literal (char *string);

globus_rsl_value_t *
globus_rsl_value_make_sequence (globus_list_t * value_list);

globus_rsl_value_t *
globus_rsl_value_make_variable (globus_rsl_value_t * sequence);

globus_rsl_value_t *
globus_rsl_value_make_concatenation (globus_rsl_value_t *left_value,
                                   globus_rsl_value_t *right_value);

/* copy the entire rsl tree */
globus_rsl_t *
globus_rsl_copy_recursive(globus_rsl_t * globus_rsl_ptr);

/* copy the entire rsl value list */
globus_rsl_value_t *
globus_rsl_value_copy_recursive(globus_rsl_value_t * globus_rsl_value_ptr);

/*************************************************************************
 *                   accessor functions
 *
 ************************************************************************/

/*                   booleans                   */

/*     return non-zero on error    */

int
globus_rsl_boolean_get_operator (globus_rsl_t *ast_node);

/*
 *
 */
globus_list_t *
globus_rsl_boolean_get_operand_list (globus_rsl_t *ast_node);

globus_list_t **
globus_rsl_boolean_get_operand_list_ref (globus_rsl_t *boolean_node);


/*                   relations                   */

char *
globus_rsl_relation_get_attribute (globus_rsl_t *ast_node);

int
globus_rsl_relation_get_operator (globus_rsl_t *ast_node);

globus_rsl_value_t *
globus_rsl_relation_get_value_sequence (globus_rsl_t *ast_node);

/* NULL unless the relation has a simple 1-element value sequence */
globus_rsl_value_t *
globus_rsl_relation_get_single_value (globus_rsl_t *ast_node);

/*                   value lists                   */

/* extract the literal node's string
 * NULL if not called on a node tagged as a literal
 */
char *
globus_rsl_value_literal_get_string (globus_rsl_value_t *literal_node);

/* extract the list of nodes under the sequence node
 * NULL if not called on a node tagges as a sequence
 */
globus_list_t *
globus_rsl_value_sequence_get_value_list (globus_rsl_value_t *sequence_node);

/*
 *
 */
globus_rsl_value_t *
globus_rsl_value_variable_get_sequence (globus_rsl_value_t * variable_node);

/* extract the name of the referenced variable
 * NULL if not called on a node tagged as a variable
 */
char *
globus_rsl_value_variable_get_name (globus_rsl_value_t *variable_node);

/* extract the optional value for the variable reference
 * NULL if no optional value specified
 * NULL if not called on a node tagged as a variable
 */
char *
globus_rsl_value_variable_get_default (globus_rsl_value_t *variable_node);

/* extract the left-hand value of a concatenation
 * NULL if not called on a node tagged as a variable
 */
globus_rsl_value_t *
globus_rsl_value_concatenation_get_left (globus_rsl_value_t *concatenation_node);

/* extract the right-hand value of a concatenation
 * NULL if not called on a node tagged as a variable
 */
globus_rsl_value_t *
globus_rsl_value_concatenation_get_right (globus_rsl_value_t *concatenation_node);

globus_list_t **
globus_rsl_value_sequence_get_list_ref (globus_rsl_value_t *sequence_node);


/*************************************************************************
 *                   set functions
 *
 ************************************************************************/

/* set the left-hand value of a concatenation to a new value
 * return non-zero on error */
int
globus_rsl_value_concatenation_set_left (globus_rsl_value_t *concatenate_node,
                                         globus_rsl_value_t *new_left_node);

/* set the right-hand value of a concatenation to a new value
 * return non-zero on error */
int
globus_rsl_value_concatenation_set_right (globus_rsl_value_t *concatenate_node,
                                          globus_rsl_value_t *new_right_node);

/*************************************************************************
 *                   eval functions
 *
 ************************************************************************/

int
globus_rsl_value_eval(globus_rsl_value_t * ast_node,
                      globus_symboltable_t * symbol_table,
                      char ** string_value,
                      int rsl_substitute_flag);

int
globus_rsl_eval (globus_rsl_t *ast_node,
                 globus_symboltable_t * symbol_table);

/*************************************************************************
 *                   free functions
 *
 ************************************************************************/


/*** all freeing is done through globus_free() ***/

/* free any storage allocated by the globus_rsl*_make_*() routine
 * for this type of node
 */
int
globus_rsl_value_free (globus_rsl_value_t *val);

int
globus_rsl_free (globus_rsl_t *ast_node);

/* like globus_rsl*_free () but recursively free subtrees too.
 * Assumes: 1.) no nodes in the tree are shared,
 *          2.) everything was allocated with globus_malloc
 */
int
globus_rsl_value_free_recursive (globus_rsl_value_t * globus_rsl_value_ptr);

int
globus_rsl_free_recursive (globus_rsl_t *ast_node);

int
globus_rsl_value_print_recursive (globus_rsl_value_t * globus_rsl_value_ptr);

int
globus_rsl_print_recursive (globus_rsl_t *ast_node);

#define GLOBUS_SPECIFICATION_PARSE_ERROR_MESSAGE_LENGTH 1024
typedef struct globus_parse_error_s
{
    int         code;
    int         line;
    int         position;
    char        message[GLOBUS_SPECIFICATION_PARSE_ERROR_MESSAGE_LENGTH];
} globus_rsl_parse_error_t;

/******************************************************************************
                              Function prototypes
******************************************************************************/

/* extract the name of the referenced variable
 * NULL if not called on a node tagged as a variable
 */
int
globus_rsl_value_variable_get_size (globus_rsl_value_t *variable_node);

globus_list_t *
globus_list_copy_reverse (globus_list_t * orig);

int
globus_rsl_value_list_literal_replace(globus_list_t * value_list,
                                     char * string_value);

globus_list_t *
globus_rsl_operand_list_copy_recursive(globus_list_t * orig);

globus_list_t *
globus_rsl_value_sequence_list_copy_recursive(globus_list_t * orig);

int
globus_rsl_value_list_param_get(globus_list_t * ast_node_list,
                     int required_type,
                     char *** value,
                     int * value_ctr);

int
globus_rsl_param_get(globus_rsl_t * ast_node,
                     int required_type,
                     char * param,
                     char *** values);

globus_list_t *
globus_rsl_param_get_values(globus_rsl_t * ast_node,
			    char * param);

globus_rsl_t *
globus_rsl_parse(char * rsl_spec);

char *
globus_rsl_unparse (globus_rsl_t *rsl_spec);

char *
globus_rsl_value_unparse (globus_rsl_value_t * rsl_value);

EXTERN_C_END

#endif /* _GLOBUS_INCLUDE_GLOBUS_RSL_H */