lmainit/lmainit.c

#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/vt.h>

#include <stdio.h>
#include <stdlib.h>

#include "builtins.h"
#include "shell.h"
#include "bashgetopt.h"

/* A builtin `xxx' is normally implemented with an `xxx_builtin' function.
   If you're converting a command that uses the normal Unix argc/argv
   calling convention, use argv = make_builtin_argv (list, &argc) and call
   the original `main' something like `xxx_main'.  Look at cat.c for an
   example.

   Builtins should use internal_getopt to parse options.  It is the same as
   getopt(3), but it takes a WORD_LIST *.  Look at print.c for an example
   of its use.

   If the builtin takes no options, call no_options(list) before doing
   anything else.  If it returns a non-zero value, your builtin should
   immediately return EX_USAGE.  Look at logname.c for an example.

   A builtin command returns EXECUTION_SUCCESS for success and
   EXECUTION_FAILURE to indicate failure. */
console_builtin (list)
     WORD_LIST *list;
{
  char *path = list->word->word;
  int fd = open (path, O_RDWR);
  unsigned int console;

  if (fd != -1)
    {
      dup2 (fd, 0);
      dup2 (fd, 1);
      dup2 (fd, 2);
      if (fd > 2)
        close (fd);

      if (sscanf (path, "/dev/tty%u%*c", &console) == 1)
        {
          if (console > 0 && console < 64)
            {
              ioctl (0, VT_ACTIVATE, console);
              ioctl (0, VT_WAITACTIVE, console);
            }
        }

      return EXECUTION_SUCCESS;
    }
  else
      return EXECUTION_FAILURE;
}

/* An array of strings forming the `long' documentation for a builtin xxx,
   which is printed by `help xxx'.  It must end with a NULL. */
char *console_doc[] = {
        "connects the current process to 'path'",
        "no controlling terminal will be allocated",
        "if the path is of the form /dev/ttyN, switches to that console",
        (char *)NULL
};

/* The standard structure describing a builtin command.  bash keeps an array
   of these structures.  The flags must include BUILTIN_ENABLED so the
   builtin can be used. */
struct builtin console_struct = {
        "console",              /* builtin name */
        console_builtin,        /* function implementing the builtin */
        BUILTIN_ENABLED,        /* initial flags for builtin */
        console_doc,            /* array of long documentation strings. */
        "console path",         /* usage synopsis; becomes short_doc */
        0                       /* reserved for internal use */
};

setsid_builtin (list)
     WORD_LIST *list;
{
  int fd = open ("/dev/tty", O_RDWR);

  if (fd != -1)
    {
      ioctl (fd, TIOCNOTTY);
      close (fd);
    }

  return setsid () >= 0
       ? EXECUTION_SUCCESS
       : EXECUTION_FAILURE;
}

char *setsid_doc[] = {
        "calls setsid",
        (char *)NULL
};

struct builtin setsid_struct = {
        "setsid",
        setsid_builtin,
        BUILTIN_ENABLED,
        setsid_doc,
        "setsid",
        0
};

winsize_builtin (list)
     WORD_LIST *list;
{
  struct winsize ws;

  if (ioctl (0, TIOCGWINSZ, &ws) != -1)
    {
      printf ("rows=%d; cols=%d\n", ws.ws_row, ws.ws_col);
      return EXECUTION_SUCCESS;
    }
  else
    {
      printf ("rows=80; cols=25\n");
      return EXECUTION_FAILURE;
    }
}

char *winsize_doc[] = {
        "returns the window size as 'rows=<rows>; cols=<columns>'",
        (char *)NULL
};

struct builtin winsize_struct = {
        "winsize",
        winsize_builtin,
        BUILTIN_ENABLED,
        winsize_doc,
        "winsize",
        0
};

renamefunc_builtin (list)
     WORD_LIST *list;
{
  if (list && list->next)
    {
      BUCKET_CONTENTS *elt = (BUCKET_CONTENTS *)hash_remove (list->word->word, shell_functions, 0);
      if (elt)
        {
          SHELL_VAR *cmd = (SHELL_VAR *)elt->data;

          free (elt->key);
          free (elt);

          free (cmd->name);
          cmd->name = savestring (list->next->word->word);

          elt = hash_insert (cmd->name, shell_functions, 0);
          elt->data = (char *)cmd;

          return EXECUTION_SUCCESS;
        }
      else
        return EXECUTION_FAILURE;
    }
  else
    return EX_USAGE;
}

char *renamefunc_doc[] = {
        "rename a function from oldname to newname. the new function mustn't exist",
        (char *)NULL
};

