Debian Codegraph @

tcl/c++/tests/basic_tcl_test.cc

raw
1 //
2 // Copyright 2021 Corey Minyard
3 //
4 // SPDX-License-Identifier: GPL-2.0-only
5
6 #include <iostream>
7 #include <string>
8 #include <cstring>
9 #include <gensio/gensio>
10 #include <gensio/gensiotcl>
11
12 using namespace std;
13 using namespace gensios;
14
15 class Open_Done: public Gensio_Open_Done {
16 public:
17 Open_Done(Waiter *w) { waiter = w; }
18 const char *get_err() { return errstr; }
19
20 private:
21
22 const char *errstr = NULL;
23
24 void open_done(int err) override {
25 if (err)
26 errstr = gensio_err_to_str(err);
27 waiter->wake();
28 }
29
30 Waiter *waiter;
31 };
32
33 class Close_Done: public Gensio_Close_Done {
34 public:
35 Close_Done(Waiter *w) { waiter = w; }
36
37 void set_gensio(Gensio *g) { io = g; }
38
39 private:
40 Gensio *io;
41
42 void close_done() override {
43 io->free();
44 }
45
46 Waiter *waiter;
47 };
48
49 class Client_Event: public Event {
50 public:
51 Client_Event(Waiter *w, const unsigned char *data, gensiods datalen): ce(w)
52 {
53 waiter = w;
54 this->data = data;
55 this->datalen = datalen;
56 }
57
58 void set_gensio(Gensio *g) { io = g; ce.set_gensio(g); }
59
60 const char *get_err() { return errstr; }
61
62 private:
63 Gensio *io;
64
65 gensiods read(int err, SimpleUCharVector idata,
66 const char *const *auxdata) override
67 {
68 if (err) {
69 errstr = gensio_err_to_str(err);
70 io->set_read_callback_enable(false);
71 io->set_write_callback_enable(false);
72 io->close(&ce);
73 return 0;
74 }
75
76 string str((char *) idata.data(), idata.size());
77
78 if (readpos + idata.size() > datalen) {
79 errstr = "Too much data";
80 io->set_read_callback_enable(false);
81 io->set_write_callback_enable(false);
82 io->close(&ce);
83 return idata.size();
84 }
85
86 if (memcmp(data + readpos, idata.data(), idata.size()) != 0) {
87 errstr = "Data mismatch";
88 io->set_read_callback_enable(false);
89 io->set_write_callback_enable(false);
90 io->close(&ce);
91 return idata.size();
92 }
93
94 readpos += idata.size();
95 if (readpos == datalen) {
96 io->set_read_callback_enable(false);
97 io->close(&ce);
98 }
99 return idata.size();
100 }
101
102 void write_ready() override
103 {
104 gensiods count;
105
106 try {
107 count = io->write(data + writepos, datalen - writepos, NULL);
108 } catch (gensio_error e) {
109 errstr = e.what();
110 io->set_read_callback_enable(false);
111 io->set_write_callback_enable(false);
112 io->close(&ce);
113 return;
114 }
115
116 writepos += count;
117 if (writepos == datalen)
118 io->set_write_callback_enable(false);
119 }
120
121 void freed() override {
122 waiter->wake();
123 }
124
125 const char *errstr = NULL;
126
127 const unsigned char *data;
128 gensiods datalen;
129 gensiods readpos = 0;
130 gensiods writepos = 0;
131
132 Close_Done ce;
133
134 Waiter *waiter;
135 };
136
137 static int
138 do_client_test(Os_Funcs &o, string ios)
139 {
140 Waiter w(o);
141 Gensio *g;
142 string s("This is a test!\r\n");
143 Open_Done oe(&w);
144 Client_Event e(&w, (unsigned char *) s.c_str(), (gensiods) s.size());
145 const char *errstr;
146 gensio_time waittime = { 2, 0 };
147 int err;
148
149 g = gensio_alloc(ios, o, &e);
150 e.set_gensio(g);
151 try {
152 g->open(&oe);
153 } catch (gensio_error e) {
154 cerr << "Error opening '" << ios << "': " << e.what() << endl;
155 return 1;
156 }
157 err = w.wait(1, &waittime);
158 if (err) {
159 g->free();
160 cerr << "Error from open wait for '" << ios << "': " <<
161 gensio_err_to_str(err) << endl;
162 return 1;
163 }
164 errstr = oe.get_err();
165 if (errstr) {
166 g->free();
167 cerr << "Error from open for '" << ios << "': " << errstr << endl;
168 return 1;
169 }
170 g->set_read_callback_enable(true);
171 g->set_write_callback_enable(true);
172 waittime = { 2, 0 };
173 err = w.wait(1, &waittime);
174 if (err) {
175 cerr << "Error from wait for '" << ios << "': " <<
176 gensio_err_to_str(err) << endl;
177 return 1;
178 }
179
180 errstr = e.get_err();
181 if (errstr) {
182 cerr << "Error handler '" << ios << "': " << errstr << endl;
183 return 1;
184 }
185 return 0;
186 }
187
188 class Server_Event: public Event {
189 public:
190 Server_Event(Waiter *w) { waiter = w; }
191
192 void set_gensio(Gensio *g) { io = g; }
193
194 const char *get_err() { return errstr; }
195
196 private:
197 Gensio *io;
198
199 gensiods read(int err, const SimpleUCharVector data,
200 const char *const *auxdata) override
201 {
202 gensiods count;
203
204 if (err) {
205 if (err != GE_REMCLOSE)
206 errstr = gensio_err_to_str(err);
207 io->set_read_callback_enable(false);
208 io->set_write_callback_enable(false);
209 io->free();
210 return 0;
211 }
212
213 try {
214 count = io->write(data, NULL);
215 } catch (gensio_error e) {
216 errstr = e.what();
217 io->set_read_callback_enable(false);
218 io->set_write_callback_enable(false);
219 io->free();
220 return data.size();
221 }
222
223 if (count < data.size()) {
224 io->set_read_callback_enable(false);
225 io->set_write_callback_enable(true);
226 }
227 return data.size();
228 }
229
230 void write_ready() override
231 {
232 io->set_read_callback_enable(true);
233 io->set_write_callback_enable(false);
234 }
235
236 void freed() override {
237 waiter->wake();
238 }
239
240 const char *errstr = NULL;
241
242 Waiter *waiter;
243 };
244
245 class Acc_Event: public Accepter_Event {
246 public:
247 Acc_Event(Waiter *w, Server_Event *e) { waiter = w; ev = e; }
248
249 void set_accepter(Accepter *a) { acc = a; }
250
251 private:
252 void log(enum gensio_log_levels level, const std::string log) override
253 {
254 std::cerr << "accepter " << gensio_log_level_to_str(level) <<
255 " log: " << log << std::endl;
256 }
257
258 void new_connection(Gensio *g) override
259 {
260 io = g;
261 ev->set_gensio(g);
262 g->set_event_handler(ev);
263 ev = NULL;
264 g->set_read_callback_enable(true);
265 g->set_write_callback_enable(true);
266 acc->free();
267 }
268
269 void freed() override
270 {
271 waiter->wake();
272 }
273
274 Accepter *acc;
275 Gensio *io;
276 Waiter *waiter;
277 Server_Event *ev;
278 };
279
280 static void
281 do_server_test(Os_Funcs &o, string ios)
282 {
283 Waiter w(o);
284 Accepter *a;
285 Server_Event e(&w);
286 Acc_Event ae(&w, &e);
287 const char *errstr;
288
289 a = gensio_acc_alloc(ios, o, &ae);
290 ae.set_accepter(a);
291 try {
292 a->startup();
293 } catch (gensio_error e) {
294 cerr << "Error opening '" << ios << "': " << e.what() << endl;
295 return;
296 }
297 cout << a->get_port() << endl;
298 a->set_callback_enable(true);
299 w.wait(2, NULL);
300
301 errstr = e.get_err();
302 if (errstr) {
303 cerr << "Server error handling '" << ios << "': " << errstr << endl;
304 }
305 }
306
307 // Internal gensio errors come in through this mechanism.
308 class Logger: public Os_Funcs_Log_Handler {
309 void log(enum gensio_log_levels level, const std::string log) override
310 {
311 std::cerr << "gensio " << gensio_log_level_to_str(level) <<
312 " log: " << log << std::endl;
313 }
314 };
315
316 class Sub_Event: public Event {
317 public:
318 Sub_Event(Waiter *w)
319 {
320 waiter = w;
321 }
322
323 void set_gensio(Gensio *g) { io = g; }
324
325 const char *get_err() { return errstr; }
326
327 string get_port() { return string(port, portpos); }
328
329 private:
330 Gensio *io;
331
332 gensiods read(int err, const SimpleUCharVector data,
333 const char *const *auxdata) override
334 {
335 gensiods i;
336
337 if (portfound) {
338 io->set_read_callback_enable(false);
339 return 0;
340 }
341
342 if (err) {
343 io->set_read_callback_enable(false);
344 waiter->wake();
345 errstr = "subprogram failed before reading port";
346 return 0;
347 }
348
349 for (i = 0; i < data.size(); i++) {
350 if (portpos >= sizeof(port)) {
351 errstr = "Port from sub too large";
352 waiter->wake();
353 io->set_read_callback_enable(false);
354 return i;
355 }
356 if (data[i] == '\n' || data[i] == '\r') {
357 port[portpos] = '\0';
358 portfound = true;
359 waiter->wake();
360 io->set_read_callback_enable(false);
361 return i;
362 }
363 port[portpos++] = data[i];
364 }
365 return i;
366 }
367
368 void write_ready() override {
369 io->set_write_callback_enable(false);
370 }
371
372 void freed() override
373 {
374 waiter->wake();
375 }
376
377 char port[100];
378 gensiods portpos = 0;
379 bool portfound = false;
380
381 const char *errstr = NULL;
382 Waiter *waiter;
383 };
384
385 int main(int argc, char *argv[])
386 {
387 int err = 0;
388 Tcl_Os_Funcs o(new Logger);
389 const char *test = "mux,tcp,localhost,";
390 const char *errstr;
391
392 o.proc_setup();
393
394 if (argc > 1) {
395 do_server_test(o, argv[1]);
396 } else {
397 char *s;
398 string ios("stdio(noredir-stderr),");
399 string ioc(test);
400 Gensio *sub;
401 Waiter w(o);
402 Sub_Event se(&w);
403 gensio_time waittime = { 2, 0 };
404 int err2;
405 char buf[10];
406 gensiods len = sizeof(buf);
407
408 cout << "Starting subprogram to act as a server" << endl;
409 s = gensio_quote_string(o, argv[0]);
410 if (!s) {
411 cerr << "Out of memory duplicating argv[0]" << endl;
412 err = 1;
413 goto out;
414 }
415 ios += s;
416 gensio_os_funcs_zfree(o, s);
417 ios += " ";
418 ios += test;
419 ios += "0";
420 try {
421 sub = gensio_alloc(ios, o, &se);
422 } catch (gensio_error e) {
423 cerr << "Unable to open " << ios << ": " << e.what() << endl;
424 err = 1;
425 goto out;
426 }
427 se.set_gensio(sub);
428 sub->open_s();
429 sub->set_read_callback_enable(true);
430 err = w.wait(1, &waittime);
431 if (err) {
432 cerr << "Error from sub wait for '" << ios << "': " <<
433 gensio_err_to_str(err) << endl;
434 err = 1;
435 } else {
436 errstr = se.get_err();
437 if (errstr) {
438 cerr << "Unable to handle sub " << ios << ": " <<
439 errstr << endl;
440 err = 1;
441 } else {
442 ioc += se.get_port();
443 cout << "Connecting to " << ioc << endl;
444 err = do_client_test(o, ioc);
445 }
446 }
447 cout << "Closing sub program" << endl;
448 sub->close_s();
449 err2 = sub->control(0, true, GENSIO_CONTROL_EXIT_CODE, buf, &len);
450 if (err2) {
451 cerr << "Error getting exit code: " << gensio_err_to_str(err2)
452 << endl;
453 err = 1;
454 }
455 err2 = strtoul(buf, NULL, 0);
456 if (err2) {
457 cerr << "Error from subprogram: " << err2 << endl;
458 err = 1;
459 }
460 sub->free();
461 waittime = { 2, 0 };
462 err2 = w.wait(1, &waittime);
463 if (err2) {
464 cerr << "Error from sub wait for '" << ios << "': " <<
465 gensio_err_to_str(err2) << endl;
466 err = 1;
467 }
468 }
469
470 out:
471 if (!err)
472 cout << "Success!" << endl;
473 return err;
474 }