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