3e206247b8e7ecd18c70a18ae8bf4260d2b418c4
[openafs.git] / src / sys / rmtsyss.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 /* Daemon that implements remote procedure call service for non-vendor system
11  * calls (currently setpag and pioctl). The AFS cache manager daemon, afsd,
12  * currently fires up this module, when the "-rmtsys" flag is given.
13  * This module resides in the lib/afs/librmtsys.a library.
14  */
15 #include <afsconfig.h>
16 #include <afs/param.h>
17
18 RCSID
19     ("$Header$");
20
21 #include <sys/types.h>
22 #include <sys/ioctl.h>
23 #include <afs/vice.h>
24 #include <netdb.h>
25 #include <netinet/in.h>
26 #include <sys/stat.h>
27 #include <sys/file.h>
28 #include <stdio.h>
29 #include <errno.h>
30 #include <rx/xdr.h>
31 #include <errno.h>
32 #include <signal.h>
33 #include <string.h>
34 /*#include <afs/cellconfig.h>*/
35 #include "rmtsys.h"
36
37 extern RMTSYS_ExecuteRequest();
38
39 #define NFS_EXPORTER        1   /* To probably handle more later */
40 #define PSETPAG             110 /* Also defined in afs/afs_pioctl.c */
41 #define PIOCTL_HEADER       6   /* # of words prepended to special pioctl */
42 #define PSetClientContext   99  /* Sets up caller's creds */
43 #define N_SECURITY_OBJECTS  1   /* No real security yet */
44
45 #define SETCLIENTCONTEXT(BLOB, host, uid, group0, group1, cmd, exportertype) { \
46            (BLOB)[0] = (host); \
47            (BLOB)[1] = (uid); \
48            (BLOB)[2] = (group0); \
49            (BLOB)[3] = (group1); \
50            (BLOB)[4] = (cmd); \
51            (BLOB)[5] = (exportertype); \
52 }
53
54
55 /* Main routine of the remote AFS system call server. The calling process will
56  * never return; this is currently called from afsd (when "-rmtsys" is passed
57  * as a parameter) */
58 rmtsysd()
59 {
60 /*  void catchsig(int); */
61     struct rx_securityClass *(securityObjects[N_SECURITY_OBJECTS]);
62     struct rx_service *service;
63
64     /* 
65      * Ignore SIGHUP signal since apparently is sent to the processes that
66      * start up from /etc/rc for some systems like hpux and aix3.1... 
67      */
68     signal(SIGHUP, SIG_IGN);
69
70     /* Initialize the rx-based RMTSYS server */
71     if (rx_Init(htons(AFSCONF_RMTSYSPORT)) < 0)
72         rmt_Quit("rx_init");
73     securityObjects[0] = rxnull_NewServerSecurityObject();
74     if (securityObjects[0] == (struct rx_securityClass *)0)
75         rmt_Quit("rxnull_NewServerSecurityObject");
76     service =
77         rx_NewService(0, RMTSYS_SERVICEID, AFSCONF_RMTSYSSERVICE,
78                       securityObjects, N_SECURITY_OBJECTS,
79                       RMTSYS_ExecuteRequest);
80     if (service == (struct rx_service *)0)
81         rmt_Quit("rx_NewService");
82     /* One may wish to tune some default RX params for better performance
83      * at some point... */
84     rx_SetMaxProcs(service, 2);
85     rx_StartServer(1);          /* Donate this process to the server process pool */
86 }
87
88
89 /* Implements the remote setpag(2) call. Note that unlike the standard call,
90  * here we also get back the new pag value; we need this so that the caller
91  * can add it to its group list via setgroups() */
92 afs_int32
93 SRMTSYS_SetPag(call, creds, newpag, errornumber)
94      struct rx_call *call;
95      clientcred *creds;
96      afs_int32 *newpag, *errornumber;
97 {
98     afs_uint32 blob[PIOCTL_HEADER];
99     struct ViceIoctl data;
100     register afs_int32 error;
101
102     *errornumber = 0;
103     SETCLIENTCONTEXT(blob, rx_HostOf(call->conn->peer), creds->uid,
104                      creds->group0, creds->group1, PSETPAG, NFS_EXPORTER);
105     data.in = (caddr_t) blob;
106     data.in_size = sizeof(blob);
107     data.out = (caddr_t) blob;
108     data.out_size = sizeof(blob);
109     /* force local pioctl call */
110     error = lpioctl(0, _VICEIOCTL(PSetClientContext), &data, 1);
111     if (error) {
112         if (errno == PSETPAG) {
113             *newpag = blob[0];  /* new pag value */
114         } else
115             *errornumber = errno;
116     }
117     return 0;
118 }
119
120
121 /* Implements the remote pioctl(2) call */
122 afs_int32
123 SRMTSYS_Pioctl(call, creds, path, cmd, follow, InData, OutData, errornumber)
124      struct rx_call *call;
125      clientcred *creds;
126      afs_int32 cmd, follow, *errornumber;
127      char *path;
128      rmtbulk *InData, *OutData;
129 {
130     register afs_int32 error;
131     struct ViceIoctl data;
132     char *pathp = path;
133     afs_uint32 blob[PIOCTL_HEADER];
134
135     *errornumber = 0;
136     SETCLIENTCONTEXT(blob, rx_HostOf(call->conn->peer), creds->uid,
137                      creds->group0, creds->group1, cmd, NFS_EXPORTER);
138     data.in =
139         (char *)malloc(InData->rmtbulk_len +
140                        PIOCTL_HEADER * sizeof(afs_int32));
141     if (!data.in)
142         return (-1);            /* helpless here */
143     if (!strcmp(path, NIL_PATHP))
144         pathp = (char *)0;      /* It meant to be NIL */
145     memcpy(data.in, blob, sizeof(blob));
146     inparam_conversion(cmd, InData->rmtbulk_val, 1);
147     memcpy(data.in + sizeof(blob), InData->rmtbulk_val, InData->rmtbulk_len);
148     data.in_size = InData->rmtbulk_len + PIOCTL_HEADER * sizeof(afs_int32);
149     data.out = OutData->rmtbulk_val;
150     data.out_size = OutData->rmtbulk_len;
151     /* force local pioctl call */
152     error = lpioctl(pathp, _VICEIOCTL(PSetClientContext), &data, follow);
153     if (error) {
154         *errornumber = errno;
155     } else {
156         /* Send the results back in network order */
157         outparam_conversion(cmd, data.out, 0);
158     }
159     free(data.in);
160     /* Note that we return success (i.e. 0) even when pioctl fails; that's
161      * because the actual errno is passed back via 'errornumber' and this call
162      * MUST return success error in order to get that OUT params back (YUCK!)
163      */
164     return (0);
165 }
166
167 rmt_Quit(msg, a, b)
168      char *msg;
169 {
170     fprintf(stderr, msg, a, b);
171     exit(1);
172 }