rdline: save return status before paging, and return it once finished
[libcmdline.git] / src / lib / cmdline.c
1 /*-
2  * Copyright (c) <2010>, Intel Corporation
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  *
9  * - Redistributions of source code must retain the above copyright
10  *   notice, this list of conditions and the following disclaimer.
11  *
12  * - Redistributions in binary form must reproduce the above copyright
13  *   notice, this list of conditions and the following disclaimer in
14  *   the documentation and/or other materials provided with the
15  *   distribution.
16  *
17  * - Neither the name of Intel Corporation nor the names of its
18  *   contributors may be used to endorse or promote products derived
19  *   from this software without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
27  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
28  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
30  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
31  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
32  * OF THE POSSIBILITY OF SUCH DAMAGE.
33  */
34
35 /*
36  * Copyright (c) 2009, Olivier MATZ <zer0@droids-corp.org>
37  * All rights reserved.
38  * Redistribution and use in source and binary forms, with or without
39  * modification, are permitted provided that the following conditions are met:
40  *
41  *     * Redistributions of source code must retain the above copyright
42  *       notice, this list of conditions and the following disclaimer.
43  *     * Redistributions in binary form must reproduce the above copyright
44  *       notice, this list of conditions and the following disclaimer in the
45  *       documentation and/or other materials provided with the distribution.
46  *     * Neither the name of the University of California, Berkeley nor the
47  *       names of its contributors may be used to endorse or promote products
48  *       derived from this software without specific prior written permission.
49  *
50  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
51  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
52  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
53  * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
54  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
55  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
56  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
57  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
58  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
59  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
60  */
61
62 #include <stdio.h>
63 #include <string.h>
64 #include <unistd.h>
65 #include <stdlib.h>
66 #include <stdarg.h>
67 #include <inttypes.h>
68 #include <fcntl.h>
69 #include <termios.h>
70 #include <netinet/in.h>
71
72 #include "cmdline_parse.h"
73 #include "cmdline_rdline.h"
74 #include "cmdline.h"
75
76 static void
77 cmdline_default_valid_buffer(struct rdline *rdl, const char *buf,
78                              __attribute__((unused)) unsigned int size)
79 {
80         struct cmdline *cl = rdl->opaque;
81         int ret;
82         ret = cmdline_parse(cl->ctx, buf, cl);
83         if (ret == CMDLINE_PARSE_AMBIGUOUS)
84                 cmdline_printf(cl, "Ambiguous command\n");
85         else if (ret == CMDLINE_PARSE_NOMATCH)
86                 cmdline_printf(cl, "Bad arguments\n");
87         else if (ret == CMDLINE_PARSE_UNTERMINATED_QUOTE)
88                 cmdline_printf(cl, "Unterminated quote\n");
89 }
90
91 static int
92 cmdline_default_complete_buffer(struct rdline *rdl, const char *buf,
93                                 char *dstbuf, unsigned int dstsize)
94 {
95         struct cmdline *cl = rdl->opaque;
96         // RDLINE_RES_COMPLETE ?
97         return cmdline_complete(cl->ctx, buf, dstbuf, dstsize);
98 }
99
100
101 static int
102 cmdline_default_help(struct rdline *rdl, const char *buf,
103                      rdline_write_t *write_cb, void *write_arg)
104 {
105         struct cmdline *cl = rdl->opaque;
106         return cmdline_help(cl->ctx, buf, cmdline_write, write_arg);
107 }
108
109 /* ---- Some rdline wrappers ---- */
110
111 /* write a buffer, just use rdline */
112 ssize_t
113 cmdline_write(void *arg, void *buf, size_t count)
114 {
115         struct rdline *rdl = arg;
116 #ifdef NO_PAGER
117         return rdline_write(rdl, buf, count);
118 #else
119         return rdline_asyncpager_write(rdl, buf, count);
120 #endif
121 }
122
123 void
124 cmdline_set_prompt(struct cmdline *cl, const char *prompt)
125 {
126         snprintf(cl->prompt, sizeof(cl->prompt), "%s", prompt);
127 }
128
129 struct cmdline *
130 cmdline_new(cmdline_parse_ctx_t *ctx, const char *prompt, int s_in, int s_out)
131 {
132         struct cmdline *cl;
133
134         cl = malloc(sizeof(struct cmdline));
135         if (cl == NULL)
136                 return NULL;
137
138         /* init cmdline structure */
139         memset(cl, 0, sizeof(struct cmdline));
140         cl->s_in = s_in;
141         cl->s_out = s_out;
142         cl->ctx = ctx;
143
144         /* init embedded rdline */
145         rdline_init(&cl->rdl, s_in, s_out,
146                     cmdline_default_valid_buffer,
147                     cmdline_default_complete_buffer,
148                     cmdline_default_help);
149
150         cl->rdl.opaque = cl;
151         cmdline_set_prompt(cl, prompt);
152         rdline_newline(&cl->rdl, cl->prompt);
153
154         return cl;
155 }
156
157 void
158 cmdline_free(struct cmdline *cl)
159 {
160         dprintf("called\n");
161         if (cl->s_in > 2)
162                 close(cl->s_in);
163         if (cl->s_out != cl->s_in && cl->s_out > 2)
164                 close(cl->s_out);
165         free(cl);
166 }
167
168 int
169 cmdline_printf(const struct cmdline *cl, const char *fmt, ...)
170 {
171         va_list ap;
172         int ret;
173
174         va_start(ap, fmt);
175         ret = rdline_vprintf(&cl->rdl, fmt, ap);
176         va_end(ap);
177
178         return ret;
179 }
180
181 /* Push an input buffer in the command line. Typically, this function
182  * is called by cmdline_interact() to send the input characters to the
183  * cmdline process. It can also be called by a user callback function,
184  * when a buffer is received from the input socket.
185  *
186  * The function returns the number of processed characters, or a
187  * negative value on error (EOF reached or command line exited. */
188 int
189 cmdline_in(struct cmdline *cl, const char *buf, int size)
190 {
191         int ret = 0;
192         int i;
193
194         for (i = 0; i < size; i++) {
195                 ret = rdline_char_in(&cl->rdl, buf[i]);
196
197                 if (ret == RDLINE_RES_VALIDATED)
198                         rdline_newline(&cl->rdl, cl->prompt);
199                 else if (ret == RDLINE_RES_EOF)
200                         return -1;
201                 else if (ret == RDLINE_RES_EXITED)
202                         return -1;
203         }
204         return i;
205 }
206
207 /* Interrupt a running command line process */
208 void
209 cmdline_quit(struct cmdline *cl)
210 {
211         rdline_quit(&cl->rdl);
212 }
213
214 /* Start command line on configured file descriptor. This function
215  * loops until the user explicitelly call cmdline_quit(), or if the
216  * input fd reaches EOF. */
217 void
218 cmdline_interact(struct cmdline *cl)
219 {
220         char c;
221
222         c = -1;
223         while (1) {
224                 if (read(cl->s_in, &c, 1) < 0)
225                         break;
226                 if (cmdline_in(cl, &c, 1) < 0)
227                         break;
228         }
229 }