gcc-warnings-cleanup-20030701
[openafs.git] / src / sys / rmtsysc.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
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
10 /*
11  * This module (residing in lib/afs/librmtsys.a) implements the client side of
12  * the rpc version (via rx) of non-standard system calls. Currently only rpc
13  * calls of setpag, and pioctl are supported.
14  */
15 #include <afsconfig.h>
16 #include <afs/param.h>
17
18 RCSID("$Header$");
19
20 #include <errno.h>
21 #include <limits.h>
22 #include <sys/types.h>
23 #include <afs/vice.h>
24 #ifdef AFS_NT40_ENV
25 #include <winsock2.h>
26 #else
27 #include <netdb.h>
28 #include <netinet/in.h>
29 #include <sys/file.h>
30 #endif
31 #include <sys/stat.h>
32 #include <stdio.h>
33 #ifdef HAVE_STRING_H
34 #include <string.h>
35 #endif
36 #ifdef HAVE_UNISTD_H
37 #include <unistd.h>
38 #endif
39 #include <rx/xdr.h>
40 #include "rmtsys.h"
41
42
43 #define NOPAG       0xffffffff /* Also defined in afs/afs.h */
44 static afs_int32 hostAddr = 0;
45 static int   hostAddrLookup = 0;
46 char *afs_server=0, server_name[128];
47 afs_int32 host;
48 static afs_int32 SetClientCreds();
49
50 /* Picks up the name of the remote afs client host where the rmtsys 
51  * daemon resides. Since the clients may be diskless and/or readonly
52  * ones we felt it's better to rely on an shell environment
53  * (AFSSERVER) for the host name first. If that is not set, the
54  * $HOME/.AFSSERVER file is checked, otherwise the "/.AFSSERVER" is
55  * used.
56  */
57 afs_int32 GetAfsServerAddr(char *syscall)
58 {
59     register struct hostent *th;
60     char *getenv();
61
62     if (hostAddrLookup) {
63         /* Take advantage of caching and assume that the remote host
64          * address won't change during a single program's invocation.
65          */
66         return hostAddr;
67     }
68     hostAddrLookup = 1;
69
70     if (!(afs_server = getenv("AFSSERVER"))) {
71         char *home_dir;
72         FILE *fp;
73         int len;
74         
75         if (!(home_dir = getenv("HOME"))) {
76             /* Our last chance is the "/.AFSSERVER" file */
77             fp = fopen("/.AFSSERVER", "r");
78             if (fp == 0) {
79                 return 0;
80             }
81             fgets(server_name, 128, fp);
82             fclose(fp);
83         } else {
84             char pathname[256];
85
86             sprintf(pathname, "%s/%s", home_dir, ".AFSSERVER");
87             fp = fopen(pathname, "r");
88             if (fp == 0) {
89                 /* Our last chance is the "/.AFSSERVER" file */
90                 fp = fopen("/.AFSSERVER", "r");
91                 if (fp == 0) {
92                     return 0;
93                 }
94             }
95             fgets(server_name, 128, fp);
96             fclose(fp);
97         }
98         len = strlen(server_name);
99         if (len == 0) {
100             return 0;
101         }
102         if (server_name[len-1] == '\n') {
103             server_name[len-1] = 0;
104         }
105         afs_server = server_name;
106     }
107     th = gethostbyname(afs_server);
108     if (!th) {
109         printf("host %s not found; %s call aborted\n", afs_server, syscall);
110         return 0;
111     }
112     memcpy(&hostAddr, th->h_addr, sizeof(hostAddr));
113     return hostAddr;
114 }
115
116
117 /* Does the actual RX connection to the afs server */
118 struct rx_connection *rx_connection(afs_int32 *errorcode, char *syscall)
119 {
120     struct rx_connection *conn;
121     struct rx_securityClass *null_securityObject;
122
123     if (!(host = GetAfsServerAddr(syscall))) {
124         *errorcode = -1;
125         return (struct rx_connection *)0;
126     }   
127     *errorcode = rx_Init(0);
128     if(*errorcode) {
129         printf("Rx initialize failed \n");
130         return (struct rx_connection *)0;
131     }
132     null_securityObject = rxnull_NewClientSecurityObject();
133     conn = rx_NewConnection(host, htons(AFSCONF_RMTSYSPORT), RMTSYS_SERVICEID, null_securityObject, 0);
134     if (!conn) {
135         printf("Unable to make a new connection\n");
136         *errorcode = -1;
137         return (struct rx_connection *)0;
138     }
139     return conn;
140 }
141
142
143 /* WARNING: The calling program (i.e. klog) MUST be suid-root since we need to
144  * do a setgroups(2) call with the new pag.... */
145 #ifdef AFS_DUX40_ENV
146 #pragma weak setpag = afs_setpag
147 int afs_setpag(void)
148 #else
149 int setpag(void)
150 #endif
151 {
152     struct rx_connection *conn;
153     clientcred creds;
154     afs_int32 errorcode, errornumber, newpag, ngroups, j, groups[NGROUPS_MAX];
155
156     if (!(conn = rx_connection(&errorcode, "setpag"))) {
157         /* Remote call can't be performed for some reason.
158          * Try the local 'setpag' system call ... */
159         errorcode = lsetpag();
160         return errorcode;
161     }
162     ngroups = SetClientCreds(&creds, groups);
163     errorcode = RMTSYS_SetPag(conn, &creds, &newpag, &errornumber);
164     if (errornumber) {
165         errno = errornumber;
166         errorcode = -1;
167         printf("Warning: Remote setpag to %s has failed (err=%d)...\n",
168                 afs_server, errno);
169     }
170     if (errorcode) {
171         return errorcode;
172     }
173     if (afs_get_pag_from_groups(groups[0], groups[1]) == NOPAG) {
174         /* we will have to shift grouplist to make room for pag */
175         if (ngroups + 2 > NGROUPS_MAX) {
176             /* this is what the real setpag returns */
177            errno = E2BIG;
178            return -1;
179         }
180         for (j = ngroups - 1; j >= 0; j--) {
181             groups[j + 2] = groups[j];
182         }
183         ngroups += 2;
184     }
185     afs_get_groups_from_pag(newpag, &groups[0], &groups[1]);
186     if (setgroups(ngroups, groups) == -1) {
187         return -1;
188     }
189 #ifdef  AFS_HPUX_ENV
190     errorcode = setuid(getuid());
191 #else
192     errorcode = setreuid(-1, getuid());
193 #endif /* AFS_HPUX_ENV */
194     return errorcode;
195 }
196
197
198 /* Remote pioctl(2) client routine */
199 #ifdef AFS_DUX40_ENV
200 #pragma weak pioctl = afs_pioctl
201 int afs_pioctl(char *path, afs_int32 cmd, struct ViceIoctl *data, afs_int32 follow) 
202 #else
203 int pioctl(char *path, afs_int32 cmd, struct ViceIoctl *data, afs_int32 follow) 
204 #endif
205 {
206     struct rx_connection *conn;
207     clientcred creds;
208     afs_int32 errorcode, errornumber, ins= data->in_size;
209     afs_uint32 groups[NGROUPS_MAX];
210     rmtbulk InData, OutData;
211     char pathname[256], *pathp = pathname, *inbuffer;
212 #if 0/*ndef HAVE_GETCWD*/ /* XXX enable when autoconf happens */
213     extern char *getwd();
214 #define getcwd(x,y) getwd(x)
215 #endif
216     if (!(conn = rx_connection(&errorcode, "pioctl"))) {
217         /* Remote call can't be performed for some reason.
218          * Try the local 'pioctl' system call ... */
219         errorcode = lpioctl(path, cmd, data, follow);
220         return errorcode;
221     }
222     (void) SetClientCreds(&creds, groups);
223 #ifdef  AFS_OSF_ENV
224     if (!ins) ins = 1;
225 #endif    
226     if (!(inbuffer = (char *)malloc(ins)))
227          return (-1);       /* helpless here */
228     if (data->in_size)
229         memcpy(inbuffer, data->in, data->in_size);
230     InData.rmtbulk_len = data->in_size;
231     InData.rmtbulk_val = inbuffer;
232     inparam_conversion(cmd, InData.rmtbulk_val, 0);
233     OutData.rmtbulk_len = data->out_size;
234     OutData.rmtbulk_val = data->out;
235     /* We always need to pass absolute pathnames to the remote pioctl since we
236      * lose the current directory value when doing an rpc call. Below we
237      * prepend the current absolute path directory, if the name is relative */
238     if (path) {
239         if (*path != '/') {
240             /* assuming relative path name */
241             if (getcwd(pathname, 256) == NULL) {
242                 free(inbuffer);
243                 printf("getwd failed; exiting\n");
244                 exit(1);
245             } 
246             strcpy(pathname+strlen(pathname), "/");
247             strcat(pathname, path);
248         } else {
249             strcpy(pathname, path);
250         }
251     } else {
252         /* Special meaning for a "NULL" pathname since xdr_string hates nil
253          * pointers, at least on non-RTS; of course the proper solution would
254          * be to change the interface declartion. */
255         strcpy(pathname, NIL_PATHP);
256     }
257     errorcode = RMTSYS_Pioctl(conn, &creds, pathp, cmd,  follow, &InData,
258                               &OutData, &errornumber);
259     if (errornumber) {
260         errno = errornumber;
261         errorcode = -1;         /* Necessary since errorcode is 0 on
262                                  * standard remote pioctl errors */
263         if (errno != EDOM && errno != EACCES)
264             printf("Warning: Remote pioctl to %s has failed (err=%d)...\n",
265                     afs_server, errno);
266     }
267     if (!errorcode) {
268         /* Do the conversions back to the host order; store the results back
269          * on the same buffer */
270         outparam_conversion(cmd, OutData.rmtbulk_val, 1);
271     }
272     free(inbuffer);
273     return errorcode;
274 }
275
276     
277 int afs_get_pag_from_groups(afs_uint32 g0, afs_uint32 g1)
278 {
279         afs_uint32 h, l, result;
280
281         g0 -= 0x3f00;
282         g1 -= 0x3f00;
283         if (g0 < 0xc000 && g1 < 0xc000) {
284                 l = ((g0 & 0x3fff) << 14) | (g1 & 0x3fff);
285                 h = (g0 >> 14);
286                 h = (g1 >> 14) + h + h + h;
287                 result =  ((h << 28) | l);
288                 /* Additional testing */        
289                 if (((result >> 24) & 0xff) == 'A')
290                         return result;
291                 else
292                         return NOPAG;
293         }
294         return NOPAG;
295 }
296
297
298 afs_get_groups_from_pag(afs_uint32 pag, afs_uint32 *g0p, afs_uint32 *g1p)
299 {
300         unsigned short g0, g1;
301
302         pag &= 0x7fffffff;
303         g0 = 0x3fff & (pag >> 14);
304         g1 = 0x3fff & pag;
305         g0 |= ((pag >> 28) / 3) << 14;
306         g1 |= ((pag >> 28) % 3) << 14;
307         *g0p = g0 + 0x3f00;
308         *g1p = g1 + 0x3f00;
309 }
310
311
312 static afs_int32 SetClientCreds(struct clientcred *creds, afs_int32 *groups)
313 {
314     afs_int32 ngroups;
315
316     creds->uid = getuid();
317     groups[0] = groups[1] = 0;
318     ngroups = getgroups(NGROUPS_MAX, groups);
319     creds->group0 = groups[0];
320     creds->group1 = groups[1];
321     return ngroups;
322 }