struct builtin renamefunc_struct = {
        "renamefunc",
        renamefunc_builtin,
        BUILTIN_ENABLED,
        renamefunc_doc,
        "renamefunc oldname newname",
        0
};

usleep_builtin (list)
     WORD_LIST *list;
{
  usleep (atof (list->word->word) * 1e6);

  return EXECUTION_SUCCESS;
}

char *usleep_doc[] = {
        "sleep a (possibly fractional) number of seconds",
        (char *)NULL
};

struct builtin usleep_struct = {
        "usleep",
        usleep_builtin,
        BUILTIN_ENABLED,
        usleep_doc,
        "usleep time-in-fractional-seconds",
        0
};

str2hex_builtin (list)
     WORD_LIST *list;
{
  char *p;

  for (p = list->word->word; *p; p++)
    printf ("%02x", *p);
  puts ("\n");

  return EXECUTION_SUCCESS;
}

char *str2hex_doc[] = {
        "convert the first argument to a hex string",
        (char *)NULL
};

struct builtin str2hex_struct = {
        "str2hex",
        str2hex_builtin,
        BUILTIN_ENABLED,
        str2hex_doc,
        "str2hex string",
        0
};

#if 0
havefunc_builtin (list)
        WORD_LIST *list;
{
        if(list && find_hash_item(list->word->word, shell_functions))
                return EXECUTION_SUCCESS;
        return EXECUTION_FAILURE;
}

char *havefunc_doc[] = {
                "checks if argument is a shell function",
                (char *)NULL
};

struct builtin havefunc_struct = {
                "havefunc",
                havefunc_builtin,
                BUILTIN_ENABLED,
                havefunc_doc,
                "havefunc name",
                0
};
#endif

