1fa5b48d97c5c4b8f8af6d6c1e476e05d66e0474
[openafs.git] / src / JAVA / libjafs / UserToken.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 <afs/param.h>
23
24 #include "Internal.h"
25 #include "org_openafs_jafs_Token.h"
26
27 #include <sys/stat.h>
28 #include <sys/ioctl.h>
29 #include <afs/vice.h>
30 #include <netinet/in.h>
31 #include <afs/venus.h>
32 #include <afs/afs_args.h>
33 /*#include <afs/afs_osi.h>
34   #include <afs/afs_usrops.h>*/
35 #include <pthread.h>
36
37 #ifdef DMALLOC
38 #include "dmalloc.h"
39 #endif
40
41 pthread_mutex_t jafs_init_lock;
42 extern pthread_mutex_t jafs_login_lock;
43 extern int readCacheParms(char *afsMountPoint, char *afsConfDir,
44                           char *afsCacheDir,  int *cacheBlocks, 
45                           int *cacheFiles, int *cacheStatEntries,
46                           int *dCacheSize, int *vCacheSize, int *chunkSize,
47                           int *closeSynch, int *debug, int *nDaemons, 
48                           int *cacheFlags, char *logFile);
49
50 /**
51  * Be carefull with the memory management:
52  *
53  * - For every GetStringUTFChars call the corresponding ReleaseStringUTFChars.
54  * - For every Get<type>ArrayElements call the corresponding
55  *   Release<type>ArrayElements
56  * - For every malloc call the corresponding free.
57  */
58
59 int osi_audit(void)
60 {
61    return 0;
62 }
63
64 /*JNIEXPORT void JNICALL Java_org_openafs_jafs_Token_callDebugger
65   (JNIEnv *env, jobject obj)
66 {
67     fprintf(stderr, "callDebugger called\n");
68     __asm__("int $0x3");
69 }*/
70
71 /**
72  * Initialize the user space library.
73  *
74  * The user space client must be initialized prior to any
75  * user space related methods, including: klog, unlog, relog,
76  * and shutdown.
77  *
78  * env      the Java environment
79  * cls      the current Java class
80  *
81  * throws AFSException
82  */
83 JNIEXPORT void JNICALL Java_org_openafs_jafs_Token_initUserSpace
84   (JNIEnv *env, jclass cls)
85 {
86   char afsMountPoint[100], afsConfDir[100], afsCacheDir[100], logFile[100];
87   jfieldID fid;
88   int pagval;
89
90   /* Initialize each init parameter with its associated default value */
91   int cacheBlocks = 100000;
92   int cacheFiles  = 12500;
93   int cacheStatEntries = 8192;
94   int dCacheSize  = 11398;
95   int vCacheSize  = 128;
96   int chunkSize   = 0;
97   int closeSynch  = 0;
98   int debug       = 0;
99   int nDaemons    = 3; 
100   int cacheFlags  = -1;
101
102   /* Initialize each init parameter with its associated default value */
103   strcpy(afsMountPoint, "/afs");
104   strcpy(afsConfDir,  "/usr/afswsp/etc");
105   strcpy(afsCacheDir, "/usr/afswsp/cache");
106   strcpy(logFile,     "/usr/afswsp/log/libjafs.log");
107
108   pthread_mutex_init(&jafs_init_lock, NULL);
109   pthread_mutex_lock(&jafs_init_lock);
110
111   readCacheParms(afsMountPoint, afsConfDir, afsCacheDir,
112                  &cacheBlocks, &cacheFiles, &cacheStatEntries,
113                  &dCacheSize, &vCacheSize, &chunkSize,
114                  &closeSynch, &debug, &nDaemons, &cacheFlags,
115                  logFile);
116
117   /* See cache.tune for configuration details */
118   if (debug) {
119     fprintf(stderr, "uafs_Init(\"init_native\", \"%s\", \"%s\", \"%s\"",
120                       "%d, %d, %d,"
121                       "%d, %d, %d,"
122                       "%d, %d, %d, %d, \"%s\");\n",
123               afsMountPoint, afsConfDir, afsCacheDir,
124               cacheBlocks, cacheFiles, cacheStatEntries,
125               dCacheSize, vCacheSize, chunkSize,
126               closeSynch, debug, nDaemons, cacheFlags, logFile);
127   }
128   uafs_Init("init_native", afsMountPoint, afsConfDir, afsCacheDir,
129              cacheBlocks, cacheFiles, cacheStatEntries,
130              dCacheSize, vCacheSize, chunkSize,
131              closeSynch, debug, nDaemons, cacheFlags, logFile);
132
133
134   /* make the initial pag the unauthenticated pag */
135   afs_setpag();
136   uafs_unlog();
137   pagval = afs_getpag_val();
138
139   fid = (*env)->GetStaticFieldID(env, cls, "ANYUSER_PAG_ID", "I");
140   if (fid == 0) {
141     fprintf(stderr,
142     "UserToken::init(): GetFieldID (ANYUSER_PAG_ID) failed\n");
143     return;
144   }
145     
146   (*env)->SetStaticIntField(env, cls, fid, pagval);
147
148   pthread_mutex_unlock(&jafs_init_lock);
149 }
150
151 /**
152  * Authenticates a user in kas, and binds that authentication
153  * to the current process.
154  *
155  * env      the Java environment
156  * obj      the current Java class
157  * loginUTF    the login to authenticate (expected as username@cellname)
158  * passwordUTF the password of the login
159  * id           the existing pag (or 0)
160  *
161  * returns the assigned pag
162  *
163  * throws AFSException
164  */
165 JNIEXPORT jint JNICALL
166 Java_org_openafs_jafs_Token_klog (JNIEnv *env, jobject obj,
167   jstring jusername, jstring jpassword, jstring jcell, jint id)
168 {
169   char *username;
170   char *password;
171   char *cell;
172   char *reason;
173   jint rc = -1;
174   int code;
175
176   if( jcell != NULL ) { 
177     cell = (char*) (*env)->GetStringUTFChars(env, jcell, 0);
178     if( !cell ) {
179       char *error = "UserToken::klog(): failed to get cell name\n";
180       fprintf(stderr, error);
181       throwMessageException( env, error );
182       return -1;
183     }
184   } else {
185     cell = NULL;
186   }
187
188   if( jusername != NULL ) {
189     username = (char*) (*env)->GetStringUTFChars(env, jusername, 0);
190     if( !username ) {
191       char *error = "UserToken::klog(): failed to get username\n";
192       (*env)->ReleaseStringUTFChars(env, jcell, cell);
193       fprintf(stderr, error);
194       throwMessageException( env, error );
195       return -1;
196     }
197   } else {
198     username = NULL;
199   }
200   if( jpassword != NULL ) {
201     password = (char*) (*env)->GetStringUTFChars(env, jpassword, 0);
202     if( !password ) {
203       char *error = "UserToken::klog(): failed to get password\n";
204       (*env)->ReleaseStringUTFChars(env, jcell, cell);
205       (*env)->ReleaseStringUTFChars(env, jusername, username);
206       fprintf(stderr, error);
207       throwMessageException( env, error );
208       return -1;
209     }
210   } else {
211     password = NULL;
212   }
213
214   if (id == 0) {
215     code = uafs_klog(username, cell, password, &reason);
216   } else {
217     /* Use existing PAG for this thread */
218     code = afs_setpag_val(id);
219     if (code != 0) code = 180492L;  /* KABADARGUMENT */
220     if (!code) code = uafs_klog_nopag(username, cell, password, &reason);
221   }
222
223   if (code != 0) {
224     if( cell != NULL ) {
225       (*env)->ReleaseStringUTFChars(env, jcell, cell);
226     }
227     if( username != NULL ) {
228       (*env)->ReleaseStringUTFChars(env, jusername, username);
229     }
230     if( password != NULL ) {
231       (*env)->ReleaseStringUTFChars(env, jpassword, password);
232     }
233     fprintf(stderr, "UserToken::klog(): uafs_klog failed to cell %s: %s\n",
234                      cell, reason);
235     fprintf(stderr, "code = %d\n", code);
236     throwAFSException( env, code );
237   }
238
239   /* Get the PAG we were assigned as the return value */
240   rc = afs_getpag_val();
241
242   /* clean up */
243   if( cell != NULL ) {
244     (*env)->ReleaseStringUTFChars(env, jcell, cell);
245   }
246   if( username != NULL ) {
247     (*env)->ReleaseStringUTFChars(env, jusername, username);
248   }
249   if( password != NULL ) {
250     (*env)->ReleaseStringUTFChars(env, jpassword, password);
251   }
252
253   /* return PAG ID */
254   return rc;
255 }
256
257 /**
258  * Authenticates a user in KAS by a previously acquired PAG ID, and binds 
259  * that authentication to the current thread or native process.
260  *
261  * <P> This method does not require the user's username and password to
262  * fully authenticate their request.  Rather it utilizes the user's PAG ID
263  * to recapture the user's existing credentials.
264  *
265  * env      the Java environment
266  * obj      the current Java class
267  * id       User's current PAG (process authentication group) ID
268  *
269  * throws AFSException
270  */
271 JNIEXPORT void JNICALL Java_org_openafs_jafs_Token_relog
272   (JNIEnv *env, jobject obj, jint id)
273 {
274   int rc;
275
276   rc = afs_setpag_val(id);
277
278   if (rc != 0) {
279     throwAFSException( env, rc );
280   }
281 }
282
283 /**
284  * Authenticates a user in KAS, and binds that authentication
285  * to the current process.
286  *
287  * env      the Java environment
288  * obj      the current Java class
289  *
290  * throws AFSException
291  */
292 JNIEXPORT void JNICALL Java_org_openafs_jafs_Token_unlog
293   (JNIEnv *env, jobject obj)
294 {
295   int rc;
296
297   rc = uafs_unlog();
298
299   if (rc != 0) {
300     throwAFSException( env, rc );
301   }
302 }
303
304 /**
305  * Inform the native library that the application is 
306  * shutting down and will be unloading.
307  *
308  * <p> The library will make a call informing the file server that it will 
309  * no longer be available for callbacks.
310  *
311  * env      the Java environment
312  * obj      the current Java class
313  *
314  * throws AFSException
315  */
316 JNIEXPORT void JNICALL Java_org_openafs_jafs_Token_shutdown
317   (JNIEnv *env, jobject obj)
318 {
319   uafs_Shutdown();
320 }
321
322
323
324