1 /** 2 * Copyright © 2016 IBM Corporation 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #pragma once 18 19 #include <poll.h> 20 #include <stdbool.h> 21 #include <stdint.h> 22 #include <termios.h> /* for speed_t */ 23 #include <time.h> 24 #include <systemd/sd-bus.h> 25 #include <sys/time.h> 26 #include <sys/un.h> 27 28 struct console; 29 struct config; 30 31 /* Handler API. 32 * 33 * Console data handlers: these implement the functions that process 34 * data coming out of the main tty device. 35 * 36 * Handlers are registered at link time using the console_handler_register() 37 * macro. We call each handler's ->init() function at startup, and ->fini() at 38 * exit. 39 * 40 * Handlers will almost always want to register a ringbuffer consumer, which 41 * provides data coming from the tty. Use cosole_register_ringbuffer_consumer() 42 * for this. To send data to the tty, use console_data_out(). 43 * 44 * If a handler needs to monitor a separate file descriptor for events, use the 45 * poller API, through console_poller_register(). 46 */ 47 struct handler { 48 const char *name; 49 int (*init)(struct handler *handler, struct console *console, 50 struct config *config); 51 void (*fini)(struct handler *handler); 52 int (*baudrate)(struct handler *handler, speed_t baudrate); 53 bool active; 54 }; 55 56 /* NOLINTBEGIN(bugprone-reserved-identifier,cert-dcl37-c,cert-dcl51-cpp) */ 57 #define __handler_name(n) __handler_##n 58 #define _handler_name(n) __handler_name(n) 59 60 #define console_handler_register(h) \ 61 static const __attribute__((section("handlers"))) \ 62 __attribute__((used)) struct handler * \ 63 _handler_name(__COUNTER__) = h 64 /* NOLINTEND(bugprone-reserved-identifier,cert-dcl37-c,cert-dcl51-cpp) */ 65 66 int console_data_out(struct console *console, const uint8_t *data, size_t len); 67 68 /* poller API */ 69 struct poller; 70 71 enum poller_ret { 72 POLLER_OK = 0, 73 POLLER_REMOVE, 74 POLLER_EXIT, 75 }; 76 77 typedef enum poller_ret (*poller_event_fn_t)(struct handler *handler, 78 int revents, void *data); 79 typedef enum poller_ret (*poller_timeout_fn_t)(struct handler *handler, 80 void *data); 81 82 struct poller *console_poller_register(struct console *console, 83 struct handler *handler, 84 poller_event_fn_t poller_fn, 85 poller_timeout_fn_t timeout_fn, int fd, 86 int events, void *data); 87 88 void console_poller_unregister(struct console *console, struct poller *poller); 89 90 void console_poller_set_events(struct console *console, struct poller *poller, 91 int events); 92 93 void console_poller_set_timeout(struct console *console, struct poller *poller, 94 const struct timeval *tv); 95 96 /* ringbuffer API */ 97 98 enum ringbuffer_poll_ret { 99 RINGBUFFER_POLL_OK = 0, 100 RINGBUFFER_POLL_REMOVE, 101 }; 102 103 typedef enum ringbuffer_poll_ret (*ringbuffer_poll_fn_t)(void *data, 104 size_t force_len); 105 106 struct ringbuffer_consumer; 107 108 struct ringbuffer { 109 uint8_t *buf; 110 size_t size; 111 size_t tail; 112 struct ringbuffer_consumer **consumers; 113 int n_consumers; 114 }; 115 116 struct ringbuffer_consumer { 117 struct ringbuffer *rb; 118 ringbuffer_poll_fn_t poll_fn; 119 void *poll_data; 120 size_t pos; 121 }; 122 123 struct ringbuffer *ringbuffer_init(size_t size); 124 void ringbuffer_fini(struct ringbuffer *rb); 125 126 struct ringbuffer_consumer * 127 ringbuffer_consumer_register(struct ringbuffer *rb, 128 ringbuffer_poll_fn_t poll_fn, void *data); 129 130 void ringbuffer_consumer_unregister(struct ringbuffer_consumer *rbc); 131 132 int ringbuffer_queue(struct ringbuffer *rb, uint8_t *data, size_t len); 133 134 size_t ringbuffer_dequeue_peek(struct ringbuffer_consumer *rbc, size_t offset, 135 uint8_t **data); 136 137 int ringbuffer_dequeue_commit(struct ringbuffer_consumer *rbc, size_t len); 138 139 size_t ringbuffer_len(struct ringbuffer_consumer *rbc); 140 141 /* console wrapper around ringbuffer consumer registration */ 142 struct ringbuffer_consumer * 143 console_ringbuffer_consumer_register(struct console *console, 144 ringbuffer_poll_fn_t poll_fn, void *data); 145 146 /* config API */ 147 struct config; 148 const char *config_get_value(struct config *config, const char *name); 149 struct config *config_init(const char *filename); 150 void config_fini(struct config *config); 151 152 int config_parse_baud(speed_t *speed, const char *baud_string); 153 uint32_t parse_baud_to_int(speed_t speed); 154 speed_t parse_int_to_baud(uint32_t baud); 155 int config_parse_logsize(const char *size_str, size_t *size); 156 157 /* socket paths */ 158 ssize_t console_socket_path(struct sockaddr_un *addr, const char *id); 159 160 typedef char(socket_path_t)[sizeof(((struct sockaddr_un *)NULL)->sun_path)]; 161 ssize_t console_socket_path_readable(const struct sockaddr_un *addr, 162 size_t addrlen, socket_path_t path); 163 164 /* utils */ 165 int write_buf_to_fd(int fd, const uint8_t *buf, size_t len); 166 167 #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0])) 168 169 #ifndef offsetof 170 #define offsetof(type, member) ((unsigned long)&((type *)NULL)->member) 171 #endif 172 173 #define container_of(ptr, type, member) \ 174 ((type *)((void *)((ptr)-offsetof(type, member)))) 175 176 #define BUILD_ASSERT(c) \ 177 do { \ 178 char __c[(c) ? 1 : -1] __attribute__((unused)); \ 179 } while (0) 180