Context Navigation

source: rtems/cpukit/libmisc/shell/shell.c @ 8bca4fc

4.104.115

Last change on this file since 8bca4fc was 8bca4fc, checked in by Thomas Doerfler <Thomas.Doerfler@…>, on 11/30/09 at 13:24:59
Added format string to fprintf().
Property mode set to `100644`
File size: 25.0 KB

Line
1	/*
2	*
3	* Instantatiate a new terminal shell.
4	*
5	* Author:
6	*
7	* WORK: fernando.ruiz@ctv.es
8	* HOME: correo@fernando-ruiz.com
9	*
10	* The license and distribution terms for this file may be
11	* found in the file LICENSE in this distribution or at
12	* http://www.rtems.com/license/LICENSE.
13	*
14	* $Id$
15	*/
16
17	#ifdef HAVE_CONFIG_H
18	#include "config.h"
19	#endif
20
21	#include <stdio.h>
22	#include <time.h>
23
24	#include <rtems.h>
25	#include <rtems/error.h>
26	#include <rtems/libio.h>
27	#include <rtems/libio_.h>
28	#include <rtems/system.h>
29	#include <rtems/shell.h>
30	#include <rtems/shellconfig.h>
31	#include <rtems/console.h>
32	#include "internal.h"
33
34	#include <termios.h>
35	#include <string.h>
36	#include <stdlib.h>
37	#include <ctype.h>
38	#include <sys/stat.h>
39	#include <unistd.h>
40	#include <errno.h>
41	#include <pwd.h>
42
43	rtems_shell_env_t rtems_global_shell_env = {
44	.magic = rtems_build_name('S', 'E', 'N', 'V'),
45	.devname = CONSOLE_DEVICE_NAME,
46	.taskname = "SHGL",
47	.exit_shell = false,
48	.forever = true,
49	.errorlevel = -1,
50	.echo = false,
51	.cwd = "/",
52	.input = NULL,
53	.output = NULL,
54	.output_append = false,
55	.wake_on_end = RTEMS_ID_NONE,
56	.login_check = NULL
57	};
58
59	rtems_shell_env_t *rtems_current_shell_env = &rtems_global_shell_env;
60
61	/*
62	* Initialize the shell user/process environment information
63	*/
64	rtems_shell_env_t *rtems_shell_init_env(
65	rtems_shell_env_t *shell_env_p
66	)
67	{
68	rtems_shell_env_t *shell_env;
69
70	shell_env = malloc(sizeof(rtems_shell_env_t));
71	if ( !shell_env )
72	return NULL;
73	if ( !shell_env_p ) {
74	*shell_env = rtems_global_shell_env;
75	} else {
76	shell_env = shell_env_p;
77	}
78	shell_env->taskname = NULL;
79
80	return shell_env;
81	}
82
83	/*
84	* Completely free a shell_env_t and all associated memory
85	*/
86	void rtems_shell_env_free(
87	void *ptr
88	)
89	{
90	rtems_shell_env_t *shell_env;
91	shell_env = (rtems_shell_env_t *) ptr;
92
93	if ( !ptr )
94	return;
95
96	if ( shell_env->input )
97	free((void *)shell_env->input);
98	if ( shell_env->output )
99	free((void *)shell_env->output);
100	free( ptr );
101	}
102
103	/*
104	* Get a line of user input with modest features
105	*/
106	int rtems_shell_line_editor(
107	char *cmds[],
108	int count,
109	int size,
110	const char *prompt,
111	FILE *in,
112	FILE *out
113	)
114	{
115	unsigned int extended_key;
116	int c;
117	int col;
118	int last_col;
119	int output;
120	char line[size];
121	char new_line[size];
122	int up;
123	int cmd = -1;
124	int inserting = 1;
125
126	output = (out && isatty(fileno(in)));
127
128	col = last_col = 0;
129
130	tcdrain(fileno(in));
131	if (out)
132	tcdrain(fileno(out));
133
134	if (output && prompt)
135	fprintf(out, "\r%s", prompt);
136
137	line[0] = 0;
138	new_line[0] = 0;
139
140	for (;;) {
141
142	if (output)
143	fflush(out);
144
145	extended_key = rtems_shell_getchar(in);
146
147	if (extended_key == EOF)
148	return -2;
149
150	c = extended_key & RTEMS_SHELL_KEYS_NORMAL_MASK;
151
152	/*
153	* Make the extended_key usable as a boolean.
154	*/
155	extended_key &= ~RTEMS_SHELL_KEYS_NORMAL_MASK;
156
157	up = 0;
158
159	if (extended_key)
160	{
161	switch (c)
162	{
163	case RTEMS_SHELL_KEYS_END:
164	if (output)
165	fprintf(out, "%s", line + col);
166	col = (int) strlen (line);
167	break;
168
169	case RTEMS_SHELL_KEYS_HOME:
170	if (output) {
171	if (prompt)
172	fprintf(out,"\r%s", prompt);
173	}
174	col = 0;
175	break;
176
177	case RTEMS_SHELL_KEYS_LARROW:
178	if (col > 0)
179	{
180	col--;
181	if (output)
182	fputc('\b', out);
183	}
184	break;
185
186	case RTEMS_SHELL_KEYS_RARROW:
187	if ((col < size) && (line[col] != '\0'))
188	{
189	if (output)
190	fprintf(out, "%c", line[col]);
191	col++;
192	}
193	break;
194
195	case RTEMS_SHELL_KEYS_UARROW:
196	if ((cmd >= (count - 1)) \|\| (strlen(cmds[cmd + 1]) == 0)) {
197	if (output)
198	fputc('\x7', out);
199	break;
200	}
201
202	up = 1;
203
204	/* drop through */
205	case RTEMS_SHELL_KEYS_DARROW:
206
207	{
208	int last_cmd = cmd;
209	int clen = strlen (line);
210
211	if (prompt)
212	clen += strlen(prompt);
213
214	if (up) {
215	cmd++;
216	} else {
217	if (cmd < 0) {
218	if (output)
219	fprintf(out, "\x7");
220	break;
221	}
222	else
223	cmd--;
224	}
225
226	if ((last_cmd < 0) \|\| (strcmp(cmds[last_cmd], line) != 0))
227	memcpy (new_line, line, size);
228
229	if (cmd < 0)
230	memcpy (line, new_line, size);
231	else
232	memcpy (line, cmds[cmd], size);
233
234	col = strlen (line);
235
236	if (output) {
237	fprintf(out,"\r%*c", clen, ' ');
238	fprintf(out,"\r%s%s", prompt, line);
239	}
240	else {
241	if (output)
242	fputc('\x7', out);
243	}
244	}
245	break;
246
247	case RTEMS_SHELL_KEYS_DEL:
248	if (line[col] != '\0')
249	{
250	int end;
251	int bs;
252	strcpy (&line[col], &line[col + 1]);
253	if (output) {
254	fprintf(out,"\r%s%s ", prompt, line);
255	end = (int) strlen (line);
256	for (bs = 0; bs < ((end - col) + 1); bs++)
257	fputc('\b', out);
258	}
259	}
260	break;
261
262	case RTEMS_SHELL_KEYS_INS:
263	inserting = inserting ? 0 : 1;
264	break;
265	}
266	}
267	else
268	{
269	switch (c)
270	{
271	case 1:/Control-a/
272	if (output) {
273	if (prompt)
274	fprintf(out,"\r%s", prompt);
275	}
276	col = 0;
277	break;
278
279	case 5:/Control-e/
280	if (output)
281	fprintf(out, "%s", line + col);
282	col = (int) strlen (line);
283	break;
284
285	case 11:/Control-k/
286	if (line[col]) {
287	if (output) {
288	int end = strlen(line);
289	int bs;
290	fprintf(out,"%*c", end - col, ' ');
291	for (bs = 0; bs < (end - col); bs++)
292	fputc('\b', out);
293	}
294	line[col] = '\0';
295	}
296	break;
297
298	case 0x04:/Control-d/
299	if (strlen(line))
300	break;
301	case EOF:
302	if (output)
303	fputc('\n', out);
304	return -2;
305
306	case '\f':
307	if (output) {
308	int end;
309	int bs;
310	fputc('\f',out);
311	fprintf(out,"\r%s%s", prompt, line);
312	end = (int) strlen (line);
313	for (bs = 0; bs < (end - col); bs++)
314	fputc('\b', out);
315	}
316	break;
317
318	case '\b':
319	case '\x7f':
320	if (col > 0)
321	{
322	int bs;
323	col--;
324	strcpy (line + col, line + col + 1);
325	if (output) {
326	fprintf(out,"\b%s \b", line + col);
327	for (bs = 0; bs < ((int) strlen (line) - col); bs++)
328	fputc('\b', out);
329	}
330	}
331	break;
332
333	case '\n':
334	case '\r':
335	{
336	/*
337	* Process the command.
338	*/
339	if (output)
340	fprintf(out,"\n");
341
342	/*
343	* Only process the command if we have a command and it is not
344	* repeated in the history.
345	*/
346	if (strlen(line) == 0) {
347	cmd = -1;
348	} else {
349	if ((cmd < 0) \|\| (strcmp(line, cmds[cmd]) != 0)) {
350	if (count > 1)
351	memmove(cmds[1], cmds[0], (count - 1) * size);
352	memmove (cmds[0], line, size);
353	cmd = 0;
354	}
355	}
356	}
357	return cmd;
358
359	default:
360	if ((col < (size - 1)) && (c >= ' ') && (c <= '~')) {
361	int end = strlen (line);
362	if (inserting && (col < end) && (end < size)) {
363	int ch, bs;
364	for (ch = end + 1; ch > col; ch--)
365	line[ch] = line[ch - 1];
366	if (output) {
367	fprintf(out, "%s", line + col);
368	for (bs = 0; bs < (end - col + 1); bs++)
369	fputc('\b', out);
370	}
371	}
372	line[col++] = c;
373	if (col > end)
374	line[col] = '\0';
375	if (output)
376	fputc(c, out);
377	}
378	break;
379	}
380	}
381	}
382	return -2;
383	}
384
385	/* ----------------------------------------------- *
386	* - The shell TASK
387	* Poor but enough..
388	* TODO: Redirection. Tty Signals. ENVVARs. Shell language.
389	* ----------------------------------------------- */
390
391	void rtems_shell_init_issue(void)
392	{
393	static bool issue_inited=false;
394	struct stat buf;
395
396	if (issue_inited)
397	return;
398	issue_inited = true;
399
400	/* dummy call to init /etc dir */
401	getpwnam("root");
402
403	if (stat("/etc/issue",&buf)) {
404	rtems_shell_write_file("/etc/issue",
405	"\n"
406	"Welcome to @V\\n"
407	"Login into @S\\n");
408	}
409
410	if (stat("/etc/issue.net",&buf)) {
411	rtems_shell_write_file("/etc/issue.net",
412	"\n"
413	"Welcome to %v\n"
414	"running on %m\n");
415	}
416	}
417
418	static bool rtems_shell_login(FILE * in,FILE * out) {
419	FILE *fd;
420	int c;
421	time_t t;
422
423	rtems_shell_init_issue();
424	setuid(0);
425	setgid(0);
426	rtems_current_user_env->euid =
427	rtems_current_user_env->egid =0;
428
429	if (out) {
430	if ((rtems_current_shell_env->devname[5]!='p')\|\|
431	(rtems_current_shell_env->devname[6]!='t')\|\|
432	(rtems_current_shell_env->devname[7]!='y')) {
433	fd = fopen("/etc/issue","r");
434	if (fd) {
435	while ((c=fgetc(fd))!=EOF) {
436	if (c=='@') {
437	switch(c=fgetc(fd)) {
438	case 'L':
439	fprintf(out,"%s",rtems_current_shell_env->devname);
440	break;
441	case 'B':
442	fprintf(out,"0");
443	break;
444	case 'T':
445	case 'D':
446	time(&t);
447	fprintf(out,"%s",ctime(&t));
448	break;
449	case 'S':
450	fprintf(out,"RTEMS");
451	break;
452	case 'V':
453	fprintf(out,"%s\n%s",_RTEMS_version, _Copyright_Notice);
454	break;
455	case '@':
456	fprintf(out,"@");
457	break;
458	default :
459	fprintf(out,"@%c",c);
460	break;
461	}
462	} else if (c=='\\') {
463	switch(c=fgetc(fd)) {
464	case '\\': fprintf(out,"\\"); break;
465	case 'b': fprintf(out,"\b"); break;
466	case 'f': fprintf(out,"\f"); break;
467	case 'n': fprintf(out,"\n"); break;
468	case 'r': fprintf(out,"\r"); break;
469	case 's': fprintf(out," "); break;
470	case 't': fprintf(out,"\t"); break;
471	case '@': fprintf(out,"@"); break;
472	}
473	} else {
474	fputc(c,out);
475	}
476	}
477	fclose(fd);
478	}
479	} else {
480	fd = fopen("/etc/issue.net","r");
481	if (fd) {
482	while ((c=fgetc(fd))!=EOF) {
483	if (c=='%') {
484	switch(c=fgetc(fd)) {
485	case 't':
486	fprintf(out,"%s",rtems_current_shell_env->devname);
487	break;
488	case 'h':
489	fprintf(out,"0");
490	break;
491	case 'D':
492	fprintf(out," ");
493	break;
494	case 'd':
495	time(&t);
496	fprintf(out,"%s",ctime(&t));
497	break;
498	case 's':
499	fprintf(out,"RTEMS");
500	break;
501	case 'm':
502	fprintf(out,"(" CPU_NAME "/" CPU_MODEL_NAME ")");
503	break;
504	case 'r':
505	fprintf(out,_RTEMS_version);
506	break;
507	case 'v':
508	fprintf(out,"%s\n%s",_RTEMS_version,_Copyright_Notice);
509	break;
510	case '%':fprintf(out,"%%");
511	break;
512	default:
513	fprintf(out,"%%%c",c);
514	break;
515	}
516	} else {
517	fputc(c,out);
518	}
519	}
520	fclose(fd);
521	}
522	}
523	}
524
525	return rtems_shell_login_prompt(
526	in,
527	out,
528	rtems_current_shell_env->devname,
529	rtems_current_shell_env->login_check
530	);
531	}
532
533	#if defined(SHELL_DEBUG)
534	void rtems_shell_print_env(
535	rtems_shell_env_t * shell_env
536	)
537	{
538	if ( !shell_env ) {
539	printk( "shell_env is NULL\n" );
540	return;
541	}
542	printk( "shell_env=%p\n"
543	"shell_env->magic=0x%08x\t"
544	"shell_env->devname=%s\n"
545	"shell_env->taskname=%s\t"
546	"shell_env->exit_shell=%d\t"
547	"shell_env->forever=%d\n",
548	shell_env->magic,
549	shell_env->devname,
550	((shell_env->taskname) ? shell_env->taskname : "NOT SET"),
551	shell_env->exit_shell,
552	shell_env->forever
553	);
554	}
555	#endif
556
557	rtems_task rtems_shell_task(rtems_task_argument task_argument)
558	{
559	rtems_shell_env_t shell_env = (rtems_shell_env_t) task_argument;
560	rtems_id wake_on_end = shell_env->wake_on_end;
561	rtems_shell_main_loop( shell_env );
562	if (wake_on_end != RTEMS_INVALID_ID)
563	rtems_event_send (wake_on_end, RTEMS_EVENT_1);
564	rtems_task_delete( RTEMS_SELF );
565	}
566
567	#define RTEMS_SHELL_MAXIMUM_ARGUMENTS (128)
568	#define RTEMS_SHELL_CMD_SIZE (128)
569	#define RTEMS_SHELL_CMD_COUNT (32)
570	#define RTEMS_SHELL_PROMPT_SIZE (128)
571
572	bool rtems_shell_main_loop(
573	rtems_shell_env_t *shell_env_arg
574	)
575	{
576	rtems_shell_env_t *shell_env;
577	rtems_shell_cmd_t *shell_cmd;
578	rtems_status_code sc;
579	struct termios term;
580	struct termios previous_term;
581	char *prompt = NULL;
582	int cmd;
583	int cmd_count = 1; /* assume a script and so only 1 command line */
584	char *cmds[RTEMS_SHELL_CMD_COUNT];
585	char *cmd_argv;
586	int argc;
587	char *argv[RTEMS_SHELL_MAXIMUM_ARGUMENTS];
588	bool result = true;
589	bool input_file = false;
590	int line = 0;
591	FILE *stdinToClose = NULL;
592	FILE *stdoutToClose = NULL;
593
594	rtems_shell_initialize_command_set();
595
596	shell_env =
597	rtems_current_shell_env = rtems_shell_init_env( shell_env_arg );
598
599	/*
600	* @todo chrisj
601	* Remove the use of task variables. Change to have a single
602	* allocation per shell and then set into a notepad register
603	* in the TCB. Provide a function to return the pointer.
604	* Task variables are a virus to embedded systems software.
605	*/
606	sc = rtems_task_variable_add(
607	RTEMS_SELF,
608	(void*)&rtems_current_shell_env,
609	rtems_shell_env_free
610	);
611	if (sc != RTEMS_SUCCESSFUL) {
612	rtems_error(sc,"rtems_task_variable_add(current_shell_env):");
613	return false;
614	}
615
616	setuid(0);
617	setgid(0);
618
619	rtems_current_user_env->euid = rtems_current_user_env->egid = 0;
620
621	fileno(stdout);
622
623	/* fprintf( stderr,
624	"-%s-%s-\n", shell_env->input, shell_env->output );
625	*/
626
627	if (shell_env->output && strcmp(shell_env->output, "stdout") != 0) {
628	if (strcmp(shell_env->output, "stderr") == 0) {
629	stdout = stderr;
630	} else if (strcmp(shell_env->output, "/dev/null") == 0) {
631	fclose (stdout);
632	} else {
633	FILE *output = fopen(shell_env_arg->output,
634	shell_env_arg->output_append ? "a" : "w");
635	if (!output) {
636	fprintf(stderr, "shell: open output %s failed: %s\n",
637	shell_env_arg->output, strerror(errno));
638	return false;
639	}
640	stdout = output;
641	stdoutToClose = output;
642	}
643	}
644
645	if (shell_env->input && strcmp(shell_env_arg->input, "stdin") != 0) {
646	FILE *input = fopen(shell_env_arg->input, "r");
647	if (!input) {
648	fprintf(stderr, "shell: open input %s failed: %s\n",
649	shell_env_arg->input, strerror(errno));
650	return false;
651	}
652	stdin = input;
653	stdinToClose = input;
654	shell_env->forever = false;
655	input_file =true;
656	}
657	else {
658	/* make a raw terminal,Linux Manuals */
659	if (tcgetattr(fileno(stdin), &previous_term) >= 0) {
660	term = previous_term;
661	term.c_iflag &= ~(IGNBRK\|BRKINT\|PARMRK\|ISTRIP\|INLCR\|IGNCR\|ICRNL\|IXON);
662	term.c_oflag &= ~OPOST;
663	term.c_oflag \|= (OPOST\|ONLCR); /* But with cr+nl on output */
664	term.c_lflag &= ~(ECHO\|ECHONL\|ICANON\|ISIG\|IEXTEN);
665	term.c_cflag \|= CLOCAL \| CREAD;
666	term.c_cc[VMIN] = 1;
667	term.c_cc[VTIME] = 0;
668	if (tcsetattr (fileno(stdin), TCSADRAIN, &term) < 0) {
669	fprintf(stderr,
670	"shell:cannot set terminal attributes(%s)\n",shell_env->devname);
671	}
672	}
673	cmd_count = RTEMS_SHELL_CMD_COUNT;
674	prompt = malloc(RTEMS_SHELL_PROMPT_SIZE);
675	if (!prompt)
676	fprintf(stderr,
677	"shell:cannot allocate prompt memory\n");
678	}
679
680	setvbuf(stdin,NULL,_IONBF,0); /* Not buffered*/
681	setvbuf(stdout,NULL,_IONBF,0); /* Not buffered*/
682
683	rtems_shell_initialize_command_set();
684
685	/*
686	* Allocate the command line buffers.
687	*/
688	cmd_argv = malloc (RTEMS_SHELL_CMD_SIZE);
689	if (!cmd_argv) {
690	fprintf(stderr, "no memory for command line buffers\n" );
691	}
692
693	cmds[0] = calloc (cmd_count, RTEMS_SHELL_CMD_SIZE);
694	if (!cmds[0]) {
695	fprintf(stderr, "no memory for command line buffers\n" );
696	}
697
698	if (cmd_argv && cmds[0]) {
699
700	memset (cmds[0], 0, cmd_count * RTEMS_SHELL_CMD_SIZE);
701
702	for (cmd = 1; cmd < cmd_count; cmd++) {
703	cmds[cmd] = cmds[cmd - 1] + RTEMS_SHELL_CMD_SIZE;
704	}
705
706	do {
707	/* Set again root user and root filesystem, side effect of set_priv..*/
708	sc = rtems_libio_set_private_env();
709	if (sc != RTEMS_SUCCESSFUL) {
710	rtems_error(sc,"rtems_libio_set_private_env():");
711	result = false;
712	break;
713	}
714
715	/*
716	* By using result here, we can fall to the bottom of the
717	* loop when the connection is dropped during login and
718	* keep on trucking.
719	*/
720	if (shell_env->login_check != NULL) {
721	result = rtems_shell_login(stdin,stdout);
722	} else {
723	result = true;
724	}
725
726	if (result) {
727	const char *c;
728	memset (cmds[0], 0, cmd_count * RTEMS_SHELL_CMD_SIZE);
729	if (!input_file) {
730	rtems_shell_cat_file(stdout,"/etc/motd");
731	fprintf(stdout, "\n"
732	"RTEMS SHELL (Ver.1.0-FRC):%s. " \
733	__DATE__". 'help' to list commands.\n",
734	shell_env->devname);
735	}
736
737	if (input_file)
738	chdir(shell_env->cwd);
739	else
740	chdir("/"); /* XXX: chdir to getpwent homedir */
741
742	shell_env->exit_shell = false;
743
744	for (;;) {
745	int cmd;
746
747	/* Prompt section */
748	if (prompt) {
749	rtems_shell_get_prompt(shell_env, prompt,
750	RTEMS_SHELL_PROMPT_SIZE);
751	}
752
753	/* getcmd section */
754	cmd = rtems_shell_line_editor(cmds, cmd_count,
755	RTEMS_SHELL_CMD_SIZE, prompt,
756	stdin, stdout);
757
758	if (cmd == -1)
759	continue; /* empty line */
760
761	if (cmd == -2)
762	break; /EOF/
763
764	line++;
765
766	if (shell_env->echo)
767	fprintf(stdout, "%d: %s\n", line, cmds[cmd]);
768
769	/* evaluate cmd section */
770	c = cmds[cmd];
771	while (*c) {
772	if (!isblank(*c))
773	break;
774	c++;
775	}
776
777	if (c == '\0') / empty line */
778	continue;
779
780	if (c == '#') { / comment character */
781	cmds[cmd][0] = 0;
782	continue;
783	}
784
785	if (!strcmp(cmds[cmd],"bye") \|\| !strcmp(cmds[cmd],"exit")) {
786	fprintf(stdout, "Shell exiting\n" );
787	break;
788	} else if (!strcmp(cmds[cmd],"shutdown")) { /* exit application */
789	fprintf(stdout, "System shutting down at user request\n" );
790	exit(0);
791	}
792
793	/* exec cmd section */
794	/* TODO:
795	* To avoid user crash catch the signals.
796	* Open a new stdio files with posibility of redirection *
797	* Run in a new shell task background. (unix &)
798	* Resuming. A little bash.
799	*/
800	memcpy (cmd_argv, cmds[cmd], RTEMS_SHELL_CMD_SIZE);
801	if (!rtems_shell_make_args(cmd_argv, &argc, argv,
802	RTEMS_SHELL_MAXIMUM_ARGUMENTS)) {
803	shell_cmd = rtems_shell_lookup_cmd(argv[0]);
804	if ( argv[0] == NULL ) {
805	shell_env->errorlevel = -1;
806	} else if ( shell_cmd == NULL ) {
807	shell_env->errorlevel = rtems_shell_script_file(argc, argv);
808	} else {
809	shell_env->errorlevel = shell_cmd->command(argc, argv);
810	}
811	}
812
813	/* end exec cmd section */
814	if (shell_env->exit_shell)
815	break;
816	}
817
818	fflush( stdout );
819	fflush( stderr );
820	}
821	} while (result && shell_env->forever);
822
823	}
824
825	if (cmds[0])
826	free (cmds[0]);
827	if (cmd_argv)
828	free (cmd_argv);
829	if (prompt)
830	free (prompt);
831
832	if (stdinToClose) {
833	fclose( stdinToClose );
834	} else {
835	if (tcsetattr(fileno(stdin), TCSADRAIN, &previous_term) < 0) {
836	fprintf(
837	stderr,
838	"shell: cannot reset terminal attributes (%s)\n",
839	shell_env->devname
840	);
841	}
842	}
843	if ( stdoutToClose )
844	fclose( stdoutToClose );
845	return result;
846	}
847
848	/* ----------------------------------------------- */
849	static rtems_status_code rtems_shell_run (
850	const char *task_name,
851	size_t task_stacksize,
852	rtems_task_priority task_priority,
853	const char *devname,
854	bool forever,
855	bool wait,
856	const char *input,
857	const char *output,
858	bool output_append,
859	rtems_id wake_on_end,
860	bool echo,
861	rtems_shell_login_check_t login_check
862	)
863	{
864	rtems_id task_id;
865	rtems_status_code sc;
866	rtems_shell_env_t *shell_env;
867	rtems_name name;
868
869	if ( task_name && strlen(task_name) >= 4)
870	name = rtems_build_name(
871	task_name[0], task_name[1], task_name[2], task_name[3]);
872	else
873	name = rtems_build_name( 'S', 'E', 'N', 'V' );
874
875	sc = rtems_task_create(
876	name,
877	task_priority,
878	task_stacksize,
879	RTEMS_PREEMPT \| RTEMS_TIMESLICE \| RTEMS_NO_ASR,
880	RTEMS_LOCAL \| RTEMS_FLOATING_POINT,
881	&task_id
882	);
883	if (sc != RTEMS_SUCCESSFUL) {
884	rtems_error(sc,"creating task %s in shell_init()",task_name);
885	return sc;
886	}
887
888	shell_env = rtems_shell_init_env( NULL );
889	if ( !shell_env ) {
890	rtems_error(RTEMS_NO_MEMORY,
891	"allocating shell_env %s in shell_init()",task_name);
892	return RTEMS_NO_MEMORY;
893	}
894	shell_env->devname = devname;
895	shell_env->taskname = task_name;
896	shell_env->exit_shell = false;
897	shell_env->forever = forever;
898	shell_env->echo = echo;
899	shell_env->input = strdup (input);
900	shell_env->output = strdup (output);
901	shell_env->output_append = output_append;
902	shell_env->wake_on_end = wake_on_end;
903	shell_env->login_check = login_check;
904
905	getcwd(shell_env->cwd, sizeof(shell_env->cwd));
906
907	sc = rtems_task_start(task_id, rtems_shell_task,
908	(rtems_task_argument) shell_env);
909	if (sc != RTEMS_SUCCESSFUL) {
910	rtems_error(sc,"starting task %s in shell_init()",task_name);
911	return sc;
912	}
913
914	if (wait) {
915	rtems_event_set out;
916	sc = rtems_event_receive (RTEMS_EVENT_1, RTEMS_WAIT, 0, &out);
917	}
918
919	return 0;
920	}
921
922	rtems_status_code rtems_shell_init(
923	const char *task_name,
924	size_t task_stacksize,
925	rtems_task_priority task_priority,
926	const char *devname,
927	bool forever,
928	bool wait,
929	rtems_shell_login_check_t login_check
930	)
931	{
932	rtems_id to_wake = RTEMS_ID_NONE;
933
934	if ( wait )
935	to_wake = rtems_task_self();
936
937	return rtems_shell_run(
938	task_name, /* task_name */
939	task_stacksize, /* task_stacksize */
940	task_priority, /* task_priority */
941	devname, /* devname */
942	forever, /* forever */
943	wait, /* wait */
944	"stdin", /* input */
945	"stdout", /* output */
946	false, /* output_append */
947	to_wake, /* wake_on_end */
948	false, /* echo */
949	login_check /* login check */
950	);
951	}
952
953	rtems_status_code rtems_shell_script (
954	const char *task_name,
955	size_t task_stacksize,
956	rtems_task_priority task_priority,
957	const char* input,
958	const char* output,
959	bool output_append,
960	bool wait,
961	bool echo
962	)
963	{
964	rtems_id current_task = RTEMS_INVALID_ID;
965	rtems_status_code sc;
966
967	if (wait) {
968	sc = rtems_task_ident (RTEMS_SELF, RTEMS_LOCAL, &current_task);
969	if (sc != RTEMS_SUCCESSFUL)
970	return sc;
971	}
972
973	sc = rtems_shell_run(
974	task_name, /* task_name */
975	task_stacksize, /* task_stacksize */
976	task_priority, /* task_priority */
977	NULL, /* devname */
978	0, /* forever */
979	wait, /* wait */
980	input, /* input */
981	output, /* output */
982	output_append, /* output_append */
983	current_task, /* wake_on_end */
984	echo, /* echo */
985	NULL /* login check */
986	);
987	if (sc != RTEMS_SUCCESSFUL)
988	return sc;
989
990	return sc;
991	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: