FreeCalypso > hg > freecalypso-tools

comparison rvinterf/tmsh/ffs2.c @ 69:2159f260ed13

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
fc-tmsh: all commands internally return values in preparation for adding one-shot mode of operation
author Mychaela Falconia <falcon@freecalypso.org>
date Wed, 26 Oct 2016 23:17:03 +0000
parents e7502631a0f9
children
comparison
equal deleted inserted replaced
68:585f63e5bca6 69:2159f260ed13
10 #include "limits.h" 10 #include "limits.h"
11 #include "localtypes.h" 11 #include "localtypes.h"
12 #include "etm.h" 12 #include "etm.h"
13 #include "ffs.h" 13 #include "ffs.h"
14 #include "tmffs2.h" 14 #include "tmffs2.h"
15 15 #include "exitcodes.h"
16 void 16
17 cmd_ffs2_close(argc, argv) 17 cmd_ffs2_close(argc, argv)
18 char **argv; 18 char **argv;
19 { 19 {
20 u_char cmdpkt[5]; 20 u_char cmdpkt[5];
21 21
22 cmdpkt[1] = ETM_FFS2; 22 cmdpkt[1] = ETM_FFS2;
23 cmdpkt[2] = TMFFS_CLOSE; 23 cmdpkt[2] = TMFFS_CLOSE;
24 cmdpkt[3] = strtoul(argv[1], 0, 0); 24 cmdpkt[3] = strtoul(argv[1], 0, 0);
25 send_etm_cmd(cmdpkt, 3); 25 send_etm_cmd(cmdpkt, 3);
26 } 26 return(0);
27 27 }
28 void 28
29 cmd_ffs2_delete(argc, argv) 29 cmd_ffs2_delete(argc, argv)
30 char **argv; 30 char **argv;
31 { 31 {
32 u_char cmdpkt[MAX_PKT_TO_TARGET], *dp; 32 u_char cmdpkt[MAX_PKT_TO_TARGET], *dp;
33 int slen; 33 int slen;
34 34
35 slen = strlen(argv[1]); 35 slen = strlen(argv[1]);
36 if (slen >= TMFFS_STRING_SIZE) { 36 if (slen >= TMFFS_STRING_SIZE) {
37 printf("error: pathname arg exceeds string length limit\n"); 37 printf("error: pathname arg exceeds string length limit\n");
38 return; 38 return(ERROR_USAGE);
39 } 39 }
40 dp = cmdpkt + 1; 40 dp = cmdpkt + 1;
41 *dp++ = ETM_FFS2; 41 *dp++ = ETM_FFS2;
42 *dp++ = TMFFS_REMOVE; 42 *dp++ = TMFFS_REMOVE;
43 *dp++ = slen + 1; 43 *dp++ = slen + 1;
44 strcpy(dp, argv[1]); 44 strcpy(dp, argv[1]);
45 dp += slen + 1; 45 dp += slen + 1;
46 send_etm_cmd(cmdpkt, dp - cmdpkt - 1); 46 send_etm_cmd(cmdpkt, dp - cmdpkt - 1);
47 } 47 return(0);
48 48 }
49 void 49
50 cmd_ffs2_format(argc, argv) 50 cmd_ffs2_format(argc, argv)
51 char **argv; 51 char **argv;
52 { 52 {
53 u_char cmdpkt[MAX_PKT_TO_TARGET], *dp; 53 u_char cmdpkt[MAX_PKT_TO_TARGET], *dp;
54 int slen; 54 int slen;
55 55
56 slen = strlen(argv[1]); 56 slen = strlen(argv[1]);
57 if (slen >= TMFFS_STRING_SIZE) { 57 if (slen >= TMFFS_STRING_SIZE) {
58 printf("error: argument exceeds string length limit\n"); 58 printf("error: argument exceeds string length limit\n");
59 return; 59 return(ERROR_USAGE);
60 } 60 }
61 dp = cmdpkt + 1; 61 dp = cmdpkt + 1;
62 *dp++ = ETM_FFS2; 62 *dp++ = ETM_FFS2;
63 *dp++ = TMFFS_FORMAT; 63 *dp++ = TMFFS_FORMAT;
64 *dp++ = slen + 1; 64 *dp++ = slen + 1;
66 dp += slen + 1; 66 dp += slen + 1;
67 /* magic is 0x2BAD, 16-bit little-endian */ 67 /* magic is 0x2BAD, 16-bit little-endian */
68 *dp++ = 0xAD; 68 *dp++ = 0xAD;
69 *dp++ = 0x2B; 69 *dp++ = 0x2B;
70 send_etm_cmd(cmdpkt, dp - cmdpkt - 1); 70 send_etm_cmd(cmdpkt, dp - cmdpkt - 1);
71 } 71 return(0);
72 72 }
73 void 73
74 cmd_ffs2_mkdir(argc, argv) 74 cmd_ffs2_mkdir(argc, argv)
75 char **argv; 75 char **argv;
76 { 76 {
77 u_char cmdpkt[MAX_PKT_TO_TARGET], *dp; 77 u_char cmdpkt[MAX_PKT_TO_TARGET], *dp;
78 int slen; 78 int slen;
79 79
80 slen = strlen(argv[1]); 80 slen = strlen(argv[1]);
81 if (slen >= TMFFS_STRING_SIZE) { 81 if (slen >= TMFFS_STRING_SIZE) {
82 printf("error: pathname arg exceeds string length limit\n"); 82 printf("error: pathname arg exceeds string length limit\n");
83 return; 83 return(ERROR_USAGE);
84 } 84 }
85 dp = cmdpkt + 1; 85 dp = cmdpkt + 1;
86 *dp++ = ETM_FFS2; 86 *dp++ = ETM_FFS2;
87 *dp++ = TMFFS_MKDIR; 87 *dp++ = TMFFS_MKDIR;
88 *dp++ = slen + 1; 88 *dp++ = slen + 1;
89 strcpy(dp, argv[1]); 89 strcpy(dp, argv[1]);
90 dp += slen + 1; 90 dp += slen + 1;
91 send_etm_cmd(cmdpkt, dp - cmdpkt - 1); 91 send_etm_cmd(cmdpkt, dp - cmdpkt - 1);
92 } 92 return(0);
93 93 }
94 void 94
95 cmd_ffs2_open(argc, argv) 95 cmd_ffs2_open(argc, argv)
96 char **argv; 96 char **argv;
97 { 97 {
98 u_char cmdpkt[MAX_PKT_TO_TARGET], *dp; 98 u_char cmdpkt[MAX_PKT_TO_TARGET], *dp;
99 int slen; 99 int slen;
100 100
101 slen = strlen(argv[1]); 101 slen = strlen(argv[1]);
102 if (slen >= TMFFS_STRING_SIZE) { 102 if (slen >= TMFFS_STRING_SIZE) {
103 printf("error: pathname arg exceeds string length limit\n"); 103 printf("error: pathname arg exceeds string length limit\n");
104 return; 104 return(ERROR_USAGE);
105 } 105 }
106 dp = cmdpkt + 1; 106 dp = cmdpkt + 1;
107 *dp++ = ETM_FFS2; 107 *dp++ = ETM_FFS2;
108 *dp++ = TMFFS_OPEN; 108 *dp++ = TMFFS_OPEN;
109 *dp++ = slen + 1; 109 *dp++ = slen + 1;
110 strcpy(dp, argv[1]); 110 strcpy(dp, argv[1]);
111 dp += slen + 1; 111 dp += slen + 1;
112 *dp++ = strtoul(argv[2], 0, 16); 112 *dp++ = strtoul(argv[2], 0, 16);
113 send_etm_cmd(cmdpkt, dp - cmdpkt - 1); 113 send_etm_cmd(cmdpkt, dp - cmdpkt - 1);
114 } 114 return(0);
115 115 }
116 void 116
117 cmd_ffs2_opendir(argc, argv) 117 cmd_ffs2_opendir(argc, argv)
118 char **argv; 118 char **argv;
119 { 119 {
120 u_char cmdpkt[MAX_PKT_TO_TARGET], *dp; 120 u_char cmdpkt[MAX_PKT_TO_TARGET], *dp;
121 int slen; 121 int slen;
122 122
123 slen = strlen(argv[1]); 123 slen = strlen(argv[1]);
124 if (slen >= TMFFS_STRING_SIZE) { 124 if (slen >= TMFFS_STRING_SIZE) {
125 printf("error: pathname arg exceeds string length limit\n"); 125 printf("error: pathname arg exceeds string length limit\n");
126 return; 126 return(ERROR_USAGE);
127 } 127 }
128 dp = cmdpkt + 1; 128 dp = cmdpkt + 1;
129 *dp++ = ETM_FFS2; 129 *dp++ = ETM_FFS2;
130 *dp++ = TMFFS_OPENDIR; 130 *dp++ = TMFFS_OPENDIR;
131 *dp++ = slen + 1; 131 *dp++ = slen + 1;
132 strcpy(dp, argv[1]); 132 strcpy(dp, argv[1]);
133 dp += slen + 1; 133 dp += slen + 1;
134 send_etm_cmd(cmdpkt, dp - cmdpkt - 1); 134 send_etm_cmd(cmdpkt, dp - cmdpkt - 1);
135 } 135 return(0);
136 136 }
137 void 137
138 cmd_ffs2_preformat() 138 cmd_ffs2_preformat()
139 { 139 {
140 u_char cmdpkt[6]; 140 u_char cmdpkt[6];
141 141
142 cmdpkt[1] = ETM_FFS2; 142 cmdpkt[1] = ETM_FFS2;
143 cmdpkt[2] = TMFFS_PREFORMAT; 143 cmdpkt[2] = TMFFS_PREFORMAT;
144 /* magic is 0xDEAD, 16-bit little-endian */ 144 /* magic is 0xDEAD, 16-bit little-endian */
145 cmdpkt[3] = 0xAD; 145 cmdpkt[3] = 0xAD;
146 cmdpkt[4] = 0xDE; 146 cmdpkt[4] = 0xDE;
147 send_etm_cmd(cmdpkt, 4); 147 send_etm_cmd(cmdpkt, 4);
148 } 148 return(0);
149 149 }
150 void 150
151 cmd_ffs2_query(argc, argv) 151 cmd_ffs2_query(argc, argv)
152 char **argv; 152 char **argv;
153 { 153 {
154 u_char cmdpkt[5]; 154 u_char cmdpkt[5];
155 155
156 cmdpkt[1] = ETM_FFS2; 156 cmdpkt[1] = ETM_FFS2;
157 cmdpkt[2] = TMFFS_QUERY; 157 cmdpkt[2] = TMFFS_QUERY;
158 cmdpkt[3] = strtoul(argv[1], 0, 0); 158 cmdpkt[3] = strtoul(argv[1], 0, 0);
159 send_etm_cmd(cmdpkt, 3); 159 send_etm_cmd(cmdpkt, 3);
160 } 160 return(0);
161 161 }
162 void 162
163 cmd_ffs2_readfd(argc, argv) 163 cmd_ffs2_readfd(argc, argv)
164 char **argv; 164 char **argv;
165 { 165 {
166 u_char cmdpkt[6]; 166 u_char cmdpkt[6];
167 167
168 cmdpkt[1] = ETM_FFS2; 168 cmdpkt[1] = ETM_FFS2;
169 cmdpkt[2] = TMFFS_READ; 169 cmdpkt[2] = TMFFS_READ;
170 cmdpkt[3] = strtoul(argv[1], 0, 0); 170 cmdpkt[3] = strtoul(argv[1], 0, 0);
171 cmdpkt[4] = strtoul(argv[2], 0, 0); 171 cmdpkt[4] = strtoul(argv[2], 0, 0);
172 send_etm_cmd(cmdpkt, 4); 172 send_etm_cmd(cmdpkt, 4);
173 } 173 return(0);
174 174 }
175 void 175
176 cmd_ffs2_readfile(argc, argv) 176 cmd_ffs2_readfile(argc, argv)
177 char **argv; 177 char **argv;
178 { 178 {
179 u_char cmdpkt[MAX_PKT_TO_TARGET], *dp; 179 u_char cmdpkt[MAX_PKT_TO_TARGET], *dp;
180 int slen; 180 int slen;
181 181
182 slen = strlen(argv[1]); 182 slen = strlen(argv[1]);
183 if (slen >= TMFFS_STRING_SIZE) { 183 if (slen >= TMFFS_STRING_SIZE) {
184 printf("error: pathname arg exceeds string length limit\n"); 184 printf("error: pathname arg exceeds string length limit\n");
185 return; 185 return(ERROR_USAGE);
186 } 186 }
187 dp = cmdpkt + 1; 187 dp = cmdpkt + 1;
188 *dp++ = ETM_FFS2; 188 *dp++ = ETM_FFS2;
189 *dp++ = TMFFS_FILE_READ; 189 *dp++ = TMFFS_FILE_READ;
190 *dp++ = slen + 1; 190 *dp++ = slen + 1;
191 strcpy(dp, argv[1]); 191 strcpy(dp, argv[1]);
192 dp += slen + 1; 192 dp += slen + 1;
193 *dp++ = strtoul(argv[2], 0, 0); 193 *dp++ = strtoul(argv[2], 0, 0);
194 send_etm_cmd(cmdpkt, dp - cmdpkt - 1); 194 send_etm_cmd(cmdpkt, dp - cmdpkt - 1);
195 } 195 return(0);
196 196 }
197 void 197
198 cmd_ffs2_stat(argc, argv) 198 cmd_ffs2_stat(argc, argv)
199 char **argv; 199 char **argv;
200 { 200 {
201 u_char cmdpkt[MAX_PKT_TO_TARGET], *dp; 201 u_char cmdpkt[MAX_PKT_TO_TARGET], *dp;
202 int slen; 202 int slen;
203 203
204 slen = strlen(argv[1]); 204 slen = strlen(argv[1]);
205 if (slen >= TMFFS_STRING_SIZE) { 205 if (slen >= TMFFS_STRING_SIZE) {
206 printf("error: pathname arg exceeds string length limit\n"); 206 printf("error: pathname arg exceeds string length limit\n");
207 return; 207 return(ERROR_USAGE);
208 } 208 }
209 dp = cmdpkt + 1; 209 dp = cmdpkt + 1;
210 *dp++ = ETM_FFS2; 210 *dp++ = ETM_FFS2;
211 *dp++ = TMFFS_STAT; 211 *dp++ = TMFFS_STAT;
212 *dp++ = slen + 1; 212 *dp++ = slen + 1;
213 strcpy(dp, argv[1]); 213 strcpy(dp, argv[1]);
214 dp += slen + 1; 214 dp += slen + 1;
215 send_etm_cmd(cmdpkt, dp - cmdpkt - 1); 215 send_etm_cmd(cmdpkt, dp - cmdpkt - 1);
216 } 216 return(0);
217 217 }
218 void 218
219 cmd_ffs2_version() 219 cmd_ffs2_version()
220 { 220 {
221 u_char cmdpkt[4]; 221 u_char cmdpkt[4];
222 222
223 cmdpkt[1] = ETM_FFS2; 223 cmdpkt[1] = ETM_FFS2;
224 cmdpkt[2] = TMFFS_VERSION; 224 cmdpkt[2] = TMFFS_VERSION;
225 send_etm_cmd(cmdpkt, 2); 225 send_etm_cmd(cmdpkt, 2);
226 } 226 return(0);
227 227 }
228 void 228
229 cmd_ffs2_wrfile(argc, argv) 229 cmd_ffs2_wrfile(argc, argv)
230 char **argv; 230 char **argv;
231 { 231 {
232 u_char cmdpkt[MAX_PKT_TO_TARGET], *dp; 232 u_char cmdpkt[MAX_PKT_TO_TARGET], *dp;
233 int slen, slen2; 233 int slen, slen2;
234 234
235 slen = strlen(argv[1]); 235 slen = strlen(argv[1]);
236 if (slen >= TMFFS_STRING_SIZE) { 236 if (slen >= TMFFS_STRING_SIZE) {
237 printf("error: pathname arg exceeds string length limit\n"); 237 printf("error: pathname arg exceeds string length limit\n");
238 return; 238 return(ERROR_USAGE);
239 } 239 }
240 slen2 = strlen(argv[2]); 240 slen2 = strlen(argv[2]);
241 if (slen2 > 64) { 241 if (slen2 > 64) {
242 printf("error: write test data argument is too long\n"); 242 printf("error: write test data argument is too long\n");
243 return; 243 return(ERROR_USAGE);
244 } 244 }
245 dp = cmdpkt + 1; 245 dp = cmdpkt + 1;
246 *dp++ = ETM_FFS2; 246 *dp++ = ETM_FFS2;
247 *dp++ = TMFFS_FILE_WRITE; 247 *dp++ = TMFFS_FILE_WRITE;
248 *dp++ = slen + 1; 248 *dp++ = slen + 1;
251 *dp++ = slen2; /* no NUL-termination on test data */ 251 *dp++ = slen2; /* no NUL-termination on test data */
252 strcpy(dp, argv[2]); 252 strcpy(dp, argv[2]);
253 dp += slen2; 253 dp += slen2;
254 *dp++ = FFS_O_CREATE | FFS_O_TRUNC; 254 *dp++ = FFS_O_CREATE | FFS_O_TRUNC;
255 send_etm_cmd(cmdpkt, dp - cmdpkt - 1); 255 send_etm_cmd(cmdpkt, dp - cmdpkt - 1);
256 } 256 return(0);
257 257 }
258 void 258
259 cmd_ffs2_writefd(argc, argv) 259 cmd_ffs2_writefd(argc, argv)
260 char **argv; 260 char **argv;
261 { 261 {
262 u_char cmdpkt[MAX_PKT_TO_TARGET], *dp; 262 u_char cmdpkt[MAX_PKT_TO_TARGET], *dp;
263 int slen2; 263 int slen2;
264 264
265 slen2 = strlen(argv[2]); 265 slen2 = strlen(argv[2]);
266 if (slen2 > 64) { 266 if (slen2 > 64) {
267 printf("error: write test data argument is too long\n"); 267 printf("error: write test data argument is too long\n");
268 return; 268 return(ERROR_USAGE);
269 } 269 }
270 dp = cmdpkt + 1; 270 dp = cmdpkt + 1;
271 *dp++ = ETM_FFS2; 271 *dp++ = ETM_FFS2;
272 *dp++ = TMFFS_WRITE; 272 *dp++ = TMFFS_WRITE;
273 *dp++ = strtoul(argv[1], 0, 0); 273 *dp++ = strtoul(argv[1], 0, 0);
274 *dp++ = slen2; /* no NUL-termination on test data */ 274 *dp++ = slen2; /* no NUL-termination on test data */
275 strcpy(dp, argv[2]); 275 strcpy(dp, argv[2]);
276 dp += slen2; 276 dp += slen2;
277 send_etm_cmd(cmdpkt, dp - cmdpkt - 1); 277 send_etm_cmd(cmdpkt, dp - cmdpkt - 1);
278 } 278 return(0);
279 279 }
280 void 280
281 cmd_ffs2_xlstat(argc, argv) 281 cmd_ffs2_xlstat(argc, argv)
282 char **argv; 282 char **argv;
283 { 283 {
284 u_char cmdpkt[MAX_PKT_TO_TARGET], *dp; 284 u_char cmdpkt[MAX_PKT_TO_TARGET], *dp;
285 int slen; 285 int slen;
286 286
287 slen = strlen(argv[1]); 287 slen = strlen(argv[1]);
288 if (slen >= TMFFS_STRING_SIZE) { 288 if (slen >= TMFFS_STRING_SIZE) {
289 printf("error: pathname arg exceeds string length limit\n"); 289 printf("error: pathname arg exceeds string length limit\n");
290 return; 290 return(ERROR_USAGE);
291 } 291 }
292 dp = cmdpkt + 1; 292 dp = cmdpkt + 1;
293 *dp++ = ETM_FFS2; 293 *dp++ = ETM_FFS2;
294 *dp++ = TMFFS_XLSTAT; 294 *dp++ = TMFFS_XLSTAT;
295 *dp++ = slen + 1; 295 *dp++ = slen + 1;
296 strcpy(dp, argv[1]); 296 strcpy(dp, argv[1]);
297 dp += slen + 1; 297 dp += slen + 1;
298 send_etm_cmd(cmdpkt, dp - cmdpkt - 1); 298 send_etm_cmd(cmdpkt, dp - cmdpkt - 1);
299 return(0);
299 } 300 }
300 301
301 static struct cmdtab { 302 static struct cmdtab {
302 char *cmd; 303 char *cmd;
303 int minargs; 304 int minargs;
304 int maxargs; 305 int maxargs;
305 void (*func)(); 306 int (*func)();
306 } ffs2_cmds[] = { 307 } ffs2_cmds[] = {
307 {"close", 1, 1, cmd_ffs2_close}, 308 {"close", 1, 1, cmd_ffs2_close},
308 {"delete", 1, 1, cmd_ffs2_delete}, 309 {"delete", 1, 1, cmd_ffs2_delete},
309 {"format", 1, 1, cmd_ffs2_format}, 310 {"format", 1, 1, cmd_ffs2_format},
310 {"mkdir", 1, 1, cmd_ffs2_mkdir}, 311 {"mkdir", 1, 1, cmd_ffs2_mkdir},
320 {"writefd", 2, 2, cmd_ffs2_writefd}, 321 {"writefd", 2, 2, cmd_ffs2_writefd},
321 {"xlstat", 1, 1, cmd_ffs2_xlstat}, 322 {"xlstat", 1, 1, cmd_ffs2_xlstat},
322 {0, 0, 0, 0} 323 {0, 0, 0, 0}
323 }; 324 };
324 325
325 void
326 cmd_ffs2(argc, argv) 326 cmd_ffs2(argc, argv)
327 char **argv; 327 char **argv;
328 { 328 {
329 struct cmdtab *tp; 329 struct cmdtab *tp;
330 int extargs; 330 int extargs;
332 for (tp = ffs2_cmds; tp->cmd; tp++) 332 for (tp = ffs2_cmds; tp->cmd; tp++)
333 if (!strcmp(tp->cmd, argv[1])) 333 if (!strcmp(tp->cmd, argv[1]))
334 break; 334 break;
335 if (!tp->func) { 335 if (!tp->func) {
336 printf("error: no such ffs2 command\n"); 336 printf("error: no such ffs2 command\n");
337 return; 337 return(ERROR_USAGE);
338 } 338 }
339 extargs = argc - 2; 339 extargs = argc - 2;
340 if (extargs > tp->maxargs) { 340 if (extargs > tp->maxargs) {
341 printf("error: too many arguments\n"); 341 printf("error: too many arguments\n");
342 return; 342 return(ERROR_USAGE);
343 } 343 }
344 if (extargs < tp->minargs) { 344 if (extargs < tp->minargs) {
345 printf("error: too few arguments\n"); 345 printf("error: too few arguments\n");
346 return; 346 return(ERROR_USAGE);
347 } 347 }
348 tp->func(argc - 1, argv + 1); 348 return tp->func(argc - 1, argv + 1);
349 } 349 }