Revision:	1.1
Committed:	Sat Dec 7 21:49:49 2002 UTC (21 years, 5 months ago) by root
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Log Message:	* empty log message *
#	User	Rev	Content
1	root	1.1	#include <unistd.h>
2			#include <sys/types.h>
3			#include <sys/stat.h>
4			#include <fcntl.h>
5			#include <sys/ioctl.h>
6			#include <sys/vt.h>
7
8			#include <stdio.h>
9			#include <stdlib.h>
10
11			#include "builtins.h"
12			#include "shell.h"
13			#include "bashgetopt.h"
14
15			/* A builtin `xxx' is normally implemented with an `xxx_builtin' function.
16			If you're converting a command that uses the normal Unix argc/argv
17			calling convention, use argv = make_builtin_argv (list, &argc) and call
18			the original `main' something like `xxx_main'. Look at cat.c for an
19			example.
20
21			Builtins should use internal_getopt to parse options. It is the same as
22			getopt(3), but it takes a WORD_LIST *. Look at print.c for an example
23			of its use.
24
25			If the builtin takes no options, call no_options(list) before doing
26			anything else. If it returns a non-zero value, your builtin should
27			immediately return EX_USAGE. Look at logname.c for an example.
28
29			A builtin command returns EXECUTION_SUCCESS for success and
30			EXECUTION_FAILURE to indicate failure. */
31			console_builtin (list)
32			WORD_LIST *list;
33			{
34			char *path = list->word->word;
35			int fd = open (path, O_RDWR);
36			unsigned int console;
37
38			if (fd != -1)
39			{
40			dup2 (fd, 0);
41			dup2 (fd, 1);
42			dup2 (fd, 2);
43			if (fd > 2)
44			close (fd);
45
46			if (sscanf (path, "/dev/tty%u%*c", &console) == 1)
47			{
48			if (console > 0 && console < 64)
49			{
50			ioctl (0, VT_ACTIVATE, console);
51			ioctl (0, VT_WAITACTIVE, console);
52			}
53			}
54
55			return EXECUTION_SUCCESS;
56			}
57			else
58			return EXECUTION_FAILURE;
59			}
60
61			/* An array of strings forming the `long' documentation for a builtin xxx,
62			which is printed by `help xxx'. It must end with a NULL. */
63			char *console_doc[] = {
64			"connects the current process to 'path'",
65			"no controlling terminal will be allocated",
66			"if the path is of the form /dev/ttyN, switches to that console",
67			(char *)NULL
68			};
69
70			/* The standard structure describing a builtin command. bash keeps an array
71			of these structures. The flags must include BUILTIN_ENABLED so the
72			builtin can be used. */
73			struct builtin console_struct = {
74			"console", /* builtin name */
75			console_builtin, /* function implementing the builtin */
76			BUILTIN_ENABLED, /* initial flags for builtin */
77			console_doc, /* array of long documentation strings. */
78			"console path", /* usage synopsis; becomes short_doc */
79			0 /* reserved for internal use */
80			};
81
82			setsid_builtin (list)
83			WORD_LIST *list;
84			{
85			int fd = open ("/dev/tty", O_RDWR);
86
87			if (fd != -1)
88			{
89			ioctl (fd, TIOCNOTTY);
90			close (fd);
91			}
92
93			return setsid () >= 0
94			? EXECUTION_SUCCESS
95			: EXECUTION_FAILURE;
96			}
97
98			char *setsid_doc[] = {
99			"calls setsid",
100			(char *)NULL
101			};
102
103			struct builtin setsid_struct = {
104			"setsid",
105			setsid_builtin,
106			BUILTIN_ENABLED,
107			setsid_doc,
108			"setsid",
109			0
110			};
111
112			winsize_builtin (list)
113			WORD_LIST *list;
114			{
115			struct winsize ws;
116
117			if (ioctl (0, TIOCGWINSZ, &ws) != -1)
118			{
119			printf ("rows=%d; cols=%d\n", ws.ws_row, ws.ws_col);
120			return EXECUTION_SUCCESS;
121			}
122			else
123			{
124			printf ("rows=80; cols=25\n");
125			return EXECUTION_FAILURE;
126			}
127			}
128
129			char *winsize_doc[] = {
130			"returns the window size as 'rows=<rows>; cols=<columns>'",
131			(char *)NULL
132			};
133
134			struct builtin winsize_struct = {
135			"winsize",
136			winsize_builtin,
137			BUILTIN_ENABLED,
138			winsize_doc,
139			"winsize",
140			0
141			};
142
143			renamefunc_builtin (list)
144			WORD_LIST *list;
145			{
146			if (list && list->next)
147			{
148			BUCKET_CONTENTS elt = (BUCKET_CONTENTS )hash_remove (list->word->word, shell_functions, 0);
149			if (elt)
150			{
151			SHELL_VAR cmd = (SHELL_VAR )elt->data;
152
153			free (elt->key);
154			free (elt);
155
156			free (cmd->name);
157			cmd->name = savestring (list->next->word->word);
158
159			elt = hash_insert (cmd->name, shell_functions, 0);
160			elt->data = (char *)cmd;
161
162			return EXECUTION_SUCCESS;
163			}
164			else
165			return EXECUTION_FAILURE;
166			}
167			else
168			return EX_USAGE;
169			}
170
171			char *renamefunc_doc[] = {
172			"rename a function from oldname to newname. the new function mustn't exist",
173			(char *)NULL
174			};
175
176			struct builtin renamefunc_struct = {
177			"renamefunc",
178			renamefunc_builtin,
179			BUILTIN_ENABLED,
180			renamefunc_doc,
181			"renamefunc oldname newname",
182			0
183			};
184
185			usleep_builtin (list)
186			WORD_LIST *list;
187			{
188			usleep (atof (list->word->word) * 1e6);
189
190			return EXECUTION_SUCCESS;
191			}
192
193			char *usleep_doc[] = {
194			"sleep a (possibly fractional) number of seconds",
195			(char *)NULL
196			};
197
198			struct builtin usleep_struct = {
199			"usleep",
200			usleep_builtin,
201			BUILTIN_ENABLED,
202			usleep_doc,
203			"usleep time-in-fractional-seconds",
204			0
205			};
206
207			str2hex_builtin (list)
208			WORD_LIST *list;
209			{
210			char *p;
211
212			for (p = list->word->word; *p; p++)
213			printf ("%02x", *p);
214			puts ("\n");
215
216			return EXECUTION_SUCCESS;
217			}
218
219			char *str2hex_doc[] = {
220			"convert the first argument to a hex string",
221			(char *)NULL
222			};
223
224			struct builtin str2hex_struct = {
225			"str2hex",
226			str2hex_builtin,
227			BUILTIN_ENABLED,
228			str2hex_doc,
229			"str2hex string",
230			0
231			};
232
233			#if 0
234			havefunc_builtin (list)
235			WORD_LIST *list;
236			{
237			if(list && find_hash_item(list->word->word, shell_functions))
238			return EXECUTION_SUCCESS;
239			return EXECUTION_FAILURE;
240			}
241
242			char *havefunc_doc[] = {
243			"checks if argument is a shell function",
244			(char *)NULL
245			};
246
247			struct builtin havefunc_struct = {
248			"havefunc",
249			havefunc_builtin,
250			BUILTIN_ENABLED,
251			havefunc_doc,
252			"havefunc name",
253			0
254			};
255			#endif
256