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