-
Notifications
You must be signed in to change notification settings - Fork 0
/
ccnshell.c
170 lines (157 loc) · 5.79 KB
/
ccnshell.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/select.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include "linenoise.h"
void completion(const char *buf, linenoiseCompletions *lc)
{
if (buf[0] == 'h') {
linenoiseAddCompletion(lc, "hello");
linenoiseAddCompletion(lc, "hello there");
}
}
char *hints(const char *buf, int *color, int *bold)
{
if (!strcasecmp(buf, "hello")) {
*color = 35;
*bold = 0;
return " World";
}
return NULL;
}
int main(int argc, char **argv)
{
char *line;
char *prgname = argv[0];
int async = 0;
/* Parse options, with --multiline we enable multi line editing. */
while (argc > 1) {
argc--;
argv++;
if (!strcmp(*argv, "--multiline")) {
linenoiseSetMultiLine(1);
printf("Multi-line mode enabled.\n");
} else if (!strcmp(*argv, "--keycodes")) {
linenoisePrintKeyCodes();
exit(0);
} else if (!strcmp(*argv, "--async")) {
async = 1;
} else {
fprintf(stderr, "Usage: %s [--multiline] [--keycodes] [--async]\n",
prgname);
exit(1);
}
}
/* Set the completion callback. This will be called every time the
* user uses the <tab> key. */
linenoiseSetCompletionCallback(completion);
linenoiseSetHintsCallback(hints);
/* Load history from file. The history file is just a plain text file
* where entries are separated by newlines. */
linenoiseHistoryLoad("history.txt"); /* Load the history at startup */
/* Now this is the main loop of the typical linenoise-based application.
* The call to linenoise() will block as long as the user types something
* and presses enter.
*
* The typed string is returned as a malloc() allocated string by
* linenoise, so the user needs to free() it. */
while (1) {
if (!async) {
line = linenoise("CCNShell >> ");
if (line == NULL)
break;
} else {
/* Asynchronous mode using the multiplexing API: wait for
* data on stdin, and simulate async data coming from some source
* using the select(2) timeout. */
struct linenoiseState ls;
char buf[1024];
linenoiseEditStart(&ls, -1, -1, buf, sizeof(buf), "CCNShell >> ");
while (1) {
fd_set readfds;
struct timeval tv;
int retval;
FD_ZERO(&readfds);
FD_SET(ls.ifd, &readfds);
tv.tv_sec = 1; // 1 sec timeout
tv.tv_usec = 0;
retval = select(ls.ifd + 1, &readfds, NULL, NULL, &tv);
if (retval == -1) {
perror("select()");
exit(1);
} else if (retval) {
line = linenoiseEditFeed(&ls);
/* A NULL return means: line editing is continuing.
* Otherwise the user hit enter or stopped editing
* (CTRL+C/D). */
if (line != linenoiseEditMore)
break;
} else {
// Timeout occurred
static int counter = 0;
linenoiseHide(&ls);
printf("Async output %d.\n", counter++);
linenoiseShow(&ls);
}
}
linenoiseEditStop(&ls);
if (line == NULL)
exit(0); /* Ctrl+D/C. */
}
// TODO: Make it modular
/* Do something with the string. */
if (line[0] != '\0' && line[0] != '/') {
linenoiseHistoryAdd(line); /* Add to the history. */
linenoiseHistorySave("history.txt"); /* Save the history on disk. */
int itr = 0, arg_idx = 1;
// At most 32 arguments. It will be copied to memory as argv for new
// process SO THE FIRST ONE SHOULD BE THE PATH OF EXECUTABLE (BY
// CONVENTION) This is weird. Who would use the first one? Every
// thing as sting is weird as well.....
char *args[32];
char *envp[] = {NULL};
char path[128] = "/usr/bin/";
memset(args, 0, 32 * sizeof(char *));
// TODO: should trim trailing spaces first
args[0] = line;
while (line[itr + 1] != '\0') {
if (line[itr] == ' ') {
line[itr] = '\0';
args[arg_idx] = line + itr + 1;
arg_idx++;
}
itr++;
}
// FIXME: C-c sends signale to both parent and child, resulting
// ending both
pid_t pid = fork();
if (pid == -1) {
printf("failed to fork\n");
} else if (pid > 0) {
int status;
waitpid(pid, &status, 0);
} else {
execve(strncat(path, line, 127 - 9), args, envp);
fprintf(stderr, "|| Failed to execute '%s': %s ||\n", line,
strerror(errno));
exit(EXIT_FAILURE); // What is the difference with _exit()?
}
} else if (!strncmp(line, "/historylen", 11)) {
/* The "/historylen" command will change the history len. */
int len = atoi(line + 11);
linenoiseHistorySetMaxLen(len);
} else if (!strncmp(line, "/mask", 5)) {
linenoiseMaskModeEnable();
} else if (!strncmp(line, "/unmask", 7)) {
linenoiseMaskModeDisable();
} else if (line[0] == '/') {
printf("Unreconized command: %s\n", line);
}
free(line);
}
return 0;
}