FreeCalypso > hg > freecalypso-tools
comparison rvinterf/tmsh/ffs2.c @ 69:2159f260ed13
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 } |