jafs-library-20020725
[openafs.git] / src / JAVA / libjafs / AdminToken.c
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
34 /**
35  * Static function used to initialize the client library and the 
36  * jafs library.
37  *
38  * env      the Java environment
39  * obj      the current Java object
40  */
41 JNIEXPORT void JNICALL 
42 Java_org_openafs_jafs_Token_initializeAdminClient(JNIEnv *env, jclass cls)
43 {
44   afs_status_t ast;
45   if( !afsclient_Init( &ast ) ) {
46     throwAFSException( env, ast );
47     return;
48   }
49 }
50
51
52 /**
53  * Authenticates the given user and password in the cell.  Returns
54  * a token that can be used to prove this authentication later.
55  *
56  * env      the Java environment
57  * obj      the current Java object
58  * jcellName    the name of the cell in which to authenticate this user
59  * juserName    the name of the user to authenticate
60  * jpassword    the password of the user
61  * returns a token representing the authentication
62  */
63 JNIEXPORT jint JNICALL 
64 Java_org_openafs_jafs_Token_getToken
65   (JNIEnv *env, jobject obj, jstring jcellName, jstring juserName,
66    jstring jpassword)
67 {
68   afs_status_t ast;
69   const char *cellName;
70   const char *userName;
71   const char *password;
72   void *tokenHandle;
73   int rc;
74
75   // convert java strings
76   if( jcellName != NULL ) { 
77       cellName = (*env)->GetStringUTFChars(env, jcellName, 0);
78       if( !cellName ) {
79           throwAFSException( env, JAFSADMNOMEM );
80           return 0;    
81       }
82   } else {
83       cellName = NULL;
84   }
85   if( juserName != NULL ) {
86       userName = (*env)->GetStringUTFChars(env, juserName, 0);
87       if( !userName ) {
88           throwAFSException( env, JAFSADMNOMEM );
89           return 0;    
90       }
91   } else {
92       userName = NULL;
93   }
94   if( jpassword != NULL ) {
95       password = (*env)->GetStringUTFChars(env, jpassword, 0);
96       if( !password ) {
97           throwAFSException( env, JAFSADMNOMEM );
98           return 0;    
99       }
100   } else {
101       password = NULL;
102   }
103
104   if ( !(afsclient_TokenGetNew( cellName, userName, password, &tokenHandle, 
105                                 &ast) ) ) {
106     // release converted strings
107       if( cellName != NULL ) {
108           (*env)->ReleaseStringUTFChars(env, jcellName, cellName);
109       }
110       if( userName != NULL ) {
111           (*env)->ReleaseStringUTFChars(env, juserName, userName);
112       }
113       if( password != NULL ) {
114           (*env)->ReleaseStringUTFChars(env, jpassword, password);
115       }
116       throwAFSException( env, ast );
117       return 0;
118   }
119
120   // release converted strings
121   if( cellName != NULL ) {
122       (*env)->ReleaseStringUTFChars(env, jcellName, cellName);
123   }
124   if( userName != NULL ) {
125       (*env)->ReleaseStringUTFChars(env, juserName, userName);
126   }
127   if( password != NULL ) {
128       (*env)->ReleaseStringUTFChars(env, jpassword, password);
129   }
130
131   return (jint) tokenHandle;
132 }
133
134 /**
135  * Closes the given currently open token.
136  *
137  * env      the Java environment
138  * obj      the current Java object
139  * tokenHandle   the token to close
140  */
141 JNIEXPORT void JNICALL 
142 Java_org_openafs_jafs_Token_close
143   (JNIEnv *env, jobject obj, jint tokenHandle)
144 {
145     afs_status_t ast;
146
147     if( !afsclient_TokenClose( (void *) tokenHandle, &ast ) ) {
148       throwAFSException( env, ast );
149       return;
150     }
151 }
152
153 /**
154  * Opens a cell for administrative use, based on the token provided.  
155  * Returns a cell handle to be used by other methods as a means of 
156  * authentication.
157  *
158  * env      the Java environment
159  * obj      the current Java object
160  * jcellName    the name of the cell for which to get the handle
161  * tokenHandle    a token handle previously returned by a call to getToken
162  * returns a handle to the open cell
163  */
164 JNIEXPORT jint JNICALL 
165 Java_org_openafs_jafs_Cell_getCellHandle
166   (JNIEnv *env, jobject obj, jstring jcellName, jint tokenHandle)
167 {
168   afs_status_t ast;
169   const char *cellName;
170   void *cellHandle;
171
172   if( jcellName != NULL ) {
173     cellName = (*env)->GetStringUTFChars(env, jcellName, 0);
174     if( !cellName ) {
175         throwAFSException( env, JAFSADMNOMEM );
176         return;    
177     }
178   } else {
179     cellName = NULL;
180   }
181
182   if( !afsclient_CellOpen( cellName, (void *) tokenHandle, 
183                            &cellHandle, &ast ) ) {
184     if( cellName != NULL ) {
185       (*env)->ReleaseStringUTFChars(env, jcellName, cellName);
186     }  
187     throwAFSException( env, ast );
188     return;
189   }
190
191   if( cellName != NULL ) {
192       (*env)->ReleaseStringUTFChars(env, jcellName, cellName);
193   }  
194   return (jint) cellHandle;
195 }
196
197 /**
198  * Closes the given currently open cell handle.
199  *
200  * env      the Java environment
201  * obj      the current Java object
202  * cellHandle   the cell handle to close
203  */
204 JNIEXPORT void JNICALL 
205 Java_org_openafs_jafs_Cell_closeCell (JNIEnv *env, jobject obj, 
206                                          jint cellHandle)
207 {
208
209    afs_status_t ast;
210
211     if( !afsclient_CellClose( (void *) cellHandle, &ast ) ) {
212       throwAFSException( env, ast );
213       return;
214     }
215
216 }
217
218 /**
219  * Opens a server for administrative vos use, based on the cell handle 
220  * provided.  Returns a vos server handle to be used by other 
221  * methods as a means of identification.
222  *
223  * env      the Java environment
224  * obj      the current Java object
225  * cellHandle    a cell handle previously returned by 
226  *                      a call to getCellHandle
227  * jserverName    the name of the server for which to retrieve 
228  *                      a vos handle
229  * returns a vos handle to the server
230  */
231 JNIEXPORT jint JNICALL 
232 Java_org_openafs_jafs_Server_getVosServerHandle
233   (JNIEnv *env, jobject obj, jint cellHandle, jstring jserverName)
234 {
235   afs_status_t ast;
236   void *serverHandle;
237   // convert java string
238   const char *serverName;
239
240   if( jserverName != NULL ) {
241       serverName = (*env)->GetStringUTFChars(env, jserverName, 0);
242       if( !serverName ) {
243           throwAFSException( env, JAFSADMNOMEM );
244           return;    
245       }
246   } else {
247       serverName = NULL;
248   }
249
250   if( !vos_ServerOpen( (void *) cellHandle, serverName, 
251                        (void **) &serverHandle, &ast ) ) {
252       if( serverName != NULL ) {
253           (*env)->ReleaseStringUTFChars(env, jserverName, serverName);
254       }
255       throwAFSException( env, ast );
256       return 0;
257   }
258
259   // release converted string
260   if( serverName != NULL ) {
261       (*env)->ReleaseStringUTFChars(env, jserverName, serverName);
262   }
263
264   return (jint) serverHandle;
265 }
266
267 /**
268  * Closes the given currently open vos server handle.
269  *
270  * env      the Java environment
271  * obj      the current Java object
272  * vosServerHandle   the vos server handle to close
273  */
274 JNIEXPORT void JNICALL 
275 Java_org_openafs_jafs_Server_closeVosServerHandle
276   (JNIEnv *env, jobject obj, jint vosServerHandle)
277 {
278     afs_status_t ast;
279
280     if( !vos_ServerClose( (void *) vosServerHandle, &ast ) ) {
281       throwAFSException( env, ast );
282       return;
283     }
284 }
285
286 /**
287  * Opens a server for administrative bos use, based on the cell handle 
288  * provided.  Returns a bos server handle to be used by other methods 
289  * as a means of identification.
290  *
291  * env      the Java environment
292  * obj      the current Java object
293  * cellHandle    a cell handle previously returned by a call 
294  *                      to getCellHandle
295  * jserverName    the name of the server for which to retrieve 
296  *                      a bos handle
297  * returns a bos handle to the server
298  */
299 JNIEXPORT jint JNICALL 
300 Java_org_openafs_jafs_Server_getBosServerHandle
301   (JNIEnv *env, jobject obj, jint cellHandle, jstring jserverName)
302 {
303   afs_status_t ast;
304   void *serverHandle;
305   // convert java string
306   const char *serverName;
307
308   if( jserverName != NULL ) {
309       serverName = (*env)->GetStringUTFChars(env, jserverName, 0);
310       if( !serverName ) {
311           throwAFSException( env, JAFSADMNOMEM );
312           return;    
313       }
314   } else {
315       serverName = NULL;
316   }
317
318   if( !bos_ServerOpen( (void *) cellHandle, serverName, 
319                        (void **) &serverHandle, &ast ) ) {
320       if( serverName != NULL ) {
321           (*env)->ReleaseStringUTFChars(env, jserverName, serverName);
322       }
323       throwAFSException( env, ast );
324       return 0;
325   }
326
327   // release converted string
328   if( serverName != NULL ) {
329       (*env)->ReleaseStringUTFChars(env, jserverName, serverName);
330   }
331
332   return (jint) serverHandle;
333 }
334
335 /**
336  * Closes the given currently open bos server handle.
337  *
338  * env      the Java environment
339  * obj      the current Java object
340  * bosServerHandle   the bos server handle to close
341  */
342 JNIEXPORT void JNICALL 
343 Java_org_openafs_jafs_Server_closeBosServerHandle
344   (JNIEnv *env, jobject obj, jint bosServerHandle)
345 {
346     afs_status_t ast;
347
348     if( !bos_ServerClose( (void *) bosServerHandle, &ast ) ) {
349       throwAFSException( env, ast );
350       return;
351     }
352 }
353
354 /**
355  * Gets the expiration time for a given token.
356  *
357  * env      the Java environment
358  * obj      the current Java object
359  *
360  * tokenHandle    a token handle previously returned by a call 
361  *                       to getToken
362  * returns a long representing the UTC time for the token expiration
363  */
364 JNIEXPORT jlong JNICALL 
365 Java_org_openafs_jafs_Token_getExpiration
366   (JNIEnv *env, jobject obj, jint tokenHandle)
367 {
368     afs_status_t ast;
369     unsigned long expTime;
370     char *prince = malloc( sizeof(char)*KAS_MAX_NAME_LEN ); 
371     char *inst = malloc( sizeof(char)*KAS_MAX_NAME_LEN );    
372     char *cell = malloc( sizeof(char)*AFS_MAX_SERVER_NAME_LEN );    
373     int hkt;
374
375     if( !prince || !inst || !cell ) {
376       if( prince ) {
377         free( prince );
378       }
379       if( inst ) {
380         free( inst );
381       }
382       if( cell ) {
383         free( cell );
384       }
385       throwAFSException( env, JAFSADMNOMEM );
386       return;    
387     }
388
389     if( !afsclient_TokenQuery( (void *) tokenHandle, &expTime, prince, inst, 
390                                cell, &hkt, &ast ) ) {
391         free( prince );
392         free( inst );
393         free( cell );
394         throwAFSException( env, ast );
395         return 0;
396     }
397
398     free( prince );
399     free( inst );
400     free( cell );
401
402     return (jlong) expTime;
403 }
404
405 // reclaim global memory used by this portion
406 JNIEXPORT void JNICALL 
407 Java_org_openafs_jafs_Token_reclaimAuthMemory (JNIEnv *env, jclass cls)
408 {
409 }
410
411
412
413
414
415