![[BACK]](/icons/back.gif){kind=icon}
Return to lif.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / hppa / stand / libsa|
Return to lif.c CVS log | Up to [local] / sys / arch / hppa / stand / libsa |
1.1 nbrk 1: /* $OpenBSD: lif.c,v 1.10 2004/11/22 18:41:41 mickey Exp $ */
2:
3: /*
4: * Copyright (c) 1998-2004 Michael Shalayeff
5: * All rights reserved.
6: *
7: * Redistribution and use in source and binary forms, with or without
8: * modification, are permitted provided that the following conditions
9: * are met:
10: * 1. Redistributions of source code must retain the above copyright
11: * notice, this list of conditions and the following disclaimer.
12: * 2. Redistributions in binary form must reproduce the above copyright
13: * notice, this list of conditions and the following disclaimer in the
14: * documentation and/or other materials provided with the distribution.
15: *
16: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19: * IN NO EVENT SHALL THE AUTHOR OR HIS RELATIVES BE LIABLE FOR ANY DIRECT,
20: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
21: * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
22: * SERVICES; LOSS OF MIND, USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
24: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
25: * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
26: * THE POSSIBILITY OF SUCH DAMAGE.
27: */
28:
29: #include <sys/param.h>
30: #include <sys/disklabel.h>
31: #include "libsa.h"
32:
33: extern int debug;
34:
35: struct file {
36: char f_buf[LIF_FILESTART];/* buffer for lif volume header and dir */
37: struct lifvol *f_lp; /* lif volume header pointer */
38: struct lifdir *f_ld; /* lif dir pointer */
39: int f_nfiles; /* gross number for lif dir entries */
40:
41: off_t f_seek; /* seek pointer for file read */
42: struct lifdir *f_rd; /* lif dir pointer for readdir */
43:
44: int f_isdir; /* special hacky flag for '.' dir */
45: int f_count; /* this file length */
46: int f_off; /* this file offset */
47: };
48:
49: int
50: lif_open (path, f)
51: char *path;
52: struct open_file *f;
53: {
54: struct file *fp;
55: struct lifdir *dp;
56: char *p, *q;
57: struct lif_load load;
58: size_t buf_size;
59: int err, l;
60:
61: #ifdef LIFDEBUG
62: if (debug)
63: printf("lif_open(%s, %p)\n", path, f);
64: #endif
65:
66: fp = alloc(sizeof(*fp));
67: /* XXX we're assuming here that sizeof(fp->f_buf) >= LIF_FILESTART */
68: if ((err = (f->f_dev->dv_strategy)(f->f_devdata, F_READ, 0,
69: sizeof(fp->f_buf), &fp->f_buf, &buf_size)) ||
70: buf_size != sizeof(fp->f_buf)) {
71: #ifdef LIFDEBUG
72: if (debug)
73: printf("lif_open: unable to read LIF header (%d)\n", err);
74: #endif
75: } else if ((fp->f_lp = (struct lifvol *)fp->f_buf)->vol_id == LIF_VOL_ID) {
76: f->f_fsdata = fp;
77: fp->f_ld = (struct lifdir *)(fp->f_buf + LIF_DIRSTART);
78: fp->f_seek = 0;
79: fp->f_rd = fp->f_ld;
80: fp->f_nfiles = lifstob(fp->f_lp->vol_dirsize) /
81: sizeof(struct lifdir);
82:
83: /* no dirs on the lif */
84: for (p = path + (l = strlen(path)); p >= path; p--)
85: if (*p == '/') {
86: p++;
87: break;
88: }
89: if (p > path)
90: path = p;
91: } else
92: err = EINVAL;
93:
94: if (!err && *path != '.') {
95: fp->f_isdir = 0;
96: err = ENOENT;
97: for (dp = fp->f_ld; dp < &fp->f_ld[fp->f_nfiles]; dp++) {
98: #ifdef LIFDEBUG
99: if (debug)
100: printf("lif_open: "
101: "%s <--> '%c%c%c%c%c%c%c%c%c%c'\n",
102: path, dp->dir_name[0], dp->dir_name[1],
103: dp->dir_name[2], dp->dir_name[3],
104: dp->dir_name[4], dp->dir_name[5],
105: dp->dir_name[6], dp->dir_name[7],
106: dp->dir_name[8], dp->dir_name[9]);
107: #endif
108: for (p = path, q = dp->dir_name;
109: *q && *q != ' '; q++, p++)
110: if (tolower(*q) != tolower(*p))
111: break;
112: if ((!*q || *q == ' ') && !*p) {
113: err = 0;
114: break;
115: }
116: }
117: if (!err) {
118: fp->f_off = lifstodb(dp->dir_addr);
119: if (!(err =(f->f_dev->dv_strategy)(f->f_devdata, F_READ,
120: fp->f_off, sizeof(load), &load, &buf_size)) &&
121: buf_size == sizeof(load)) {
122: /* no checksum */
123: fp->f_count = load.count - sizeof(int);
124: fp->f_off = dbtob(fp->f_off) + sizeof(load);
125: #ifdef LIFDEBUG
126: if (debug)
127: printf("lif_open: %u @ %u [%x]\n",
128: fp->f_count, fp->f_off,
129: load.address);
130: #endif
131: } else if (!err)
132: err = EIO;
133: }
134: } else
135: fp->f_isdir = 1;
136:
137: if (err) {
138: free (fp, sizeof(*fp));
139: f->f_fsdata = NULL;
140: }
141: #ifdef LIFDEBUG
142: if (debug)
143: printf("ret(%d)\n", err);
144: #endif
145: return err;
146: }
147:
148: int
149: lif_close(f)
150: struct open_file *f;
151: {
152: free (f->f_fsdata, sizeof(struct file));
153: f->f_fsdata = NULL;
154: return 0;
155: }
156:
157: int
158: lif_read(f, buf, size, resid)
159: struct open_file *f;
160: void *buf;
161: size_t size;
162: size_t *resid;
163: {
164: struct file *fp = (struct file *)f->f_fsdata;
165: char *p;
166: char bbuf[DEV_BSIZE];
167: size_t bsize, count = sizeof(bbuf);
168: int err = 0;
169: int foff;
170:
171: #ifdef LIFDEBUG
172: if (debug)
173: printf("lif_read(%p, %p, %u, %p)\n", f, buf, size, resid);
174: #endif
175:
176: for (p = bbuf; size; fp->f_seek += bsize, p += bsize) {
177: twiddle();
178: foff = fp->f_off + fp->f_seek;
179: if (fp->f_seek >= fp->f_count ||
180: (err = (f->f_dev->dv_strategy)(f->f_devdata, F_READ,
181: btodb(foff), count, p, &bsize)))
182: break;
183: if (p == bbuf) {
184: bsize = sizeof(bbuf) - (foff & (sizeof(bbuf) - 1));
185: bsize = min(bsize, size);
186: bcopy(bbuf + (foff & (sizeof(bbuf) - 1)), buf, bsize);
187: p = buf;
188: }
189: count = size -= bsize;
190: }
191: if (resid)
192: *resid = size;
193:
194: return err;
195: }
196:
197: int
198: lif_write(f, buf, size, resid)
199: struct open_file *f;
200: void *buf;
201: size_t size;
202: size_t *resid;
203: {
204: return EOPNOTSUPP;
205: }
206:
207: off_t
208: lif_seek(f, offset, where)
209: struct open_file *f;
210: off_t offset;
211: int where;
212: {
213: struct file *fp = (struct file *)f->f_fsdata;
214:
215: switch (where) {
216: case SEEK_SET:
217: fp->f_seek = offset;
218: break;
219: case SEEK_CUR:
220: fp->f_seek += offset;
221: break;
222: case SEEK_END:
223: fp->f_seek = fp->f_count - offset;
224: break;
225: default:
226: return (-1);
227: }
228: return (fp->f_seek);
229: }
230:
231: int
232: lif_stat(f, sb)
233: struct open_file *f;
234: struct stat *sb;
235: {
236: struct file *fp = (struct file *)f->f_fsdata;
237:
238: sb->st_mode = 0755 | (fp->f_isdir? S_IFDIR: 0); /* XXX */
239: sb->st_uid = 0;
240: sb->st_gid = 0;
241: sb->st_size = fp->f_count;
242: return 0;
243: }
244:
245: int
246: lif_readdir(f, name)
247: struct open_file *f;
248: char *name;
249: {
250: struct file *fp = (struct file *)f->f_fsdata;
251: char *p;
252:
253: if (name) {
254: while ((fp->f_rd->dir_name[0] == ' ' ||
255: !fp->f_rd->dir_name[0]) &&
256: (fp->f_rd - fp->f_ld) < fp->f_nfiles)
257: fp->f_rd++;
258: if ((fp->f_rd - fp->f_ld) >= fp->f_nfiles) {
259: *name = '\0';
260: return -1;
261: }
262: strncpy(name, fp->f_rd->dir_name, sizeof(fp->f_rd->dir_name));
263: if ((p = strchr(name, ' ')))
264: *p = '\0';
265: fp->f_rd++;
266: } else
267: fp->f_rd = fp->f_ld;
268:
269: return 0;
270: }