xref: /plan9/sys/src/cmd/ssh2/dial.c (revision 6c0e6fed62599342770755338f74d351b8dd2269)
1 /*
2  * dial - connect to a service (parallel version)
3  */
4 #include <u.h>
5 #include <libc.h>
6 #include <ctype.h>
7 
8 typedef struct Conn Conn;
9 typedef struct Dest Dest;
10 typedef struct DS DS;
11 
12 enum
13 {
14 	Maxstring	= 128,
15 	Maxpath		= 256,
16 
17 	Maxcsreply	= 64*80,	/* this is probably overly generous */
18 	/*
19 	 * this should be a plausible slight overestimate for non-interactive
20 	 * use even if it's ridiculously long for interactive use.
21 	 */
22 	Maxconnms	= 2*60*1000,	/* 2 minutes */
23 };
24 
25 struct DS {
26 	/* dist string */
27 	char	buf[Maxstring];
28 	char	*netdir;		/* e.g., /net.alt */
29 	char	*proto;			/* e.g., tcp */
30 	char	*rem;			/* e.g., host!service */
31 
32 	/* other args */
33 	char	*local;
34 	char	*dir;
35 	int	*cfdp;
36 };
37 
38 /*
39  * malloc these; they need to be writable by this proc & all children.
40  * the stack is private to each proc, and static allocation in the data
41  * segment would not permit concurrent dials within a multi-process program.
42  */
43 struct Conn {
44 	int	pid;
45 	int	dead;
46 
47 	int	dfd;
48 	int	cfd;
49 	char	dir[NETPATHLEN+1];
50 	char	err[ERRMAX];
51 };
52 struct Dest {
53 	Conn	*conn;			/* allocated array */
54 	Conn	*connend;
55 	int	nkid;
56 
57 	long	oalarm;
58 	int	naddrs;
59 
60 	QLock	winlck;
61 	int	winner;			/* index into conn[] */
62 
63 	char	*nextaddr;
64 	char	addrlist[Maxcsreply];
65 };
66 
67 static int	call(char*, char*, DS*, Dest*, Conn*);
68 static int	csdial(DS*);
69 static void	_dial_string_parse(char*, DS*);
70 
71 
72 /*
73  *  the dialstring is of the form '[/net/]proto!dest'
74  */
75 static int
dialimpl(char * dest,char * local,char * dir,int * cfdp)76 dialimpl(char *dest, char *local, char *dir, int *cfdp)
77 {
78 	DS ds;
79 	int rv;
80 	char err[ERRMAX], alterr[ERRMAX];
81 
82 	ds.local = local;
83 	ds.dir = dir;
84 	ds.cfdp = cfdp;
85 
86 	_dial_string_parse(dest, &ds);
87 	if(ds.netdir)
88 		return csdial(&ds);
89 
90 	ds.netdir = "/net";
91 	rv = csdial(&ds);
92 	if(rv >= 0)
93 		return rv;
94 	err[0] = '\0';
95 	errstr(err, sizeof err);
96 	if(strstr(err, "refused") != 0){
97 		werrstr("%s", err);
98 		return rv;
99 	}
100 	ds.netdir = "/net.alt";
101 	rv = csdial(&ds);
102 	if(rv >= 0)
103 		return rv;
104 
105 	alterr[0] = 0;
106 	errstr(alterr, sizeof alterr);
107 	if(strstr(alterr, "translate") || strstr(alterr, "does not exist"))
108 		werrstr("%s", err);
109 	else
110 		werrstr("%s", alterr);
111 	return rv;
112 }
113 
114 /*
115  * the thread library can't cope with rfork(RFMEM|RFPROC),
116  * so it must override this with a private version of dial.
117  */
118 int (*_dial)(char *, char *, char *, int *) = dialimpl;
119 
120 int
dial(char * dest,char * local,char * dir,int * cfdp)121 dial(char *dest, char *local, char *dir, int *cfdp)
122 {
123 	return (*_dial)(dest, local, dir, cfdp);
124 }
125 
126 static int
connsalloc(Dest * dp,int addrs)127 connsalloc(Dest *dp, int addrs)
128 {
129 	Conn *conn;
130 
131 	free(dp->conn);
132 	dp->connend = nil;
133 	assert(addrs > 0);
134 
135 	dp->conn = mallocz(addrs * sizeof *dp->conn, 1);
136 	if(dp->conn == nil)
137 		return -1;
138 	dp->connend = dp->conn + addrs;
139 	for(conn = dp->conn; conn < dp->connend; conn++)
140 		conn->cfd = conn->dfd = -1;
141 	return 0;
142 }
143 
144 static void
freedest(Dest * dp)145 freedest(Dest *dp)
146 {
147 	long oalarm;
148 
149 	if (dp == nil)
150 		return;
151 	oalarm = dp->oalarm;
152 	free(dp->conn);
153 	free(dp);
154 	if (oalarm >= 0)
155 		alarm(oalarm);
156 }
157 
158 static void
closeopenfd(int * fdp)159 closeopenfd(int *fdp)
160 {
161 	if (*fdp >= 0) {
162 		close(*fdp);
163 		*fdp = -1;
164 	}
165 }
166 
167 static void
notedeath(Dest * dp,char * exitsts)168 notedeath(Dest *dp, char *exitsts)
169 {
170 	int i, n, pid;
171 	char *fields[5];			/* pid + 3 times + error */
172 	Conn *conn;
173 
174 	for (i = 0; i < nelem(fields); i++)
175 		fields[i] = "";
176 	n = tokenize(exitsts, fields, nelem(fields));
177 	if (n < 4)
178 		return;
179 	pid = atoi(fields[0]);
180 	if (pid <= 0)
181 		return;
182 	for (conn = dp->conn; conn < dp->connend; conn++)
183 		if (conn->pid == pid && !conn->dead) {  /* it's one we know? */
184 			if (conn - dp->conn != dp->winner) {
185 				closeopenfd(&conn->dfd);
186 				closeopenfd(&conn->cfd);
187 			}
188 			strncpy(conn->err, fields[4], sizeof conn->err - 1);
189 			conn->err[sizeof conn->err - 1] = '\0';
190 			conn->dead = 1;
191 			return;
192 		}
193 	/* not a proc that we forked */
194 }
195 
196 static int
outstandingprocs(Dest * dp)197 outstandingprocs(Dest *dp)
198 {
199 	Conn *conn;
200 
201 	for (conn = dp->conn; conn < dp->connend; conn++)
202 		if (!conn->dead)
203 			return 1;
204 	return 0;
205 }
206 
207 static int
reap(Dest * dp)208 reap(Dest *dp)
209 {
210 	char exitsts[2*ERRMAX];
211 
212 	if (outstandingprocs(dp) && await(exitsts, sizeof exitsts) >= 0) {
213 		notedeath(dp, exitsts);
214 		return 0;
215 	}
216 	return -1;
217 }
218 
219 static int
fillinds(DS * ds,Dest * dp)220 fillinds(DS *ds, Dest *dp)
221 {
222 	Conn *conn;
223 
224 	if (dp->winner < 0)
225 		return -1;
226 	conn = &dp->conn[dp->winner];
227 	if (ds->cfdp)
228 		*ds->cfdp = conn->cfd;
229 	if (ds->dir) {
230 		strncpy(ds->dir, conn->dir, NETPATHLEN);
231 		ds->dir[NETPATHLEN-1] = '\0';
232 	}
233 	return conn->dfd;
234 }
235 
236 static int
connectwait(Dest * dp,char * besterr)237 connectwait(Dest *dp, char *besterr)
238 {
239 	Conn *conn;
240 
241 	/* wait for a winner or all attempts to time out */
242 	while (dp->winner < 0 && reap(dp) >= 0)
243 		;
244 
245 	/* kill all of our still-live kids & reap them */
246 	for (conn = dp->conn; conn < dp->connend; conn++)
247 		if (!conn->dead)
248 			postnote(PNPROC, conn->pid, "alarm");
249 	while (reap(dp) >= 0)
250 		;
251 
252 	/* rummage about and report some error string */
253 	for (conn = dp->conn; conn < dp->connend; conn++)
254 		if (conn - dp->conn != dp->winner && conn->dead &&
255 		    conn->err[0]) {
256 			strncpy(besterr, conn->err, ERRMAX-1);
257 			conn->err[ERRMAX-1] = '\0';
258 			break;
259 		}
260 	return dp->winner;
261 }
262 
263 static int
parsecs(Dest * dp,char ** clonep,char ** destp)264 parsecs(Dest *dp, char **clonep, char **destp)
265 {
266 	char *dest, *p;
267 
268 	dest = strchr(dp->nextaddr, ' ');
269 	if(dest == nil)
270 		return -1;
271 	*dest++ = '\0';
272 	p = strchr(dest, '\n');
273 	if(p == nil)
274 		return -1;
275 	*p++ = '\0';
276 	*clonep = dp->nextaddr;
277 	*destp = dest;
278 	dp->nextaddr = p;		/* advance to next line */
279 	return 0;
280 }
281 
282 static void
pickuperr(char * besterr,char * err)283 pickuperr(char *besterr, char *err)
284 {
285 	err[0] = '\0';
286 	errstr(err, ERRMAX);
287 	if(strstr(err, "does not exist") == 0)
288 		strcpy(besterr, err);
289 }
290 
291 static int
catcher(void *,char * s)292 catcher(void *, char *s)
293 {
294 	return strstr(s, "alarm") != nil;
295 }
296 
297 /*
298  * try all addresses in parallel and take the first one that answers;
299  * this helps when systems have ip v4 and v6 addresses but are
300  * only reachable from here on one (or some) of them.
301  */
302 static int
dialmulti(DS * ds,Dest * dp)303 dialmulti(DS *ds, Dest *dp)
304 {
305 	int rv, kid, kidme;
306 	char *clone, *dest;
307 	char err[ERRMAX], besterr[ERRMAX];
308 
309 	dp->winner = -1;
310 	dp->nkid = 0;
311 	while(dp->winner < 0 && *dp->nextaddr != '\0' &&
312 	    parsecs(dp, &clone, &dest) >= 0) {
313 		kidme = dp->nkid++;		/* make private copy on stack */
314 		kid = rfork(RFPROC|RFMEM);	/* spin off a call attempt */
315 		if (kid < 0)
316 			--dp->nkid;
317 		else if (kid == 0) {
318 			/* only in kid, to avoid atnotify callbacks in parent */
319 			atnotify(catcher, 1);
320 
321 			*besterr = '\0';
322 			rv = call(clone, dest, ds, dp, &dp->conn[kidme]);
323 			if(rv < 0)
324 				pickuperr(besterr, err);
325 			_exits(besterr);	/* avoid atexit callbacks */
326 		}
327 	}
328 	rv = connectwait(dp, besterr);
329 	if(rv < 0 && *besterr)
330 		werrstr("%s", besterr);
331 	else
332 		werrstr("%s", err);
333 	return rv;
334 }
335 
336 static int
csdial(DS * ds)337 csdial(DS *ds)
338 {
339 	int n, fd, rv, addrs, bleft;
340 	char c;
341 	char *addrp, *clone2, *dest;
342 	char buf[Maxstring], clone[Maxpath], err[ERRMAX], besterr[ERRMAX];
343 	Dest *dp;
344 
345 	dp = mallocz(sizeof *dp, 1);
346 	if(dp == nil)
347 		return -1;
348 	dp->winner = -1;
349 	dp->oalarm = alarm(0);
350 	if (connsalloc(dp, 1) < 0) {		/* room for a single conn. */
351 		freedest(dp);
352 		return -1;
353 	}
354 
355 	/*
356 	 *  open connection server
357 	 */
358 	snprint(buf, sizeof(buf), "%s/cs", ds->netdir);
359 	fd = open(buf, ORDWR);
360 	if(fd < 0){
361 		/* no connection server, don't translate */
362 		snprint(clone, sizeof(clone), "%s/%s/clone", ds->netdir, ds->proto);
363 		rv = call(clone, ds->rem, ds, dp, &dp->conn[0]);
364 		fillinds(ds, dp);
365 		freedest(dp);
366 		return rv;
367 	}
368 
369 	/*
370 	 *  ask connection server to translate
371 	 */
372 	snprint(buf, sizeof(buf), "%s!%s", ds->proto, ds->rem);
373 	if(write(fd, buf, strlen(buf)) < 0){
374 		close(fd);
375 		freedest(dp);
376 		return -1;
377 	}
378 
379 	/*
380 	 *  read all addresses from the connection server.
381 	 */
382 	seek(fd, 0, 0);
383 	addrs = 0;
384 	addrp = dp->nextaddr = dp->addrlist;
385 	bleft = sizeof dp->addrlist - 2;	/* 2 is room for \n\0 */
386 	while(bleft > 0 && (n = read(fd, addrp, bleft)) > 0) {
387 		if (addrp[n-1] != '\n')
388 			addrp[n++] = '\n';
389 		addrs++;
390 		addrp += n;
391 		bleft -= n;
392 	}
393 	/*
394 	 * if we haven't read all of cs's output, assume the last line might
395 	 * have been truncated and ignore it.  we really don't expect this
396 	 * to happen.
397 	 */
398 	if (addrs > 0 && bleft <= 0 && read(fd, &c, 1) == 1)
399 		addrs--;
400 	close(fd);
401 
402 	*besterr = 0;
403 	rv = -1;				/* pessimistic default */
404 	dp->naddrs = addrs;
405 	if (addrs == 0)
406 		werrstr("no address to dial");
407 	else if (addrs == 1) {
408 		/* common case: dial one address without forking */
409 		if (parsecs(dp, &clone2, &dest) >= 0 &&
410 		    (rv = call(clone2, dest, ds, dp, &dp->conn[0])) < 0) {
411 			pickuperr(besterr, err);
412 			werrstr("%s", besterr);
413 		}
414 	} else if (connsalloc(dp, addrs) >= 0)
415 		rv = dialmulti(ds, dp);
416 
417 	/* fill in results */
418 	if (rv >= 0 && dp->winner >= 0)
419 		rv = fillinds(ds, dp);
420 
421 	freedest(dp);
422 	return rv;
423 }
424 
425 static int
call(char * clone,char * dest,DS * ds,Dest * dp,Conn * conn)426 call(char *clone, char *dest, DS *ds, Dest *dp, Conn *conn)
427 {
428 	int fd, cfd, n, calleralarm, oalarm;
429 	char cname[Maxpath], name[Maxpath], data[Maxpath], *p;
430 
431 	/* because cs is in a different name space, replace the mount point */
432 	if(*clone == '/'){
433 		p = strchr(clone+1, '/');
434 		if(p == nil)
435 			p = clone;
436 		else
437 			p++;
438 	} else
439 		p = clone;
440 	snprint(cname, sizeof cname, "%s/%s", ds->netdir, p);
441 
442 	conn->pid = getpid();
443 	conn->cfd = cfd = open(cname, ORDWR);
444 	if(cfd < 0)
445 		return -1;
446 
447 	/* get directory name */
448 	n = read(cfd, name, sizeof(name)-1);
449 	if(n < 0){
450 		closeopenfd(&conn->cfd);
451 		return -1;
452 	}
453 	name[n] = 0;
454 	for(p = name; *p == ' '; p++)
455 		;
456 	snprint(name, sizeof(name), "%ld", strtoul(p, 0, 0));
457 	p = strrchr(cname, '/');
458 	*p = 0;
459 	if(ds->dir)
460 		snprint(conn->dir, NETPATHLEN, "%s/%s", cname, name);
461 	snprint(data, sizeof(data), "%s/%s/data", cname, name);
462 
463 	/* should be no alarm pending now; re-instate caller's alarm, if any */
464 	calleralarm = dp->oalarm > 0;
465 	if (calleralarm)
466 		alarm(dp->oalarm);
467 	else if (dp->naddrs > 1)	/* in a sub-process? */
468 		alarm(Maxconnms);
469 
470 	/* connect */
471 	if(ds->local)
472 		snprint(name, sizeof(name), "connect %s %s", dest, ds->local);
473 	else
474 		snprint(name, sizeof(name), "connect %s", dest);
475 	if(write(cfd, name, strlen(name)) < 0){
476 		closeopenfd(&conn->cfd);
477 		return -1;
478 	}
479 
480 	oalarm = alarm(0);	/* don't let alarm interrupt critical section */
481 	if (calleralarm)
482 		dp->oalarm = oalarm;	/* time has passed, so update user's */
483 
484 	/* open data connection */
485 	conn->dfd = fd = open(data, ORDWR);
486 	if(fd < 0){
487 		closeopenfd(&conn->cfd);
488 		alarm(dp->oalarm);
489 		return -1;
490 	}
491 	if(ds->cfdp == nil)
492 		closeopenfd(&conn->cfd);
493 
494 	n = conn - dp->conn;
495 	if (dp->winner < 0) {
496 		qlock(&dp->winlck);
497 		if (dp->winner < 0 && conn < dp->connend)
498 			dp->winner = n;
499 		qunlock(&dp->winlck);
500 	}
501 	alarm(calleralarm? dp->oalarm: 0);
502 	return fd;
503 }
504 
505 /*
506  * assume p points at first '!' in dial string.  st is start of dial string.
507  * there could be subdirs of the conn dirs (e.g., ssh/0) that must count as
508  * part of the proto string, so skip numeric components.
509  * returns pointer to delimiter after right-most non-numeric component.
510  */
511 static char *
backoverchans(char * st,char * p)512 backoverchans(char *st, char *p)
513 {
514 	char *sl;
515 
516 	for (sl = p; --p >= st && isascii(*p) && isdigit(*p); sl = p) {
517 		while (--p >= st && isascii(*p) && isdigit(*p))
518 			;
519 		if (p < st || *p != '/')
520 			break;			/* "net.alt2" or ran off start */
521 		while (p > st && p[-1] == '/')	/* skip runs of slashes */
522 			p--;
523 	}
524 	return sl;
525 }
526 
527 /*
528  *  parse a dial string
529  */
530 static void
_dial_string_parse(char * str,DS * ds)531 _dial_string_parse(char *str, DS *ds)
532 {
533 	char *p, *p2;
534 
535 	strncpy(ds->buf, str, Maxstring);
536 	ds->buf[Maxstring-1] = 0;
537 
538 	p = strchr(ds->buf, '!');
539 	if(p == 0) {
540 		ds->netdir = 0;
541 		ds->proto = "net";
542 		ds->rem = ds->buf;
543 	} else {
544 		if(*ds->buf != '/' && *ds->buf != '#'){
545 			ds->netdir = 0;
546 			ds->proto = ds->buf;
547 		} else {
548 			p2 = backoverchans(ds->buf, p);
549 
550 			/* back over last component of netdir (proto) */
551 			while (--p2 > ds->buf && *p2 != '/')
552 				;
553 			*p2++ = 0;
554 			ds->netdir = ds->buf;
555 			ds->proto = p2;
556 		}
557 		*p = 0;
558 		ds->rem = p + 1;
559 	}
560 }
561