source: mainline/uspace/lib/display/src/disp_srv.c@ 3c54869

ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 3c54869 was cdd6fc9, checked in by Jiri Svoboda <jiri@…>, 3 years ago

Add missing replies in IPC error paths
  • Property mode set to 100644
File size: 14.8 KB
Line 
1/*
2 * Copyright (c) 2023 Jiri Svoboda
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 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * - The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29/** @addtogroup libdisplay
30 * @{
31 */
32/**
33 * @file
34 * @brief Display protocol server stub
35 */
36
37#include <disp_srv.h>
38#include <display/event.h>
39#include <display/info.h>
40#include <display/wndresize.h>
41#include <errno.h>
42#include <io/log.h>
43#include <ipc/display.h>
44#include <mem.h>
45#include <stdlib.h>
46#include <stddef.h>
47#include "../private/params.h"
48
49static void display_callback_create_srv(display_srv_t *srv, ipc_call_t *call)
50{
51 async_sess_t *sess = async_callback_receive(EXCHANGE_SERIALIZE);
52 if (sess == NULL) {
53 async_answer_0(call, ENOMEM);
54 return;
55 }
56
57 srv->client_sess = sess;
58 async_answer_0(call, EOK);
59}
60
61static void display_window_create_srv(display_srv_t *srv, ipc_call_t *icall)
62{
63 sysarg_t wnd_id;
64 ipc_call_t call;
65 display_wnd_params_enc_t eparams;
66 display_wnd_params_t params;
67 char *caption;
68 size_t size;
69 errno_t rc;
70
71 if (!async_data_write_receive(&call, &size)) {
72 async_answer_0(&call, EREFUSED);
73 async_answer_0(icall, EREFUSED);
74 return;
75 }
76
77 if (size != sizeof(display_wnd_params_enc_t)) {
78 async_answer_0(&call, EINVAL);
79 async_answer_0(icall, EINVAL);
80 return;
81 }
82
83 rc = async_data_write_finalize(&call, &eparams, size);
84 if (rc != EOK) {
85 async_answer_0(&call, rc);
86 async_answer_0(icall, rc);
87 return;
88 }
89
90 caption = calloc(eparams.caption_size + 1, 1);
91 if (caption == NULL) {
92 async_answer_0(icall, ENOMEM);
93 return;
94 }
95
96 if (!async_data_write_receive(&call, &size)) {
97 free(caption);
98 async_answer_0(&call, EREFUSED);
99 async_answer_0(icall, EREFUSED);
100 return;
101 }
102
103 if (size != eparams.caption_size) {
104 free(caption);
105 async_answer_0(&call, EINVAL);
106 async_answer_0(icall, EINVAL);
107 return;
108 }
109
110 rc = async_data_write_finalize(&call, caption, eparams.caption_size);
111 if (rc != EOK) {
112 free(caption);
113 async_answer_0(&call, rc);
114 async_answer_0(icall, rc);
115 return;
116 }
117
118 if (srv->ops->window_create == NULL) {
119 free(caption);
120 async_answer_0(icall, ENOTSUP);
121 return;
122 }
123
124 /* Decode the parameters from transport */
125 params.rect = eparams.rect;
126 params.caption = caption;
127 params.min_size = eparams.min_size;
128 params.pos = eparams.pos;
129 params.flags = eparams.flags;
130
131 rc = srv->ops->window_create(srv->arg, &params, &wnd_id);
132 async_answer_1(icall, rc, wnd_id);
133}
134
135static void display_window_destroy_srv(display_srv_t *srv, ipc_call_t *icall)
136{
137 sysarg_t wnd_id;
138 errno_t rc;
139
140 wnd_id = ipc_get_arg1(icall);
141
142 if (srv->ops->window_destroy == NULL) {
143 async_answer_0(icall, ENOTSUP);
144 return;
145 }
146
147 rc = srv->ops->window_destroy(srv->arg, wnd_id);
148 async_answer_0(icall, rc);
149}
150
151static void display_window_move_req_srv(display_srv_t *srv, ipc_call_t *icall)
152{
153 sysarg_t wnd_id;
154 ipc_call_t call;
155 gfx_coord2_t pos;
156 size_t size;
157 errno_t rc;
158
159 wnd_id = ipc_get_arg1(icall);
160
161 if (!async_data_write_receive(&call, &size)) {
162 async_answer_0(&call, EREFUSED);
163 async_answer_0(icall, EREFUSED);
164 return;
165 }
166
167 if (size != sizeof(gfx_coord2_t)) {
168 async_answer_0(&call, EINVAL);
169 async_answer_0(icall, EINVAL);
170 return;
171 }
172
173 rc = async_data_write_finalize(&call, &pos, size);
174 if (rc != EOK) {
175 async_answer_0(&call, rc);
176 async_answer_0(icall, rc);
177 return;
178 }
179
180 if (srv->ops->window_move_req == NULL) {
181 async_answer_0(icall, ENOTSUP);
182 return;
183 }
184
185 rc = srv->ops->window_move_req(srv->arg, wnd_id, &pos);
186 async_answer_0(icall, rc);
187}
188
189static void display_window_move_srv(display_srv_t *srv, ipc_call_t *icall)
190{
191 sysarg_t wnd_id;
192 ipc_call_t call;
193 gfx_coord2_t dpos;
194 size_t size;
195 errno_t rc;
196
197 wnd_id = ipc_get_arg1(icall);
198
199 if (!async_data_write_receive(&call, &size)) {
200 async_answer_0(&call, EREFUSED);
201 async_answer_0(icall, EREFUSED);
202 return;
203 }
204
205 if (size != sizeof(gfx_coord2_t)) {
206 async_answer_0(&call, EINVAL);
207 async_answer_0(icall, EINVAL);
208 return;
209 }
210
211 rc = async_data_write_finalize(&call, &dpos, size);
212 if (rc != EOK) {
213 async_answer_0(&call, rc);
214 async_answer_0(icall, rc);
215 return;
216 }
217
218 if (srv->ops->window_move == NULL) {
219 async_answer_0(icall, ENOTSUP);
220 return;
221 }
222
223 rc = srv->ops->window_move(srv->arg, wnd_id, &dpos);
224 async_answer_0(icall, rc);
225}
226
227static void display_window_get_pos_srv(display_srv_t *srv, ipc_call_t *icall)
228{
229 sysarg_t wnd_id;
230 ipc_call_t call;
231 gfx_coord2_t dpos;
232 size_t size;
233 errno_t rc;
234
235 wnd_id = ipc_get_arg1(icall);
236
237 if (srv->ops->window_get_pos == NULL) {
238 async_answer_0(icall, ENOTSUP);
239 return;
240 }
241
242 if (!async_data_read_receive(&call, &size)) {
243 async_answer_0(&call, EREFUSED);
244 async_answer_0(icall, EREFUSED);
245 return;
246 }
247
248 rc = srv->ops->window_get_pos(srv->arg, wnd_id, &dpos);
249 if (rc != EOK) {
250 async_answer_0(&call, rc);
251 async_answer_0(icall, rc);
252 return;
253 }
254
255 if (size != sizeof(gfx_coord2_t)) {
256 async_answer_0(&call, EINVAL);
257 async_answer_0(icall, EINVAL);
258 return;
259 }
260
261 rc = async_data_read_finalize(&call, &dpos, size);
262 if (rc != EOK) {
263 async_answer_0(&call, rc);
264 async_answer_0(icall, rc);
265 return;
266 }
267
268 async_answer_0(icall, EOK);
269}
270
271static void display_window_get_max_rect_srv(display_srv_t *srv,
272 ipc_call_t *icall)
273{
274 sysarg_t wnd_id;
275 ipc_call_t call;
276 gfx_rect_t rect;
277 size_t size;
278 errno_t rc;
279
280 wnd_id = ipc_get_arg1(icall);
281
282 if (srv->ops->window_get_max_rect == NULL) {
283 async_answer_0(icall, ENOTSUP);
284 return;
285 }
286
287 if (!async_data_read_receive(&call, &size)) {
288 async_answer_0(&call, EREFUSED);
289 async_answer_0(icall, EREFUSED);
290 return;
291 }
292
293 rc = srv->ops->window_get_max_rect(srv->arg, wnd_id, &rect);
294 if (rc != EOK) {
295 async_answer_0(&call, rc);
296 async_answer_0(icall, rc);
297 return;
298 }
299
300 if (size != sizeof(gfx_rect_t)) {
301 async_answer_0(&call, EINVAL);
302 async_answer_0(icall, EINVAL);
303 return;
304 }
305
306 rc = async_data_read_finalize(&call, &rect, size);
307 if (rc != EOK) {
308 async_answer_0(&call, rc);
309 async_answer_0(icall, rc);
310 return;
311 }
312
313 async_answer_0(icall, EOK);
314}
315
316static void display_window_resize_req_srv(display_srv_t *srv, ipc_call_t *icall)
317{
318 sysarg_t wnd_id;
319 ipc_call_t call;
320 display_wnd_rsztype_t rsztype;
321 gfx_coord2_t pos;
322 size_t size;
323 errno_t rc;
324
325 wnd_id = ipc_get_arg1(icall);
326 rsztype = (display_wnd_rsztype_t) ipc_get_arg2(icall);
327
328 if (!async_data_write_receive(&call, &size)) {
329 async_answer_0(&call, EREFUSED);
330 async_answer_0(icall, EREFUSED);
331 return;
332 }
333
334 if (size != sizeof(gfx_coord2_t)) {
335 async_answer_0(&call, EINVAL);
336 async_answer_0(icall, EINVAL);
337 return;
338 }
339
340 rc = async_data_write_finalize(&call, &pos, size);
341 if (rc != EOK) {
342 async_answer_0(&call, rc);
343 async_answer_0(icall, rc);
344 return;
345 }
346
347 if (srv->ops->window_resize_req == NULL) {
348 async_answer_0(icall, ENOTSUP);
349 return;
350 }
351
352 rc = srv->ops->window_resize_req(srv->arg, wnd_id, rsztype, &pos);
353 async_answer_0(icall, rc);
354}
355
356static void display_window_resize_srv(display_srv_t *srv, ipc_call_t *icall)
357{
358 sysarg_t wnd_id;
359 ipc_call_t call;
360 display_wnd_resize_t wresize;
361 size_t size;
362 errno_t rc;
363
364 wnd_id = ipc_get_arg1(icall);
365
366 if (!async_data_write_receive(&call, &size)) {
367 async_answer_0(&call, EREFUSED);
368 async_answer_0(icall, EREFUSED);
369 return;
370 }
371
372 if (size != sizeof(display_wnd_resize_t)) {
373 async_answer_0(&call, EINVAL);
374 async_answer_0(icall, EINVAL);
375 return;
376 }
377
378 rc = async_data_write_finalize(&call, &wresize, size);
379 if (rc != EOK) {
380 async_answer_0(&call, rc);
381 async_answer_0(icall, rc);
382 return;
383 }
384
385 if (srv->ops->window_resize == NULL) {
386 async_answer_0(icall, ENOTSUP);
387 return;
388 }
389
390 rc = srv->ops->window_resize(srv->arg, wnd_id, &wresize.offs,
391 &wresize.nrect);
392 async_answer_0(icall, rc);
393}
394
395static void display_window_minimize_srv(display_srv_t *srv, ipc_call_t *icall)
396{
397 sysarg_t wnd_id;
398 errno_t rc;
399
400 wnd_id = ipc_get_arg1(icall);
401
402 if (srv->ops->window_minimize == NULL) {
403 async_answer_0(icall, ENOTSUP);
404 return;
405 }
406
407 rc = srv->ops->window_minimize(srv->arg, wnd_id);
408 async_answer_0(icall, rc);
409}
410
411static void display_window_maximize_srv(display_srv_t *srv, ipc_call_t *icall)
412{
413 sysarg_t wnd_id;
414 errno_t rc;
415
416 wnd_id = ipc_get_arg1(icall);
417
418 if (srv->ops->window_maximize == NULL) {
419 async_answer_0(icall, ENOTSUP);
420 return;
421 }
422
423 rc = srv->ops->window_maximize(srv->arg, wnd_id);
424 async_answer_0(icall, rc);
425}
426
427static void display_window_unmaximize_srv(display_srv_t *srv, ipc_call_t *icall)
428{
429 sysarg_t wnd_id;
430 errno_t rc;
431
432 wnd_id = ipc_get_arg1(icall);
433
434 if (srv->ops->window_unmaximize == NULL) {
435 async_answer_0(icall, ENOTSUP);
436 return;
437 }
438
439 rc = srv->ops->window_unmaximize(srv->arg, wnd_id);
440 async_answer_0(icall, rc);
441}
442
443static void display_window_set_cursor_srv(display_srv_t *srv, ipc_call_t *icall)
444{
445 sysarg_t wnd_id;
446 display_stock_cursor_t cursor;
447 errno_t rc;
448
449 wnd_id = ipc_get_arg1(icall);
450 cursor = ipc_get_arg2(icall);
451
452 if (srv->ops->window_set_cursor == NULL) {
453 async_answer_0(icall, ENOTSUP);
454 return;
455 }
456
457 rc = srv->ops->window_set_cursor(srv->arg, wnd_id, cursor);
458 async_answer_0(icall, rc);
459}
460
461static void display_window_set_caption_srv(display_srv_t *srv,
462 ipc_call_t *icall)
463{
464 sysarg_t wnd_id;
465 ipc_call_t call;
466 char *caption;
467 size_t size;
468 errno_t rc;
469
470 wnd_id = ipc_get_arg1(icall);
471
472 if (!async_data_write_receive(&call, &size)) {
473 async_answer_0(&call, EREFUSED);
474 async_answer_0(icall, EREFUSED);
475 return;
476 }
477
478 caption = calloc(size + 1, 1);
479 if (caption == NULL) {
480 async_answer_0(&call, ENOMEM);
481 async_answer_0(icall, ENOMEM);
482 return;
483 }
484
485 rc = async_data_write_finalize(&call, caption, size);
486 if (rc != EOK) {
487 free(caption);
488 async_answer_0(&call, rc);
489 async_answer_0(icall, rc);
490 return;
491 }
492
493 if (srv->ops->window_set_caption == NULL) {
494 free(caption);
495 async_answer_0(icall, ENOTSUP);
496 return;
497 }
498
499 rc = srv->ops->window_set_caption(srv->arg, wnd_id, caption);
500 async_answer_0(icall, rc);
501 free(caption);
502}
503
504static void display_get_event_srv(display_srv_t *srv, ipc_call_t *icall)
505{
506 sysarg_t wnd_id;
507 display_wnd_ev_t event;
508 ipc_call_t call;
509 size_t size;
510 errno_t rc;
511
512 if (srv->ops->get_event == NULL) {
513 async_answer_0(icall, ENOTSUP);
514 return;
515 }
516
517 rc = srv->ops->get_event(srv->arg, &wnd_id, &event);
518 if (rc != EOK) {
519 async_answer_0(icall, rc);
520 return;
521 }
522
523 /* Transfer event data */
524 if (!async_data_read_receive(&call, &size)) {
525 async_answer_0(&call, EREFUSED);
526 async_answer_0(icall, EREFUSED);
527 return;
528 }
529
530 if (size != sizeof(event)) {
531 async_answer_0(icall, EREFUSED);
532 async_answer_0(&call, EREFUSED);
533 return;
534 }
535
536 rc = async_data_read_finalize(&call, &event, sizeof(event));
537 if (rc != EOK) {
538 async_answer_0(icall, rc);
539 async_answer_0(&call, rc);
540 return;
541 }
542
543 async_answer_1(icall, EOK, wnd_id);
544}
545
546static void display_get_info_srv(display_srv_t *srv, ipc_call_t *icall)
547{
548 display_info_t info;
549 ipc_call_t call;
550 size_t size;
551 errno_t rc;
552
553 if (srv->ops->get_info == NULL) {
554 async_answer_0(icall, ENOTSUP);
555 return;
556 }
557
558 /* Transfer information */
559 if (!async_data_read_receive(&call, &size)) {
560 async_answer_0(&call, EREFUSED);
561 async_answer_0(icall, EREFUSED);
562 return;
563 }
564
565 if (size != sizeof(info)) {
566 async_answer_0(icall, EREFUSED);
567 async_answer_0(&call, EREFUSED);
568 return;
569 }
570
571 rc = srv->ops->get_info(srv->arg, &info);
572 if (rc != EOK) {
573 async_answer_0(icall, rc);
574 async_answer_0(&call, rc);
575 return;
576 }
577
578 rc = async_data_read_finalize(&call, &info, sizeof(info));
579 if (rc != EOK) {
580 async_answer_0(icall, rc);
581 async_answer_0(&call, rc);
582 return;
583 }
584
585 async_answer_0(icall, EOK);
586}
587
588void display_conn(ipc_call_t *icall, display_srv_t *srv)
589{
590 /* Accept the connection */
591 async_accept_0(icall);
592
593 while (true) {
594 ipc_call_t call;
595
596 async_get_call(&call);
597 sysarg_t method = ipc_get_imethod(&call);
598
599 if (!method) {
600 /* The other side has hung up */
601 async_answer_0(&call, EOK);
602 break;
603 }
604
605 switch (method) {
606 case DISPLAY_CALLBACK_CREATE:
607 display_callback_create_srv(srv, &call);
608 break;
609 case DISPLAY_WINDOW_CREATE:
610 display_window_create_srv(srv, &call);
611 break;
612 case DISPLAY_WINDOW_DESTROY:
613 display_window_destroy_srv(srv, &call);
614 break;
615 case DISPLAY_WINDOW_MOVE_REQ:
616 display_window_move_req_srv(srv, &call);
617 break;
618 case DISPLAY_WINDOW_MOVE:
619 display_window_move_srv(srv, &call);
620 break;
621 case DISPLAY_WINDOW_GET_POS:
622 display_window_get_pos_srv(srv, &call);
623 break;
624 case DISPLAY_WINDOW_GET_MAX_RECT:
625 display_window_get_max_rect_srv(srv, &call);
626 break;
627 case DISPLAY_WINDOW_RESIZE_REQ:
628 display_window_resize_req_srv(srv, &call);
629 break;
630 case DISPLAY_WINDOW_RESIZE:
631 display_window_resize_srv(srv, &call);
632 break;
633 case DISPLAY_WINDOW_MINIMIZE:
634 display_window_minimize_srv(srv, &call);
635 break;
636 case DISPLAY_WINDOW_MAXIMIZE:
637 display_window_maximize_srv(srv, &call);
638 break;
639 case DISPLAY_WINDOW_UNMAXIMIZE:
640 display_window_unmaximize_srv(srv, &call);
641 break;
642 case DISPLAY_WINDOW_SET_CURSOR:
643 display_window_set_cursor_srv(srv, &call);
644 break;
645 case DISPLAY_WINDOW_SET_CAPTION:
646 display_window_set_caption_srv(srv, &call);
647 break;
648 case DISPLAY_GET_EVENT:
649 display_get_event_srv(srv, &call);
650 break;
651 case DISPLAY_GET_INFO:
652 display_get_info_srv(srv, &call);
653 break;
654 default:
655 async_answer_0(&call, ENOTSUP);
656 }
657 }
658
659 /* Hang up callback session */
660 if (srv->client_sess != NULL) {
661 async_hangup(srv->client_sess);
662 srv->client_sess = NULL;
663 }
664}
665
666/** Initialize display server structure
667 *
668 * @param srv Display server structure to initialize
669 */
670void display_srv_initialize(display_srv_t *srv)
671{
672 memset(srv, 0, sizeof(*srv));
673}
674
675/** Send 'pending' event to client.
676 *
677 * @param srv Display server structure
678 */
679void display_srv_ev_pending(display_srv_t *srv)
680{
681 async_exch_t *exch;
682
683 exch = async_exchange_begin(srv->client_sess);
684 async_msg_0(exch, DISPLAY_EV_PENDING);
685 async_exchange_end(exch);
686}
687
688/** @}
689 */
Note: See TracBrowser for help on using the repository browser.