2 * dial - connect to a service (parallel version)
7 typedef struct Conn Conn;
8 typedef struct Dest Dest;
16 Maxcsreply = 64*80, /* this is probably overly generous */
18 * this should be a plausible slight overestimate for non-interactive
19 * use even if it's ridiculously long for interactive use.
21 Maxconnms = 20*60*1000, /* 20 minutes */
38 * malloc these; they need to be writable by this proc & all children.
39 * the stack is private to each proc, and static allocation in the data
40 * segment would not permit concurrent dials within a multi-process program.
52 Conn *conn; /* allocated array */
57 int winner; /* index into conn[] */
60 char addrlist[Maxcsreply];
63 static int call(char*, char*, DS*, Dest*, Conn*);
64 static int csdial(DS*);
65 static void _dial_string_parse(char*, DS*);
69 * the dialstring is of the form '[/net/]proto!dest'
72 dialimpl(char *dest, char *local, char *dir, int *cfdp)
76 char err[ERRMAX], alterr[ERRMAX];
82 _dial_string_parse(dest, &ds);
91 errstr(err, sizeof err);
92 if(strstr(err, "refused") != 0){
96 ds.netdir = "/net.alt";
102 errstr(alterr, sizeof alterr);
103 if(strstr(alterr, "translate") || strstr(alterr, "does not exist"))
106 werrstr("%s", alterr);
111 * the thread library can't cope with rfork(RFMEM|RFPROC),
112 * so it must override this with a private version of dial.
114 int (*_dial)(char *, char *, char *, int *) = dialimpl;
117 dial(char *dest, char *local, char *dir, int *cfdp)
119 return (*_dial)(dest, local, dir, cfdp);
123 connsalloc(Dest *dp, int addrs)
129 dp->conn = mallocz(addrs * sizeof *dp->conn, 1);
132 dp->connend = dp->conn + addrs;
146 closeopenfd(int *fdp)
155 notedeath(Dest *dp, char *exitsts)
158 char *fields[5]; /* pid + 3 times + error */
161 for (i = 0; i < nelem(fields); i++)
163 n = tokenize(exitsts, fields, nelem(fields));
166 pid = atoi(fields[0]);
169 for (conn = dp->conn; conn < dp->connend; conn++)
170 if (conn->pid == pid && !conn->dead) { /* it's one we know? */
171 if (conn - dp->conn != dp->winner) {
172 closeopenfd(&conn->dfd);
173 closeopenfd(&conn->cfd);
175 strncpy(conn->err, fields[4], sizeof conn->err);
179 /* not a proc that we forked */
183 outstandingprocs(Dest *dp)
187 for (conn = dp->conn; conn < dp->connend; conn++)
196 char exitsts[2*ERRMAX];
198 if (outstandingprocs(dp) && await(exitsts, sizeof exitsts) >= 0) {
199 notedeath(dp, exitsts);
206 fillinds(DS *ds, Dest *dp)
212 conn = &dp->conn[dp->winner];
214 *ds->cfdp = conn->cfd;
216 strncpy(ds->dir, conn->dir, NETPATHLEN);
221 connectwait(Dest *dp, char *besterr)
225 /* wait for a winner or all attempts to time out */
226 while (dp->winner < 0 && reap(dp) >= 0)
229 /* kill all of our still-live kids & reap them */
230 for (conn = dp->conn; conn < dp->connend; conn++)
232 postnote(PNPROC, conn->pid, "die");
233 while (reap(dp) >= 0)
236 /* rummage about and report some error string */
237 for (conn = dp->conn; conn < dp->connend; conn++)
238 if (conn - dp->conn != dp->winner && conn->dead &&
240 strncpy(besterr, conn->err, ERRMAX);
247 parsecs(Dest *dp, char **clonep, char **destp)
251 dest = strchr(dp->nextaddr, ' ');
255 p = strchr(dest, '\n');
259 *clonep = dp->nextaddr;
261 dp->nextaddr = p; /* advance to next line */
266 pickuperr(char *besterr, char *err)
270 if(strstr(err, "does not exist") == 0)
271 strcpy(besterr, err);
275 * try all addresses in parallel and take the first one that answers;
276 * this helps when systems have ip v4 and v6 addresses but are
277 * only reachable from here on one (or some) of them.
280 dialmulti(DS *ds, Dest *dp)
284 char err[ERRMAX], besterr[ERRMAX];
288 while(dp->winner < 0 && *dp->nextaddr != '\0' &&
289 parsecs(dp, &clone, &dest) >= 0) {
290 kidme = dp->nkid++; /* make private copy on stack */
291 kid = rfork(RFPROC|RFMEM); /* spin off a call attempt */
297 rv = call(clone, dest, ds, dp, &dp->conn[kidme]);
299 pickuperr(besterr, err);
300 _exits(besterr); /* avoid atexit callbacks */
303 rv = connectwait(dp, besterr);
304 if(rv < 0 && *besterr)
305 werrstr("%s", besterr);
314 int n, fd, rv, addrs, bleft;
316 char *addrp, *clone2, *dest;
317 char buf[Maxstring], clone[Maxpath], err[ERRMAX], besterr[ERRMAX];
320 dp = mallocz(sizeof *dp, 1);
324 if (connsalloc(dp, 1) < 0) { /* room for a single conn. */
330 * open connection server
332 snprint(buf, sizeof(buf), "%s/cs", ds->netdir);
333 fd = open(buf, ORDWR);
335 /* no connection server, don't translate */
336 snprint(clone, sizeof(clone), "%s/%s/clone", ds->netdir, ds->proto);
337 rv = call(clone, ds->rem, ds, dp, &dp->conn[0]);
344 * ask connection server to translate
346 snprint(buf, sizeof(buf), "%s!%s", ds->proto, ds->rem);
347 if(write(fd, buf, strlen(buf)) < 0){
354 * read all addresses from the connection server.
358 addrp = dp->nextaddr = dp->addrlist;
359 bleft = sizeof dp->addrlist - 2; /* 2 is room for \n\0 */
360 while(bleft > 0 && (n = read(fd, addrp, bleft)) > 0) {
361 if (addrp[n-1] != '\n')
368 * if we haven't read all of cs's output, assume the last line might
369 * have been truncated and ignore it. we really don't expect this
372 if (addrs > 0 && bleft <= 0 && read(fd, &c, 1) == 1)
377 rv = -1; /* pessimistic default */
379 werrstr("no address to dial");
380 else if (addrs == 1) {
381 /* common case: dial one address without forking */
382 if (parsecs(dp, &clone2, &dest) >= 0 &&
383 (rv = call(clone2, dest, ds, dp, &dp->conn[0])) < 0) {
384 pickuperr(besterr, err);
385 werrstr("%s", besterr);
387 } else if (connsalloc(dp, addrs) >= 0)
388 rv = dialmulti(ds, dp);
390 /* fill in results */
391 if (rv >= 0 && dp->winner >= 0)
392 rv = fillinds(ds, dp);
399 call(char *clone, char *dest, DS *ds, Dest *dp, Conn *conn)
402 char cname[Maxpath], name[Maxpath], data[Maxpath], *p;
404 /* because cs is in a different name space, replace the mount point */
406 p = strchr(clone+1, '/');
413 snprint(cname, sizeof cname, "%s/%s", ds->netdir, p);
415 conn->pid = getpid();
416 conn->cfd = cfd = open(cname, ORDWR);
420 /* get directory name */
421 n = read(cfd, name, sizeof(name)-1);
423 closeopenfd(&conn->cfd);
427 for(p = name; *p == ' '; p++)
429 snprint(name, sizeof(name), "%ld", strtoul(p, 0, 0));
430 p = strrchr(cname, '/');
433 snprint(conn->dir, NETPATHLEN, "%s/%s", cname, name);
434 snprint(data, sizeof(data), "%s/%s/data", cname, name);
438 snprint(name, sizeof(name), "connect %s %s", dest, ds->local);
440 snprint(name, sizeof(name), "connect %s", dest);
441 if(write(cfd, name, strlen(name)) < 0){
442 closeopenfd(&conn->cfd);
446 /* open data connection */
447 conn->dfd = fd = open(data, ORDWR);
449 closeopenfd(&conn->cfd);
453 closeopenfd(&conn->cfd);
456 if (dp->winner < 0 && conn < dp->connend)
457 dp->winner = conn - dp->conn;
458 qunlock(&dp->winlck);
463 * parse a dial string
466 _dial_string_parse(char *str, DS *ds)
470 strncpy(ds->buf, str, Maxstring);
471 ds->buf[Maxstring-1] = 0;
473 p = strchr(ds->buf, '!');
479 if(*ds->buf != '/' && *ds->buf != '#'){
483 for(p2 = p; *p2 != '/'; p2--)
486 ds->netdir = ds->buf;