![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to umount.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sbin / umount|
Return to umount.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sbin / umount |
1.1 root 1: /*-
2: * Copyright (c) 1980, 1989 The Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms are permitted
6: * provided that: (1) source distributions retain this entire copyright
7: * notice and comment, and (2) distributions including binaries display
8: * the following acknowledgement: ``This product includes software
9: * developed by the University of California, Berkeley and its contributors''
10: * in the documentation or other materials provided with the distribution
11: * and in all advertising materials mentioning features or use of this
12: * software. Neither the name of the University nor the names of its
13: * contributors may be used to endorse or promote products derived
14: * from this software without specific prior written permission.
15: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
16: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
17: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
18: */
19:
20: #ifndef lint
21: char copyright[] =
22: "@(#) Copyright (c) 1980, 1989 The Regents of the University of California.\n\
23: All rights reserved.\n";
24: #endif /* not lint */
25:
26: #ifndef lint
27: static char sccsid[] = "@(#)umount.c 5.14 (Berkeley) 6/1/90";
28: #endif /* not lint */
29:
30: #include <sys/param.h>
31: #include <sys/stat.h>
32: #include <sys/mount.h>
33:
34: #ifdef NFS
35: #include <sys/time.h>
36: #include <sys/socket.h>
37: #include <sys/socketvar.h>
38: #include <netdb.h>
39: #include <rpc/rpc.h>
40: #include <rpc/pmap_clnt.h>
41: #include <rpc/pmap_prot.h>
42: #include <nfs/rpcv2.h>
43: #endif
44:
45: #include <fstab.h>
46: #include <stdio.h>
47: #include <string.h>
48:
49: #ifdef NFS
50: int xdr_dir();
51: char *nfshost;
52: #endif
53:
54: int vflag, all, errs, fake;
55: int fflag = MNT_NOFORCE;
56: char *getmntname();
57:
58: #define MNTON 1
59: #define MNTFROM 2
60: #define MNTTYPE 3
61:
62: int *typelist, *maketypelist();
63:
64: main(argc, argv)
65: int argc;
66: char **argv;
67: {
68: extern char *optarg;
69: extern int optind;
70: int ch;
71:
72: sync();
73: while ((ch = getopt(argc, argv, "afFh:t:v")) != EOF)
74: switch((char)ch) {
75: case 'v':
76: vflag++;
77: break;
78: case 'f':
79: fflag = MNT_FORCE;
80: break;
81: case 'F':
82: fake++;
83: break;
84: case 'a':
85: all++;
86: break;
87: case 't':
88: typelist = maketypelist(optarg);
89: break;
90: #ifdef NFS
91: case 'h':
92: /* -h flag implies -a, and "-t nfs" if no -t flag */
93: nfshost = optarg;
94: all++;
95: if (typelist == NULL)
96: typelist = maketypelist("nfs");
97: break;
98: #endif /* NFS */
99: case '?':
100: default:
101: usage();
102: /* NOTREACHED */
103: }
104: argc -= optind;
105: argv += optind;
106:
107: if (argc == 0 && !all)
108: usage();
109: if (all) {
110: if (argc > 0)
111: usage();
112: if (setfsent() == 0)
113: perror(FSTAB), exit(1);
114: umountall(typelist);
115: exit(0);
116: } else
117: setfsent();
118: while (argc > 0) {
119: if (umountfs(*argv++, 0) == 0)
120: errs++;
121: argc--;
122: }
123: exit(errs);
124: }
125:
126: usage()
127: {
128: fprintf(stderr,
129: "%s\n%s\n",
130: "Usage: umount [-fv] special | node",
131: #ifndef NFS
132: " or umount -a[fv] [-t fstypelist]"
133: #else
134: " or umount -a[fv] [-h host] [-t fstypelist]"
135: #endif
136: );
137: exit(1);
138: }
139:
140: umountall(typelist)
141: char **typelist;
142: {
143: register struct fstab *fs;
144: struct fstab *allocfsent();
145:
146: if ((fs = getfsent()) == (struct fstab *)0)
147: return;
148: fs = allocfsent(fs);
149: umountall(typelist);
150: if (strcmp(fs->fs_file, "/") == 0) {
151: freefsent(fs);
152: return;
153: }
154: if (strcmp(fs->fs_type, FSTAB_RW) &&
155: strcmp(fs->fs_type, FSTAB_RO) &&
156: strcmp(fs->fs_type, FSTAB_RQ)) {
157: freefsent(fs);
158: return;
159: }
160: (void) umountfs(fs->fs_file, typelist);
161: freefsent(fs);
162: }
163:
164: struct fstab *
165: allocfsent(fs)
166: register struct fstab *fs;
167: {
168: register struct fstab *new;
169: register char *cp;
170: char *malloc();
171:
172: new = (struct fstab *)malloc((unsigned)sizeof (*fs));
173: cp = malloc((unsigned)strlen(fs->fs_file) + 1);
174: strcpy(cp, fs->fs_file);
175: new->fs_file = cp;
176: cp = malloc((unsigned)strlen(fs->fs_type) + 1);
177: strcpy(cp, fs->fs_type);
178: new->fs_type = cp;
179: cp = malloc((unsigned)strlen(fs->fs_spec) + 1);
180: strcpy(cp, fs->fs_spec);
181: new->fs_spec = cp;
182: new->fs_passno = fs->fs_passno;
183: new->fs_freq = fs->fs_freq;
184: return (new);
185: }
186:
187: freefsent(fs)
188: register struct fstab *fs;
189: {
190:
191: if (fs->fs_file)
192: free(fs->fs_file);
193: if (fs->fs_spec)
194: free(fs->fs_spec);
195: if (fs->fs_type)
196: free(fs->fs_type);
197: free((char *)fs);
198: }
199:
200: umountfs(name, typelist)
201: char *name;
202: int *typelist;
203: {
204: char *mntpt;
205: struct stat stbuf;
206: int type;
207: #ifdef NFS
208: register CLIENT *clp;
209: struct hostent *hp = 0;
210: struct sockaddr_in saddr;
211: struct timeval pertry, try;
212: enum clnt_stat clnt_stat;
213: int so = RPC_ANYSOCK;
214: char *hostp, *delimp;
215: #endif /* NFS */
216:
217: if (stat(name, &stbuf) < 0) {
218: if ((mntpt = getmntname(name, MNTON, &type)) == 0)
219: return (0);
220: } else if ((stbuf.st_mode & S_IFMT) == S_IFBLK) {
221: if ((mntpt = getmntname(name, MNTON, &type)) == 0)
222: return (0);
223: } else if ((stbuf.st_mode & S_IFMT) == S_IFDIR) {
224: mntpt = name;
225: if ((name = getmntname(mntpt, MNTFROM, &type)) == 0)
226: return (0);
227: } else {
228: fprintf(stderr, "%s: not a directory or special device\n",
229: name);
230: return (0);
231: }
232:
233: if (badtype(type, typelist))
234: return(1);
235: #ifdef NFS
236: if ((delimp = index(name, '@')) != NULL) {
237: hostp = delimp + 1;
238: *delimp = '\0';
239: hp = gethostbyname(hostp);
240: *delimp = '@';
241: } else if ((delimp = index(name, ':')) != NULL) {
242: *delimp = '\0';
243: hostp = name;
244: hp = gethostbyname(hostp);
245: name = delimp+1;
246: *delimp = ':';
247: }
248:
249: if (!namematch(hp, nfshost))
250: return(1);
251: #endif /* NFS */
252: if (!fake && unmount(mntpt, fflag) < 0) {
253: perror(mntpt);
254: return (0);
255: }
256: if (vflag)
257: fprintf(stderr, "%s: Unmounted from %s\n", name, mntpt);
258:
259: #ifdef NFS
260: if (!fake && hp != NULL && (fflag & MNT_FORCE) == 0) {
261: *delimp = '\0';
262: bcopy(hp->h_addr,(caddr_t)&saddr.sin_addr,hp->h_length);
263: saddr.sin_family = AF_INET;
264: saddr.sin_port = 0;
265: pertry.tv_sec = 3;
266: pertry.tv_usec = 0;
267: if ((clp = clntudp_create(&saddr, RPCPROG_MNT, RPCMNT_VER1,
268: pertry, &so)) == NULL) {
269: clnt_pcreateerror("Cannot MNT PRC");
270: return (1);
271: }
272: clp->cl_auth = authunix_create_default();
273: try.tv_sec = 20;
274: try.tv_usec = 0;
275: clnt_stat = clnt_call(clp, RPCMNT_UMOUNT, xdr_dir, name,
276: xdr_void, (caddr_t)0, try);
277: if (clnt_stat != RPC_SUCCESS) {
278: clnt_perror(clp, "Bad MNT RPC");
279: return (1);
280: }
281: auth_destroy(clp->cl_auth);
282: clnt_destroy(clp);
283: }
284: #endif /* NFS */
285: return (1);
286: }
287:
288: char *
289: getmntname(name, what, type)
290: char *name;
291: int what;
292: int *type;
293: {
294: int mntsize, i;
295: struct statfs *mntbuf;
296:
297: if ((mntsize = getmntinfo(&mntbuf, MNT_NOWAIT)) == 0) {
298: perror("umount");
299: return (0);
300: }
301: for (i = 0; i < mntsize; i++) {
302: if (what == MNTON && !strcmp(mntbuf[i].f_mntfromname, name)) {
303: if (type)
304: *type = mntbuf[i].f_type;
305: return (mntbuf[i].f_mntonname);
306: }
307: if (what == MNTFROM && !strcmp(mntbuf[i].f_mntonname, name)) {
308: if (type)
309: *type = mntbuf[i].f_type;
310: return (mntbuf[i].f_mntfromname);
311: }
312: }
313: fprintf(stderr, "%s: not currently mounted\n", name);
314: return (0);
315: }
316:
317: static int skipvfs;
318:
319: badtype(type, typelist)
320: int type;
321: int *typelist;
322: {
323: if (typelist == 0)
324: return(0);
325: while (*typelist) {
326: if (type == *typelist)
327: return(skipvfs);
328: typelist++;
329: }
330: return(!skipvfs);
331: }
332:
333: int *
334: maketypelist(fslist)
335: char *fslist;
336: {
337: register char *nextcp;
338: register int *av, i;
339: char *malloc();
340:
341: if (fslist == NULL)
342: return(NULL);
343: if (fslist[0] == 'n' && fslist[1] == 'o') {
344: fslist += 2;
345: skipvfs = 1;
346: } else
347: skipvfs = 0;
348: for (i = 0, nextcp = fslist; *nextcp; nextcp++)
349: if (*nextcp == ',')
350: i++;
351: av = (int *)malloc((i+2) * sizeof(int));
352: if (av == NULL)
353: return(NULL);
354: for (i = 0; fslist; fslist = nextcp) {
355: if (nextcp = index(fslist, ','))
356: *nextcp++ = '\0';
357: if (strcmp(fslist, "ufs") == 0)
358: av[i++] = MOUNT_UFS;
359: else if (strcmp(fslist, "nfs") == 0)
360: av[i++] = MOUNT_NFS;
361: else if (strcmp(fslist, "mfs") == 0)
362: av[i++] = MOUNT_MFS;
363: else if (strcmp(fslist, "pc") == 0)
364: av[i++] = MOUNT_PC;
365: }
366: av[i++] = 0;
367: return(av);
368: }
369:
370: #ifdef NFS
371: namematch(hp, nfshost)
372: struct hostent *hp;
373: char *nfshost;
374: {
375: register char *cp;
376: register char **np;
377:
378: if (hp == NULL || nfshost == NULL)
379: return(1);
380: if (strcasecmp(nfshost, hp->h_name) == 0)
381: return(1);
382: if (cp = index(hp->h_name, '.')) {
383: *cp = '\0';
384: if (strcasecmp(nfshost, hp->h_name) == 0)
385: return(1);
386: }
387: for (np = hp->h_aliases; *np; np++) {
388: if (strcasecmp(nfshost, *np) == 0)
389: return(1);
390: if (cp = index(*np, '.')) {
391: *cp = '\0';
392: if (strcasecmp(nfshost, *np) == 0)
393: return(1);
394: }
395: }
396: return(0);
397: }
398:
399: /*
400: * xdr routines for mount rpc's
401: */
402: xdr_dir(xdrsp, dirp)
403: XDR *xdrsp;
404: char *dirp;
405: {
406: return (xdr_string(xdrsp, &dirp, RPCMNT_PATHLEN));
407: }
408: #endif /* NFS */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.