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
|
/*
* $LynxId: HTAAUtil.h,v 1.13 2010/10/27 00:09:52 tom Exp $
*
* Utilities for the Authorization parts of libwww
* COMMON PARTS OF AUTHORIZATION MODULE TO BOTH SERVER AND BROWSER
*
* This module is the interface to the common parts of Access Authorization (AA) package
* for both server and browser. Important to know about memory allocation:
*
* Routines in this module use dynamic allocation, but free automatically all the memory
* reserved by them.
*
* Therefore the caller never has to (and never should) free() any object returned by
* these functions.
*
* Therefore also all the strings returned by this package are only valid until the next
* call to the same function is made. This approach is selected, because of the nature of
* access authorization: no string returned by the package needs to be valid longer than
* until the next call.
*
* This also makes it easy to plug the AA package in: you don't have to ponder whether to
* free() something here or is it done somewhere else (because it is always done somewhere
* else).
*
* The strings that the package needs to store are copied so the original strings given as
* parameters to AA functions may be freed or modified with no side effects.
*
* Also note: The AA package does not free() anything else than what it has itself
* allocated.
*
*/
#ifndef HTAAUTIL_H
#define HTAAUTIL_H
#include <HTList.h>
#ifdef __cplusplus
extern "C" {
#endif
/*
* Numeric constants
*/
#define MAX_USERNAME_LEN 16 /* @@ Longest allowed username */
#define MAX_PASSWORD_LEN 3*13 /* @@ Longest allowed password */
/* (encrypted, so really only 3*8) */
#define MAX_METHODNAME_LEN 12 /* @@ Longest allowed method name */
#define MAX_FIELDNAME_LEN 16 /* @@ Longest field name in */
/* protection setup file */
#define MAX_PATHNAME_LEN 80 /* @@ Longest passwd/group file */
/* pathname to allow */
/*
Datatype definitions
HTAASCHEME
The enumeration HTAAScheme represents the possible authentication schemes used by the
WWW Access Authorization.
*/ typedef enum {
HTAA_UNKNOWN,
HTAA_NONE,
HTAA_BASIC,
HTAA_PUBKEY,
HTAA_KERBEROS_V4,
HTAA_KERBEROS_V5,
HTAA_MAX_SCHEMES /* THIS MUST ALWAYS BE LAST! Number of schemes */
} HTAAScheme;
/*
ENUMERATION TO REPRESENT HTTP METHODS
*/
typedef enum {
METHOD_UNKNOWN,
METHOD_GET,
METHOD_PUT
} HTAAMethod;
/*
Authentication Schemes
*/
/* PUBLIC HTAAScheme_enum()
* TRANSLATE SCHEME NAME TO A SCHEME ENUMERATION
* ON ENTRY:
* name is a string representing the scheme name.
*
* ON EXIT:
* returns the enumerated constant for that scheme.
*/
extern HTAAScheme HTAAScheme_enum(const char *name);
/* PUBLIC HTAAScheme_name()
* GET THE NAME OF A GIVEN SCHEME
* ON ENTRY:
* scheme is one of the scheme enum values:
* HTAA_NONE, HTAA_BASIC, HTAA_PUBKEY, ...
*
* ON EXIT:
* returns the name of the scheme, i.e.
* "none", "basic", "pubkey", ...
*/
extern const char *HTAAScheme_name(HTAAScheme scheme);
/*
Methods
*/
/* PUBLIC HTAAMethod_enum()
* TRANSLATE METHOD NAME INTO AN ENUMERATED VALUE
* ON ENTRY:
* name is the method name to translate.
*
* ON EXIT:
* returns HTAAMethod enumerated value corresponding
* to the given name.
*/
extern HTAAMethod HTAAMethod_enum(const char *name);
/* PUBLIC HTAAMethod_name()
* GET THE NAME OF A GIVEN METHOD
* ON ENTRY:
* method is one of the method enum values:
* METHOD_GET, METHOD_PUT, ...
*
* ON EXIT:
* returns the name of the scheme, i.e.
* "GET", "PUT", ...
*/
extern const char *HTAAMethod_name(HTAAMethod method);
/* PUBLIC HTAAMethod_inList()
* IS A METHOD IN A LIST OF METHOD NAMES
* ON ENTRY:
* method is the method to look for.
* list is a list of method names.
*
* ON EXIT:
* returns YES, if method was found.
* NO, if not found.
*/
extern BOOL HTAAMethod_inList(HTAAMethod method, HTList *list);
/*
Match Template Against Filename
*/
/* PUBLIC HTAA_templateMatch()
* STRING COMPARISON FUNCTION FOR FILE NAMES
* WITH ONE WILDCARD * IN THE TEMPLATE
* NOTE:
* This is essentially the same code as in HTRules.c, but it
* cannot be used because it is embedded in between other code.
* (In fact, HTRules.c should use this routine, but then this
* routine would have to be more sophisticated... why is life
* sometimes so hard...)
*
* ON ENTRY:
* ctemplate is a template string to match the file name
* against, may contain a single wildcard
* character * which matches zero or more
* arbitrary characters.
* filename is the filename (or pathname) to be matched
* against the template.
*
* ON EXIT:
* returns YES, if filename matches the template.
* NO, otherwise.
*/
extern BOOL HTAA_templateMatch(const char *ctemplate,
const char *filename);
/* PUBLIC HTAA_templateCaseMatch()
* STRING COMPARISON FUNCTION FOR FILE NAMES
* WITH ONE WILDCARD * IN THE TEMPLATE (Case Insensitive)
* NOTE:
* This is essentially the same code as in HTAA_templateMatch, but
* it compares case insensitive (for VMS). Reason for this routine
* is that HTAA_templateMatch gets called from several places, also
* there where a case sensitive match is needed, so one cannot just
* change the HTAA_templateMatch routine for VMS.
*
* ON ENTRY:
* ctemplate is a template string to match the file name
* against, may contain a single wildcard
* character * which matches zero or more
* arbitrary characters.
* filename is the filename (or pathname) to be matched
* against the template.
*
* ON EXIT:
* returns YES, if filename matches the template.
* NO, otherwise.
*/
extern BOOL HTAA_templateCaseMatch(const char *ctemplate,
const char *filename);
/* PUBLIC HTAA_makeProtectionTemplate()
* CREATE A PROTECTION TEMPLATE FOR THE FILES
* IN THE SAME DIRECTORY AS THE GIVEN FILE
* (Used by server if there is no fancier way for
* it to tell the client, and by browser if server
* didn't send WWW-ProtectionTemplate: field)
* ON ENTRY:
* docname is the document pathname (from URL).
*
* ON EXIT:
* returns a template matching docname, and other files
* files in that directory.
*
* E.g. /foo/bar/x.html => /foo/bar/ *
* ^
* Space only to prevent it from
* being a comment marker here,
* there really isn't any space.
*/
extern char *HTAA_makeProtectionTemplate(const char *docname);
/*
MIME Argument List Parser
*/
/* PUBLIC HTAA_parseArgList()
* PARSE AN ARGUMENT LIST GIVEN IN A HEADER FIELD
* ON ENTRY:
* str is a comma-separated list:
*
* item, item, item
* where
* item ::= value
* | name=value
* | name="value"
*
* Leading and trailing whitespace is ignored
* everywhere except inside quotes, so the following
* examples are equal:
*
* name=value,foo=bar
* name="value",foo="bar"
* name = value , foo = bar
* name = "value" , foo = "bar"
*
* ON EXIT:
* returns a list of name-value pairs (actually HTAssocList*).
* For items with no name, just value, the name is
* the number of order number of that item. E.g.
* "1" for the first, etc.
*/
extern HTList *HTAA_parseArgList(char *str);
/*
Header Line Reader
*/
/* PUBLIC HTAA_setupReader()
* SET UP HEADER LINE READER, i.e., give
* the already-read-but-not-yet-processed
* buffer of text to be read before more
* is read from the socket.
* ON ENTRY:
* start_of_headers is a pointer to a buffer containing
* the beginning of the header lines
* (rest will be read from a socket).
* length is the number of valid characters in
* 'start_of_headers' buffer.
* soc is the socket to use when start_of_headers
* buffer is used up.
* ON EXIT:
* returns nothing.
* Subsequent calls to HTAA_getUnfoldedLine()
* will use this buffer first and then
* proceed to read from socket.
*/
extern void HTAA_setupReader(char *start_of_headers,
size_t length,
int soc);
/* PUBLIC HTAA_getUnfoldedLine()
* READ AN UNFOLDED HEADER LINE FROM SOCKET
* ON ENTRY:
* HTAA_setupReader must absolutely be called before
* this function to set up internal buffer.
*
* ON EXIT:
* returns a newly-allocated character string representing
* the read line. The line is unfolded, i.e.
* lines that begin with whitespace are appended
* to current line. E.g.
*
* Field-Name: Blaa-Blaa
* This-Is-A-Continuation-Line
* Here-Is_Another
*
* is seen by the caller as:
*
* Field-Name: Blaa-Blaa This-Is-A-Continuation-Line Here-Is_Another
*
*/
extern char *HTAA_getUnfoldedLine(void);
#ifdef __cplusplus
}
#endif
#endif /* NOT HTAAUTIL_H */
|
