Blob


1 #include <u.h>
2 #include <libc.h>
3 #include <ip.h>
4 #include <thread.h>
5 #include <sunrpc.h>
7 /*
8 * Sun RPC server; for now, no reply cache
9 */
11 static void sunrpcproc(void*);
12 static void sunrpcrequestthread(void*);
13 static void sunrpcreplythread(void*);
14 static void sunrpcforkthread(void*);
15 static SunProg *sunfindprog(SunSrv*, SunMsg*, SunRpc*, Channel**);
17 typedef struct Targ Targ;
18 struct Targ
19 {
20 void (*fn)(void*);
21 void *arg;
22 };
24 SunSrv*
25 sunsrv(void)
26 {
27 SunSrv *srv;
29 srv = emalloc(sizeof(SunSrv));
30 srv->chatty = 0;
31 srv->crequest = chancreate(sizeof(SunMsg*), 16);
32 srv->creply = chancreate(sizeof(SunMsg*), 16);
33 srv->cthread = chancreate(sizeof(Targ), 4);
35 proccreate(sunrpcproc, srv, SunStackSize);
36 return srv;
37 }
39 void
40 sunsrvprog(SunSrv *srv, SunProg *prog, Channel *c)
41 {
42 if(srv->nprog%16 == 0){
43 srv->prog = erealloc(srv->prog, (srv->nprog+16)*sizeof(srv->prog[0]));
44 srv->cdispatch = erealloc(srv->cdispatch, (srv->nprog+16)*sizeof(srv->cdispatch[0]));
45 }
46 srv->prog[srv->nprog] = prog;
47 srv->cdispatch[srv->nprog] = c;
48 srv->nprog++;
49 }
51 static void
52 sunrpcproc(void *v)
53 {
54 threadcreate(sunrpcreplythread, v, SunStackSize);
55 threadcreate(sunrpcrequestthread, v, SunStackSize);
56 threadcreate(sunrpcforkthread, v, SunStackSize);
58 }
60 static void
61 sunrpcforkthread(void *v)
62 {
63 SunSrv *srv = v;
64 Targ t;
66 while(recv(srv->cthread, &t) == 1)
67 threadcreate(t.fn, t.arg, SunStackSize);
68 }
70 void
71 sunsrvthreadcreate(SunSrv *srv, void (*fn)(void*), void *arg)
72 {
73 Targ t;
75 t.fn = fn;
76 t.arg = arg;
77 send(srv->cthread, &t);
78 }
80 static void
81 sunrpcrequestthread(void *v)
82 {
83 int status;
84 uchar *p, *ep;
85 Channel *c;
86 SunSrv *srv = v;
87 SunMsg *m;
88 SunProg *pg;
89 SunStatus ok;
91 while((m = recvp(srv->crequest)) != nil){
92 /* could look up in cache here? */
94 if(srv->chatty) fprint(2, "sun msg %p count %d\n", m, m->count);
95 m->srv = srv;
96 p = m->data;
97 ep = p+m->count;
98 status = m->rpc.status;
99 if(sunrpcunpack(p, ep, &p, &m->rpc) != SunSuccess){
100 fprint(2, "in: %.*H unpack failed\n", m->count, m->data);
101 sunmsgdrop(m);
102 continue;
104 if(srv->chatty)
105 fprint(2, "in: %B\n", &m->rpc);
106 if(status){
107 sunmsgreplyerror(m, status);
108 continue;
110 if(srv->alwaysreject){
111 if(srv->chatty)
112 fprint(2, "\trejecting\n");
113 sunmsgreplyerror(m, SunAuthTooWeak);
114 continue;
117 if(!m->rpc.iscall){
118 sunmsgreplyerror(m, SunGarbageArgs);
119 continue;
122 if((pg = sunfindprog(srv, m, &m->rpc, &c)) == nil){
123 /* sunfindprog sent error */
124 continue;
127 p = m->rpc.data;
128 ep = p+m->rpc.ndata;
129 m->call = nil;
130 if((ok = suncallunpackalloc(pg, m->rpc.proc<<1, p, ep, &p, &m->call)) != SunSuccess){
131 sunmsgreplyerror(m, ok);
132 continue;
134 m->call->rpc = m->rpc;
136 if(srv->chatty)
137 fprint(2, "\t%C\n", m->call);
139 m->pg = pg;
140 sendp(c, m);
144 static SunProg*
145 sunfindprog(SunSrv *srv, SunMsg *m, SunRpc *rpc, Channel **pc)
147 int i, vlo, vhi;
148 SunProg *pg;
150 vlo = 0x7fffffff;
151 vhi = -1;
153 for(i=0; i<srv->nprog; i++){
154 pg = srv->prog[i];
155 if(pg->prog != rpc->prog)
156 continue;
157 if(pg->vers == rpc->vers){
158 *pc = srv->cdispatch[i];
159 return pg;
161 /* right program, wrong version: record range */
162 if(pg->vers < vlo)
163 vlo = pg->vers;
164 if(pg->vers > vhi)
165 vhi = pg->vers;
167 if(vhi == -1){
168 if(srv->chatty)
169 fprint(2, "\tprogram %ud unavailable\n", rpc->prog);
170 sunmsgreplyerror(m, SunProgUnavail);
171 }else{
172 /* putting these in rpc is a botch */
173 rpc->low = vlo;
174 rpc->high = vhi;
175 if(srv->chatty)
176 fprint(2, "\tversion %ud unavailable; have %d-%d\n", rpc->vers, vlo, vhi);
177 sunmsgreplyerror(m, SunProgMismatch);
179 return nil;
182 static void
183 sunrpcreplythread(void *v)
185 SunMsg *m;
186 SunSrv *srv = v;
188 while((m = recvp(srv->creply)) != nil){
189 /* could record in cache here? */
190 sendp(m->creply, m);
194 int
195 sunmsgreplyerror(SunMsg *m, SunStatus error)
197 uchar *p, *bp, *ep;
198 int n;
200 m->rpc.status = error;
201 m->rpc.iscall = 0;
202 m->rpc.verf.flavor = SunAuthNone;
203 m->rpc.data = nil;
204 m->rpc.ndata = 0;
206 if(m->srv->chatty)
207 fprint(2, "out: %B\n", &m->rpc);
209 n = sunrpcsize(&m->rpc);
210 bp = emalloc(n);
211 ep = bp+n;
212 p = bp;
213 if(sunrpcpack(p, ep, &p, &m->rpc) < 0){
214 fprint(2, "sunrpcpack failed\n");
215 sunmsgdrop(m);
216 return 0;
218 if(p != ep){
219 fprint(2, "sunmsgreplyerror: rpc sizes didn't work out\n");
220 sunmsgdrop(m);
221 return 0;
223 free(m->data);
224 m->data = bp;
225 m->count = n;
226 sendp(m->srv->creply, m);
227 return 0;
230 int
231 sunmsgreply(SunMsg *m, SunCall *c)
233 int n1, n2;
234 uchar *bp, *p, *ep;
236 c->type = m->call->type+1;
237 c->rpc.iscall = 0;
238 c->rpc.prog = m->rpc.prog;
239 c->rpc.vers = m->rpc.vers;
240 c->rpc.proc = m->rpc.proc;
241 c->rpc.xid = m->rpc.xid;
243 if(m->srv->chatty){
244 fprint(2, "out: %B\n", &c->rpc);
245 fprint(2, "\t%C\n", c);
248 n1 = sunrpcsize(&c->rpc);
249 n2 = suncallsize(m->pg, c);
251 bp = emalloc(n1+n2);
252 ep = bp+n1+n2;
253 p = bp;
254 if(sunrpcpack(p, ep, &p, &c->rpc) != SunSuccess){
255 fprint(2, "sunrpcpack failed\n");
256 return sunmsgdrop(m);
258 if(suncallpack(m->pg, p, ep, &p, c) != SunSuccess){
259 fprint(2, "pg->pack failed\n");
260 return sunmsgdrop(m);
262 if(p != ep){
263 fprint(2, "sunmsgreply: sizes didn't work out\n");
264 return sunmsgdrop(m);
266 free(m->data);
267 m->data = bp;
268 m->count = n1+n2;
270 sendp(m->srv->creply, m);
271 return 0;
274 int
275 sunmsgdrop(SunMsg *m)
277 free(m->data);
278 free(m->call);
279 memset(m, 0xFB, sizeof *m);
280 free(m);
281 return 0;