f227f657485a812d2f1b1ea1098129ac7123a2a5
[dragonfly.git] / usr.sbin / puffs / mount_psshfs / psshfs.c
1 /*      $NetBSD: psshfs.c,v 1.63 2011/05/19 15:07:16 riastradh Exp $    */
2
3 /*
4  * Copyright (c) 2006-2009  Antti Kantee.  All Rights Reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
16  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
17  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
18  * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
21  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25  * SUCH DAMAGE.
26  */
27
28 /*
29  * psshfs: puffs sshfs
30  *
31  * psshfs implements sshfs functionality on top of puffs making it
32  * possible to mount a filesystme through the sftp service.
33  *
34  * psshfs can execute multiple operations in "parallel" by using the
35  * puffs_cc framework for continuations.
36  *
37  * Concurrency control is handled currently by vnode locking (this
38  * will change in the future).  Context switch locations are easy to
39  * find by grepping for puffs_framebuf_enqueue_cc().
40  */
41
42 #include <sys/types.h>
43 #include <sys/wait.h>
44 #include <sys/ioctl.h>
45 #include <sys/socket.h>
46 #include <sys/uio.h>
47
48 #include <assert.h>
49 #include <err.h>
50 #include <errno.h>
51 #include <paths.h>
52 #include <poll.h>
53 #include <puffs.h>
54 #include <signal.h>
55 #include <stdlib.h>
56 #include <stdio.h>
57 #include <unistd.h>
58
59 #include "psshfs.h"
60 #include "util_compat.h"
61
62 static int      pssh_connect(struct puffs_usermount *, int);
63 static void     psshfs_loopfn(struct puffs_usermount *);
64 static void     usage(void);
65 static void     add_ssharg(char ***, int *, const char *);
66 static void     psshfs_notify(struct puffs_usermount *, int, int);
67
68 #define SSH_PATH "/usr/bin/ssh"
69
70 unsigned int max_reads;
71 static int sighup;
72
73 static void
74 add_ssharg(char ***sshargs, int *nargs, const char *arg)
75 {
76
77         *sshargs = realloc(*sshargs, (*nargs + 2) * sizeof(char*));
78         if (!*sshargs)
79                 err(1, "realloc");
80         (*sshargs)[(*nargs)++] = estrdup(arg);
81         (*sshargs)[*nargs] = NULL;
82 }
83
84 static void
85 usage()
86 {
87
88         fprintf(stderr, "usage: %s "
89             "[-ceprst] [-F configfile] [-O sshopt=value] [-o opts] "
90             "user@host:path mountpath\n",
91             getprogname());
92         exit(1);
93 }
94
95 static void
96 takehup(int sig)
97 {
98
99         sighup = 1;
100 }
101
102 int
103 main(int argc, char *argv[])
104 {
105         struct psshfs_ctx pctx;
106         struct puffs_usermount *pu;
107         struct puffs_ops *pops;
108         struct psshfs_node *root = &pctx.psn_root;
109         struct puffs_node *pn_root;
110         puffs_framev_fdnotify_fn notfn;
111         struct vattr *rva;
112         char **sshargs;
113         char *userhost;
114         char *hostpath;
115         int mntflags, pflags, ch;
116         int detach;
117         int exportfs, refreshival, numconnections;
118         int nargs;
119
120         setprogname(argv[0]);
121         puffs_unmountonsignal(SIGINT, true);
122         puffs_unmountonsignal(SIGTERM, true);
123
124         if (argc < 3)
125                 usage();
126
127         memset(&pctx, 0, sizeof(pctx));
128         mntflags = pflags = exportfs = nargs = 0;
129         numconnections = 1;
130         detach = 1;
131         refreshival = DEFAULTREFRESH;
132         notfn = puffs_framev_unmountonclose;
133         sshargs = NULL;
134         add_ssharg(&sshargs, &nargs, SSH_PATH);
135         add_ssharg(&sshargs, &nargs, "-axs");
136         add_ssharg(&sshargs, &nargs, "-oClearAllForwardings=yes");
137
138         while ((ch = getopt(argc, argv, "c:eF:g:o:O:pr:st:u:")) != -1) {
139                 switch (ch) {
140                 case 'c':
141                         numconnections = atoi(optarg);
142                         if (numconnections < 1 || numconnections > 2) {
143                                 fprintf(stderr, "%s: only 1 or 2 connections "
144                                     "permitted currently\n", getprogname());
145                                 usage();
146                                 /*NOTREACHED*/
147                         }
148                         break;
149                 case 'e':
150                         exportfs = 1;
151                         break;
152                 case 'F':
153                         add_ssharg(&sshargs, &nargs, "-F");
154                         add_ssharg(&sshargs, &nargs, optarg);
155                         break;
156                 case 'g':
157                         pctx.domanglegid = 1;
158                         pctx.manglegid = atoi(optarg);
159                         if (pctx.manglegid == (gid_t)-1)
160                                 errx(1, "-1 not allowed for -g");
161                         pctx.mygid = getegid();
162                         break;
163                 case 'O':
164                         add_ssharg(&sshargs, &nargs, "-o");
165                         add_ssharg(&sshargs, &nargs, optarg);
166                         break;
167                 case 'o':
168                         getmntopts(optarg, puffsmopts, &mntflags, &pflags);
169                         break;
170                 case 'p':
171                         notfn = psshfs_notify;
172                         break;
173                 case 'r':
174                         max_reads = atoi(optarg);
175                         break;
176                 case 's':
177                         detach = 0;
178                         break;
179                 case 't':
180                         refreshival = atoi(optarg);
181                         if (refreshival < 0 && refreshival != -1)
182                                 errx(1, "invalid timeout %d", refreshival);
183                         break;
184                 case 'u':
185                         pctx.domangleuid = 1;
186                         pctx.mangleuid = atoi(optarg);
187                         if (pctx.mangleuid == (uid_t)-1)
188                                 errx(1, "-1 not allowed for -u");
189                         pctx.myuid = geteuid();
190                         break;
191                 default:
192                         usage();
193                         /*NOTREACHED*/
194                 }
195         }
196         argc -= optind;
197         argv += optind;
198
199         if (pflags & PUFFS_FLAG_OPDUMP)
200                 detach = 0;
201         pflags |= PUFFS_FLAG_BUILDPATH;
202         pflags |= PUFFS_KFLAG_WTCACHE | PUFFS_KFLAG_IAONDEMAND;
203
204         if (argc != 2)
205                 usage();
206
207         PUFFSOP_INIT(pops);
208
209         PUFFSOP_SET(pops, psshfs, fs, unmount);
210         PUFFSOP_SETFSNOP(pops, sync); /* XXX */
211         PUFFSOP_SET(pops, psshfs, fs, statvfs);
212         PUFFSOP_SET(pops, psshfs, fs, nodetofh);
213         PUFFSOP_SET(pops, psshfs, fs, fhtonode);
214
215         PUFFSOP_SET(pops, psshfs, node, lookup);
216         PUFFSOP_SET(pops, psshfs, node, create);
217         PUFFSOP_SET(pops, psshfs, node, open);
218         PUFFSOP_SET(pops, psshfs, node, inactive);
219         PUFFSOP_SET(pops, psshfs, node, readdir);
220         PUFFSOP_SET(pops, psshfs, node, getattr);
221         PUFFSOP_SET(pops, psshfs, node, setattr);
222         PUFFSOP_SET(pops, psshfs, node, mkdir);
223         PUFFSOP_SET(pops, psshfs, node, remove);
224         PUFFSOP_SET(pops, psshfs, node, readlink);
225         PUFFSOP_SET(pops, psshfs, node, rmdir);
226         PUFFSOP_SET(pops, psshfs, node, link);
227         PUFFSOP_SET(pops, psshfs, node, symlink);
228         PUFFSOP_SET(pops, psshfs, node, rename);
229         PUFFSOP_SET(pops, psshfs, node, read);
230         PUFFSOP_SET(pops, psshfs, node, write);
231         PUFFSOP_SET(pops, psshfs, node, reclaim);
232
233         pu = puffs_init(pops, argv[0], "psshfs", &pctx, pflags);
234         if (pu == NULL)
235                 err(1, "puffs_init");
236
237         pctx.mounttime = time(NULL);
238         pctx.refreshival = refreshival;
239         pctx.numconnections = numconnections;
240
241         userhost = argv[0];
242         hostpath = strchr(userhost, ':');
243         if (hostpath) {
244                 *hostpath++ = '\0';
245                 pctx.mountpath = hostpath;
246         } else
247                 pctx.mountpath = ".";
248
249         add_ssharg(&sshargs, &nargs, argv[0]);
250         add_ssharg(&sshargs, &nargs, "sftp");
251         pctx.sshargs = sshargs;
252
253         pctx.nextino = 2;
254         memset(root, 0, sizeof(struct psshfs_node));
255         TAILQ_INIT(&root->pw);
256         pn_root = puffs_pn_new(pu, root);
257         if (pn_root == NULL)
258                 return errno;
259         puffs_setroot(pu, pn_root);
260
261         puffs_framev_init(pu, psbuf_read, psbuf_write, psbuf_cmp, NULL, notfn);
262
263         signal(SIGHUP, takehup);
264         puffs_ml_setloopfn(pu, psshfs_loopfn);
265         if (pssh_connect(pu, PSSHFD_META) == -1)
266                 err(1, "can't connect meta");
267         if (puffs_framev_addfd(pu, pctx.sshfd,
268             PUFFS_FBIO_READ | PUFFS_FBIO_WRITE) == -1)
269                 err(1, "framebuf addfd meta");
270         if (numconnections == 2) {
271                 if (pssh_connect(pu, PSSHFD_DATA) == -1)
272                         err(1, "can't connect data");
273                 if (puffs_framev_addfd(pu, pctx.sshfd_data,
274                     PUFFS_FBIO_READ | PUFFS_FBIO_WRITE) == -1)
275                         err(1, "framebuf addfd data");
276         } else {
277                 pctx.sshfd_data = pctx.sshfd;
278         }
279
280         if (exportfs)
281                 puffs_setfhsize(pu, sizeof(struct psshfs_fid),
282                     PUFFS_FHFLAG_NFSV2 | PUFFS_FHFLAG_NFSV3);
283
284         rva = &pn_root->pn_va;
285         rva->va_fileid = pctx.nextino++;
286
287         /*
288          * For root link count, just guess something ridiculously high.
289          * Guessing too high has no known adverse effects, but fts(3)
290          * doesn't like too low values.  This guess will be replaced
291          * with the real value when readdir is first called for
292          * the root directory.
293          */
294         rva->va_nlink = 8811;
295
296         if (detach)
297                 if (puffs_daemon(pu, 1, 1) == -1)
298                         err(1, "puffs_daemon");
299
300         if (puffs_mount(pu, argv[1], mntflags, puffs_getroot(pu)) == -1)
301                 err(1, "puffs_mount");
302         if (puffs_setblockingmode(pu, PUFFSDEV_NONBLOCK) == -1)
303                 err(1, "setblockingmode");
304
305         if (puffs_mainloop(pu) == -1)
306                 err(1, "mainloop");
307         puffs_exit(pu, 1);
308
309         return 0;
310 }
311
312 #define RETRY_MAX 100
313
314 void
315 psshfs_notify(struct puffs_usermount *pu, int fd, int what)
316 {
317         struct psshfs_ctx *pctx = puffs_getspecific(pu);
318         int nretry, which, newfd, dummy;
319
320         if (fd == pctx->sshfd) {
321                 which = PSSHFD_META;
322         } else {
323                 assert(fd == pctx->sshfd_data);
324                 which = PSSHFD_DATA;
325         }
326
327         if (puffs_getstate(pu) != PUFFS_STATE_RUNNING)
328                 return;
329
330         if (what != (PUFFS_FBIO_READ | PUFFS_FBIO_WRITE)) {
331                 puffs_framev_removefd(pu, fd, ECONNRESET);
332                 return;
333         }
334         close(fd);
335
336         /* deal with zmobies, beware of half-eaten brain */
337         while (waitpid(-1, &dummy, WNOHANG) > 0)
338                 continue;
339
340         for (nretry = 0;;nretry++) {
341                 if ((newfd = pssh_connect(pu, which)) == -1)
342                         goto retry2;
343
344                 if (puffs_framev_addfd(pu, newfd,
345                     PUFFS_FBIO_READ | PUFFS_FBIO_WRITE) == -1)
346                         goto retry1;
347
348                 break;
349  retry1:
350                 fprintf(stderr, "reconnect failed... ");
351                 close(newfd);
352  retry2:
353                 if (nretry < RETRY_MAX) {
354                         fprintf(stderr, "retry (%d left)\n", RETRY_MAX-nretry);
355                         sleep(nretry);
356                 } else {
357                         fprintf(stderr, "retry count exceeded, going south\n");
358                         exit(1); /* XXXXXXX */
359                 }
360         }
361 }
362
363 static int
364 pssh_connect(struct puffs_usermount *pu, int which)
365 {
366         struct psshfs_ctx *pctx = puffs_getspecific(pu);
367         char * const *sshargs = pctx->sshargs;
368         int fds[2];
369         pid_t pid;
370         int dnfd, x;
371         int *sshfd;
372         pid_t *sshpid;
373
374         if (which == PSSHFD_META) {
375                 sshfd = &pctx->sshfd;
376                 sshpid = &pctx->sshpid;
377         } else {
378                 assert(which == PSSHFD_DATA);
379                 sshfd = &pctx->sshfd_data;
380                 sshpid = &pctx->sshpid_data;
381         }
382
383         if (socketpair(AF_UNIX, SOCK_STREAM, 0, fds) == -1)
384                 return -1;
385
386         pid = fork();
387         switch (pid) {
388         case -1:
389                 return -1;
390                 /*NOTREACHED*/
391         case 0: /* child */
392                 if (dup2(fds[0], STDIN_FILENO) == -1)
393                         err(1, "child dup2");
394                 if (dup2(fds[0], STDOUT_FILENO) == -1)
395                         err(1, "child dup2");
396                 close(fds[0]);
397                 close(fds[1]);
398
399                 dnfd = open(_PATH_DEVNULL, O_RDWR);
400                 if (dnfd != -1)
401                         dup2(dnfd, STDERR_FILENO);
402
403                 execvp(sshargs[0], sshargs);
404                 /*NOTREACHED*/
405                 break;
406         default:
407                 *sshpid = pid;
408                 *sshfd = fds[1];
409                 close(fds[0]);
410                 break;
411         }
412
413         if (psshfs_handshake(pu, *sshfd) != 0)
414                 errx(1, "handshake failed, server does not support sftp?");
415         x = 1;
416         if (ioctl(*sshfd, FIONBIO, &x) == -1)
417                 err(1, "nonblocking descriptor %d", which);
418
419         return *sshfd;
420 }
421
422 static void *
423 invalone(struct puffs_usermount *pu, struct puffs_node *pn, void *arg)
424 {
425         struct psshfs_node *psn = pn->pn_data;
426
427         psn->attrread = 0;
428         psn->dentread = 0;
429         psn->slread = 0;
430
431         return NULL;
432 }
433
434 static void
435 psshfs_loopfn(struct puffs_usermount *pu)
436 {
437
438         if (sighup) {
439                 puffs_pn_nodewalk(pu, invalone, NULL);
440                 sighup = 0;
441         }
442 }