Lines of
xvfs.c.rvt
from check-in 6b8ea28911
that are changed by the sequence of edits moving toward
check-in 5f2895faba:
1: #include <xvfs-core.h>
2: #include <sys/stat.h>
3: #include <unistd.h>
4: #include <string.h>
5: #include <tcl.h>
6:
7: #define XVFS_NAME_LOOKUP_ERROR (-1)
8: #define XVFS_FILE_BLOCKSIZE 1024
9:
10: #define MIN(a, b) (((a) < (b)) ? (a) : (b))
11:
12: typedef enum {
13: XVFS_FILE_TYPE_REG,
14: XVFS_FILE_TYPE_DIR
15: } xvfs_file_type_t;
16:
17: typedef Tcl_WideInt xvfs_size_t;
18:
19: struct xvfs_file_data {
20: const char *name;
21: xvfs_file_type_t type;
22: xvfs_size_t size;
23: union {
24: const unsigned char *fileContents;
25: const char **dirChildren;
26: } data;
27: };
28:
29: <?
30: package require xvfs
31: xvfs::main $argv
32: ?>
33: static long xvfs_<?= $::xvfs::fsName ?>_nameToIndex(const char *path) {
34: unsigned int pathHash;
35: size_t pathLen;
36:
37: if (path == NULL) {
38: return(XVFS_NAME_LOOKUP_ERROR);
39: }
40:
41: pathLen = strlen(path);
42: pathHash = Tcl_ZlibAdler32(0, (const unsigned char *) path, pathLen);
43: switch (pathHash) {
44: <?
45: for {set index 0} {$index < [llength $::xvfs::outputFiles]} {incr index} {
46: set outputFile [lindex $::xvfs::outputFiles $index]
47: set outputFileHash [zlib adler32 $outputFile 0]
48: lappend outputFileHashToIndex($outputFileHash) $index
49: }
50:
51: foreach {outputFileHash outputFileIndexes} [lsort -stride 2 -dictionary [array get outputFileHashToIndex]] {
52: ?> case <?= $outputFileHash ?>:
53: <?
54: foreach outputFileIndex $outputFileIndexes {
55: set outputFileName [lindex $::xvfs::outputFiles $outputFileIndex]
56: set outputFileNameLen [string length $outputFileName]
57: ?> if (pathLen == <?= $outputFileNameLen ?> && memcmp(path, xvfs_<?= $::xvfs::fsName ?>_data[<?= $outputFileIndex ?>].name, pathLen) == 0) {
58: return(<?= $outputFileIndex ?>);
59: }
60: <?
61: }
62: ?> break;
63: <? } ?>
64: }
65:
66: return(XVFS_NAME_LOOKUP_ERROR);
67: }
68:
69: static const char **xvfs_<?= $::xvfs::fsName ?>_getChildren(const char *path, Tcl_WideInt *count) {
70: struct xvfs_file_data *fileInfo;
71: long inode;
72:
73: /*
74: * Validate input parameters
75: */
76: if (count == NULL) {
77: return(NULL);
78: }
79:
80: /*
81: * Get the inode from the lookup function
82: */
83: inode = xvfs_<?= $::xvfs::fsName ?>_nameToIndex(path);
84: if (inode == XVFS_NAME_LOOKUP_ERROR) {
85: *count = XVFS_RV_ERR_ENOENT;
86: return(NULL);
87: }
88:
89: fileInfo = &xvfs_<?= $::xvfs::fsName ?>_data[inode];
90:
91: /*
92: * Ensure this is a directory
93: */
94: if (fileInfo->type != XVFS_FILE_TYPE_DIR) {
95: *count = XVFS_RV_ERR_ENOTDIR;
96: return(NULL);
97: }
98:
99: *count = fileInfo->size;
100: return(fileInfo->data.dirChildren);
101: }
102:
103: static const unsigned char *xvfs_<?= $::xvfs::fsName ?>_getData(const char *path, Tcl_WideInt start, Tcl_WideInt *length) {
104: struct xvfs_file_data *fileInfo;
105: Tcl_WideInt resultLength;
106: long inode;
107:
108: /*
109: * Validate input parameters
110: */
111: if (length == NULL) {
112: return(NULL);
113: }
114:
115: if (start < 0) {
116: *length = XVFS_RV_ERR_EINVAL;
117: return(NULL);
118: }
119:
120: if (*length < 0) {
121: *length = XVFS_RV_ERR_EINVAL;
122: return(NULL);
123: }
124:
125: /*
126: * Get the inode from the lookup function
127: */
128: inode = xvfs_<?= $::xvfs::fsName ?>_nameToIndex(path);
129: if (inode == XVFS_NAME_LOOKUP_ERROR) {
130: *length = XVFS_RV_ERR_ENOENT;
131: return(NULL);
132: }
133:
134: fileInfo = &xvfs_<?= $::xvfs::fsName ?>_data[inode];
135:
136: /*
137: * Ensure this is a file that can be read
138: */
139: if (fileInfo->type != XVFS_FILE_TYPE_REG) {
140: *length = XVFS_RV_ERR_EISDIR;
141: return(NULL);
142: }
143:
144: /*
145: * Validate the length
146: */
147: if (start > fileInfo->size) {
148: *length = XVFS_RV_ERR_EFAULT;
149: return(NULL);
150: }
151:
152: if (*length == 0) {
153: resultLength = fileInfo->size - start;
154: } else {
155: resultLength = MIN(fileInfo->size - start, *length);
156: }
157: *length = resultLength;
158:
159: /*
160: * Return the data
161: */
162: return(fileInfo->data.fileContents + start);
163: }
164:
165: static int xvfs_<?= $::xvfs::fsName ?>_getStat(const char *path, Tcl_StatBuf *statBuf) {
166: struct xvfs_file_data *fileInfo;
167: long inode;
168:
169: /*
170: * Validate input parameters
171: */
172: if (!statBuf) {
173: return(XVFS_RV_ERR_EINVAL);
174: }
175:
176: /*
177: * Get the inode from the lookup function
178: */
179: inode = xvfs_<?= $::xvfs::fsName ?>_nameToIndex(path);
180: if (inode == XVFS_NAME_LOOKUP_ERROR) {
181: return(XVFS_RV_ERR_ENOENT);
182: }
183:
184: fileInfo = &xvfs_<?= $::xvfs::fsName ?>_data[inode];
185:
186: statBuf->st_dev = 0;
187: statBuf->st_rdev = 0;
188: statBuf->st_ino = inode;
189: statBuf->st_uid = -1;
190: statBuf->st_gid = -1;
191: statBuf->st_atime = 0;
192: statBuf->st_ctime = 0;
193: statBuf->st_mtime = 0;
194: statBuf->st_blksize = XVFS_FILE_BLOCKSIZE;
195:
196: if (fileInfo->type == XVFS_FILE_TYPE_REG) {
197: statBuf->st_mode = 0100444;
198: statBuf->st_nlink = 1;
199: statBuf->st_size = fileInfo->size;
200: statBuf->st_blocks = (fileInfo->size + statBuf->st_blksize - 1) / statBuf->st_blksize;
201: } else if (fileInfo->type == XVFS_FILE_TYPE_DIR) {
202: statBuf->st_mode = 040555;
203: statBuf->st_nlink = fileInfo->size;
204: statBuf->st_size = fileInfo->size;
205: statBuf->st_blocks = 1;
206: }
207:
208: return(0);
209: }
210:
211: static struct Xvfs_FSInfo xvfs_<?= $::xvfs::fsName ?>_fsInfo = {
212: .protocolVersion = XVFS_PROTOCOL_VERSION,
213: .name = "<?= $::xvfs::fsName ?>",
214: .getChildrenProc = xvfs_<?= $::xvfs::fsName ?>_getChildren,
215: .getDataProc = xvfs_<?= $::xvfs::fsName ?>_getData,
216: .getStatProc = xvfs_<?= $::xvfs::fsName ?>_getStat
217: };
218:
219: int Xvfs_<?= $::xvfs::fsName ?>_Init(Tcl_Interp *interp) {
220: int register_ret;
221:
222: #ifdef USE_TCL_STUBS
223: const char *tclInitStubs_ret;
224: /* Initialize Stubs */
225: tclInitStubs_ret = Tcl_InitStubs(interp, TCL_PATCH_LEVEL, 0);
226: if (!tclInitStubs_ret) {
227: return(TCL_ERROR);
228: }
229: #endif
230:
231: register_ret = Xvfs_Register(interp, &xvfs_<?= $::xvfs::fsName ?>_fsInfo);
232: if (register_ret != TCL_OK) {
233: return(register_ret);
234: }
235:
236: return(TCL_OK);
237: }