Commit | Line | Data |
---|---|---|
805e021f CE |
1 | /* |
2 | * Copyright (c) 2001-2002 International Business Machines Corp. | |
3 | * All rights reserved. | |
4 | * | |
5 | * This software has been released under the terms of the IBM Public | |
6 | * License. For details, see the LICENSE file in the top-level source | |
7 | * directory or online at http://www.openafs.org/dl/license10.html | |
8 | * | |
9 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
10 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
11 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
12 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR | |
13 | * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, | |
14 | * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, | |
15 | * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR | |
16 | * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF | |
17 | * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING | |
18 | * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | |
19 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
20 | */ | |
21 | ||
22 | #include "Internal.h" | |
23 | #include "org_openafs_jafs_Cell.h" | |
24 | #include "org_openafs_jafs_Token.h" | |
25 | ||
26 | #include <stdio.h> | |
27 | #include <afs_kasAdmin.h> | |
28 | #include <afs_ptsAdmin.h> | |
29 | #include <afs_clientAdmin.h> | |
30 | #include <kautils.h> | |
31 | #include <cellconfig.h> | |
32 | #include <afs_AdminClientErrors.h> | |
33 | #include <rx/rxkad.h> | |
34 | ||
35 | /** | |
36 | * Static function used to initialize the client library and the | |
37 | * jafs library. | |
38 | * | |
39 | * env the Java environment | |
40 | * obj the current Java object | |
41 | */ | |
42 | JNIEXPORT void JNICALL | |
43 | Java_org_openafs_jafs_Token_initializeAdminClient(JNIEnv *env, jclass cls) | |
44 | { | |
45 | afs_status_t ast; | |
46 | if( !afsclient_Init( &ast ) ) { | |
47 | throwAFSException( env, ast ); | |
48 | return; | |
49 | } | |
50 | } | |
51 | ||
52 | ||
53 | /** | |
54 | * Authenticates the given user and password in the cell. Returns | |
55 | * a token that can be used to prove this authentication later. | |
56 | * | |
57 | * env the Java environment | |
58 | * obj the current Java object | |
59 | * jcellName the name of the cell in which to authenticate this user | |
60 | * juserName the name of the user to authenticate | |
61 | * jpassword the password of the user | |
62 | * returns a token representing the authentication | |
63 | */ | |
64 | JNIEXPORT jlong JNICALL | |
65 | Java_org_openafs_jafs_Token_getToken | |
66 | (JNIEnv *env, jobject obj, jstring jcellName, jstring juserName, | |
67 | jstring jpassword) | |
68 | { | |
69 | afs_status_t ast; | |
70 | const char *cellName; | |
71 | const char *userName; | |
72 | const char *password; | |
73 | void *tokenHandle; | |
74 | int rc; | |
75 | int err; | |
76 | ||
77 | // convert java strings | |
78 | if( jcellName != NULL ) { | |
79 | cellName = (*env)->GetStringUTFChars(env, jcellName, 0); | |
80 | if( !cellName ) { | |
81 | throwAFSException( env, JAFSADMNOMEM ); | |
82 | return 0; | |
83 | } | |
84 | } else { | |
85 | cellName = NULL; | |
86 | } | |
87 | if( juserName != NULL ) { | |
88 | userName = (*env)->GetStringUTFChars(env, juserName, 0); | |
89 | if( !userName ) { | |
90 | throwAFSException( env, JAFSADMNOMEM ); | |
91 | return 0; | |
92 | } | |
93 | } else { | |
94 | userName = NULL; | |
95 | } | |
96 | if( jpassword != NULL ) { | |
97 | password = (*env)->GetStringUTFChars(env, jpassword, 0); | |
98 | if( !password ) { | |
99 | throwAFSException( env, JAFSADMNOMEM ); | |
100 | return 0; | |
101 | } | |
102 | } else { | |
103 | password = NULL; | |
104 | } | |
105 | ||
106 | err = (password==NULL || userName==NULL) | |
107 | ? afsclient_TokenGetExisting( cellName, &tokenHandle, &ast) | |
108 | : afsclient_TokenGetNew( cellName, userName, password, &tokenHandle, &ast); | |
109 | ||
110 | if ( !err ) { | |
111 | // release converted strings | |
112 | if( cellName != NULL ) { | |
113 | (*env)->ReleaseStringUTFChars(env, jcellName, cellName); | |
114 | } | |
115 | if( userName != NULL ) { | |
116 | (*env)->ReleaseStringUTFChars(env, juserName, userName); | |
117 | } | |
118 | if( password != NULL ) { | |
119 | (*env)->ReleaseStringUTFChars(env, jpassword, password); | |
120 | } | |
121 | throwAFSException( env, ast ); | |
122 | return 0; | |
123 | } | |
124 | ||
125 | // release converted strings | |
126 | if( cellName != NULL ) { | |
127 | (*env)->ReleaseStringUTFChars(env, jcellName, cellName); | |
128 | } | |
129 | if( userName != NULL ) { | |
130 | (*env)->ReleaseStringUTFChars(env, juserName, userName); | |
131 | } | |
132 | if( password != NULL ) { | |
133 | (*env)->ReleaseStringUTFChars(env, jpassword, password); | |
134 | } | |
135 | ||
136 | return (jlong) tokenHandle; | |
137 | } | |
138 | ||
139 | /** | |
140 | * Closes the given currently open token. | |
141 | * | |
142 | * env the Java environment | |
143 | * obj the current Java object | |
144 | * tokenHandle the token to close | |
145 | */ | |
146 | JNIEXPORT void JNICALL | |
147 | Java_org_openafs_jafs_Token_close | |
148 | (JNIEnv *env, jobject obj, jlong tokenHandle) | |
149 | { | |
150 | afs_status_t ast; | |
151 | ||
152 | if( !afsclient_TokenClose( (void *) tokenHandle, &ast ) ) { | |
153 | throwAFSException( env, ast ); | |
154 | return; | |
155 | } | |
156 | } | |
157 | ||
158 | /** | |
159 | * Opens a cell for administrative use, based on the token provided. | |
160 | * Returns a cell handle to be used by other methods as a means of | |
161 | * authentication. | |
162 | * | |
163 | * env the Java environment | |
164 | * obj the current Java object | |
165 | * jcellName the name of the cell for which to get the handle | |
166 | * tokenHandle a token handle previously returned by a call to getToken | |
167 | * returns a handle to the open cell | |
168 | */ | |
169 | JNIEXPORT jlong JNICALL | |
170 | Java_org_openafs_jafs_Cell_getCellHandle | |
171 | (JNIEnv *env, jobject obj, jstring jcellName, jlong tokenHandle) | |
172 | { | |
173 | afs_status_t ast; | |
174 | const char *cellName; | |
175 | void *cellHandle; | |
176 | ||
177 | if( jcellName != NULL ) { | |
178 | cellName = (*env)->GetStringUTFChars(env, jcellName, 0); | |
179 | if( !cellName ) { | |
180 | throwAFSException( env, JAFSADMNOMEM ); | |
181 | return; | |
182 | } | |
183 | } else { | |
184 | cellName = NULL; | |
185 | } | |
186 | ||
187 | if( !afsclient_CellOpen( cellName, (void *) tokenHandle, | |
188 | &cellHandle, &ast ) ) { | |
189 | if( cellName != NULL ) { | |
190 | (*env)->ReleaseStringUTFChars(env, jcellName, cellName); | |
191 | } | |
192 | throwAFSException( env, ast ); | |
193 | return; | |
194 | } | |
195 | ||
196 | if( cellName != NULL ) { | |
197 | (*env)->ReleaseStringUTFChars(env, jcellName, cellName); | |
198 | } | |
199 | ||
200 | return (jlong) cellHandle; | |
201 | } | |
202 | ||
203 | /** | |
204 | * Closes the given currently open cell handle. | |
205 | * | |
206 | * env the Java environment | |
207 | * obj the current Java object | |
208 | * cellHandle the cell handle to close | |
209 | */ | |
210 | JNIEXPORT void JNICALL | |
211 | Java_org_openafs_jafs_Cell_closeCell (JNIEnv *env, jobject obj, | |
212 | jlong cellHandle) | |
213 | { | |
214 | ||
215 | afs_status_t ast; | |
216 | ||
217 | if( !afsclient_CellClose( (void *) cellHandle, &ast ) ) { | |
218 | throwAFSException( env, ast ); | |
219 | return; | |
220 | } | |
221 | ||
222 | } | |
223 | ||
224 | /** | |
225 | * Opens a server for administrative vos use, based on the cell handle | |
226 | * provided. Returns a vos server handle to be used by other | |
227 | * methods as a means of identification. | |
228 | * | |
229 | * env the Java environment | |
230 | * obj the current Java object | |
231 | * cellHandle a cell handle previously returned by | |
232 | * a call to getCellHandle | |
233 | * jserverName the name of the server for which to retrieve | |
234 | * a vos handle | |
235 | * returns a vos handle to the server | |
236 | */ | |
237 | JNIEXPORT jlong JNICALL | |
238 | Java_org_openafs_jafs_Server_getVosServerHandle | |
239 | (JNIEnv *env, jobject obj, jlong cellHandle, jstring jserverName) | |
240 | { | |
241 | afs_status_t ast; | |
242 | void *serverHandle; | |
243 | // convert java string | |
244 | const char *serverName; | |
245 | ||
246 | if( jserverName != NULL ) { | |
247 | serverName = (*env)->GetStringUTFChars(env, jserverName, 0); | |
248 | if( !serverName ) { | |
249 | throwAFSException( env, JAFSADMNOMEM ); | |
250 | return; | |
251 | } | |
252 | } else { | |
253 | serverName = NULL; | |
254 | } | |
255 | ||
256 | if( !vos_ServerOpen( (void *) cellHandle, serverName, | |
257 | (void **) &serverHandle, &ast ) ) { | |
258 | if( serverName != NULL ) { | |
259 | (*env)->ReleaseStringUTFChars(env, jserverName, serverName); | |
260 | } | |
261 | throwAFSException( env, ast ); | |
262 | return 0; | |
263 | } | |
264 | ||
265 | // release converted string | |
266 | if( serverName != NULL ) { | |
267 | (*env)->ReleaseStringUTFChars(env, jserverName, serverName); | |
268 | } | |
269 | ||
270 | return (jlong) serverHandle; | |
271 | } | |
272 | ||
273 | /** | |
274 | * Closes the given currently open vos server handle. | |
275 | * | |
276 | * env the Java environment | |
277 | * obj the current Java object | |
278 | * vosServerHandle the vos server handle to close | |
279 | */ | |
280 | JNIEXPORT void JNICALL | |
281 | Java_org_openafs_jafs_Server_closeVosServerHandle | |
282 | (JNIEnv *env, jobject obj, jlong vosServerHandle) | |
283 | { | |
284 | afs_status_t ast; | |
285 | ||
286 | if( !vos_ServerClose( (void *) vosServerHandle, &ast ) ) { | |
287 | throwAFSException( env, ast ); | |
288 | return; | |
289 | } | |
290 | } | |
291 | ||
292 | /** | |
293 | * Opens a server for administrative bos use, based on the cell handle | |
294 | * provided. Returns a bos server handle to be used by other methods | |
295 | * as a means of identification. | |
296 | * | |
297 | * env the Java environment | |
298 | * obj the current Java object | |
299 | * cellHandle a cell handle previously returned by a call | |
300 | * to getCellHandle | |
301 | * jserverName the name of the server for which to retrieve | |
302 | * a bos handle | |
303 | * returns a bos handle to the server | |
304 | */ | |
305 | JNIEXPORT jlong JNICALL | |
306 | Java_org_openafs_jafs_Server_getBosServerHandle | |
307 | (JNIEnv *env, jobject obj, jlong cellHandle, jstring jserverName) | |
308 | { | |
309 | afs_status_t ast; | |
310 | void *serverHandle; | |
311 | // convert java string | |
312 | const char *serverName; | |
313 | ||
314 | if( jserverName != NULL ) { | |
315 | serverName = (*env)->GetStringUTFChars(env, jserverName, 0); | |
316 | if( !serverName ) { | |
317 | throwAFSException( env, JAFSADMNOMEM ); | |
318 | return; | |
319 | } | |
320 | } else { | |
321 | serverName = NULL; | |
322 | } | |
323 | ||
324 | if( !bos_ServerOpen( (void *) cellHandle, serverName, | |
325 | (void **) &serverHandle, &ast ) ) { | |
326 | if( serverName != NULL ) { | |
327 | (*env)->ReleaseStringUTFChars(env, jserverName, serverName); | |
328 | } | |
329 | throwAFSException( env, ast ); | |
330 | return 0; | |
331 | } | |
332 | ||
333 | // release converted string | |
334 | if( serverName != NULL ) { | |
335 | (*env)->ReleaseStringUTFChars(env, jserverName, serverName); | |
336 | } | |
337 | ||
338 | return (jlong) serverHandle; | |
339 | } | |
340 | ||
341 | /** | |
342 | * Closes the given currently open bos server handle. | |
343 | * | |
344 | * env the Java environment | |
345 | * obj the current Java object | |
346 | * bosServerHandle the bos server handle to close | |
347 | */ | |
348 | JNIEXPORT void JNICALL | |
349 | Java_org_openafs_jafs_Server_closeBosServerHandle | |
350 | (JNIEnv *env, jobject obj, jlong bosServerHandle) | |
351 | { | |
352 | afs_status_t ast; | |
353 | ||
354 | if( !bos_ServerClose( (void *) bosServerHandle, &ast ) ) { | |
355 | throwAFSException( env, ast ); | |
356 | return; | |
357 | } | |
358 | } | |
359 | ||
360 | /** | |
361 | * Gets the expiration time for a given token. | |
362 | * | |
363 | * env the Java environment | |
364 | * obj the current Java object | |
365 | * | |
366 | * tokenHandle a token handle previously returned by a call | |
367 | * to getToken | |
368 | * returns a long representing the UTC time for the token expiration | |
369 | */ | |
370 | JNIEXPORT jlong JNICALL | |
371 | Java_org_openafs_jafs_Token_getExpiration | |
372 | (JNIEnv *env, jobject obj, jlong tokenHandle) | |
373 | { | |
374 | afs_status_t ast; | |
375 | unsigned long expTime; | |
376 | char *prince = malloc( sizeof(char)*KAS_MAX_NAME_LEN ); | |
377 | char *inst = malloc( sizeof(char)*KAS_MAX_NAME_LEN ); | |
378 | char *cell = malloc( sizeof(char)*AFS_MAX_SERVER_NAME_LEN ); | |
379 | int hkt; | |
380 | ||
381 | if( !prince || !inst || !cell ) { | |
382 | if( prince ) { | |
383 | free( prince ); | |
384 | } | |
385 | if( inst ) { | |
386 | free( inst ); | |
387 | } | |
388 | if( cell ) { | |
389 | free( cell ); | |
390 | } | |
391 | throwAFSException( env, JAFSADMNOMEM ); | |
392 | return; | |
393 | } | |
394 | ||
395 | if( !afsclient_TokenQuery( (void *) tokenHandle, &expTime, prince, inst, | |
396 | cell, &hkt, &ast ) ) { | |
397 | free( prince ); | |
398 | free( inst ); | |
399 | free( cell ); | |
400 | throwAFSException( env, ast ); | |
401 | return 0; | |
402 | } | |
403 | ||
404 | free( prince ); | |
405 | free( inst ); | |
406 | free( cell ); | |
407 | ||
408 | return (jlong) expTime; | |
409 | } | |
410 | ||
411 | // reclaim global memory used by this portion | |
412 | JNIEXPORT void JNICALL | |
413 | Java_org_openafs_jafs_Token_reclaimAuthMemory (JNIEnv *env, jclass cls) | |
414 | { | |
415 | } | |
416 | ||
417 | ||
418 | ||
419 | ||
420 | ||
421 |