What is the best practice to read / write certs over zephyr_console line for a modem. #67182

zafersn · 2024-01-03T23:46:20Z

zafersn
Jan 3, 2024

I have a python script that writes rootca certs and private keys from PC.

on the board side, first I just wanted to use a ready-to-use solution in zephyr to read data from uart. So I pick the uart_console getline example. that works good for at commands

but when I try to read certs, it doesn't work, corruptions occur and I have missed data bytes. So I was wondering how can I read all certs bytes(max 5000 bytes) and what is the best practice for this. it seems there is no ready to use solution in the zephyr for this and I have to tackle with this problem. am I correct?

here for example what I am writing from python script and what I am reading on the device side:

the cert I am writing from python.

I read from the board:

the other point is that see this first line I have from the board -----BEGIN CERTIFICATE-----afaDQTCCAimgAwIBAgITBmyfz5m/jAo54vB4ikPmljZbyjANBgkqhkiG9w0BAQsF

in the original cert -----BEGIN CERTIFICATE----- doesnt share the same line but in the eco it does.

Is there anyone who can shed some light on this issue?

cheers!

ndrs-pst · 2024-01-17T19:11:35Z

ndrs-pst
Jan 17, 2024

@zafersn, due to the console's limitations in handling a stream of data, there are two options for a workaround:

Lower the console baud rate to 19,200 or 9,600 bps.
Add a time interval between sending each character, e.g., 1 ms.

1 reply

zafersn Jan 17, 2024
Author

@ndrs-pst thanks for your reply. I think your suggestion here seems good enough and will work for someone who has to use uart console getline. But I dont think it is the best way to do that.

here is the code that I went by:
it is from the nrf at_host.c:
https://github.com/nrfconnect/sdk-nrf/blob/main/lib/at_host/at_host.c

#define CONFIG_AT_CMD_MAX_LEN 4096
/* Stack definition for AT host workqueue */
#define INIT_HANDLER_STACK_SIZE 2048
K_THREAD_STACK_DEFINE(init_handler_stack_area, INIT_HANDLER_STACK_SIZE);

static inline void write_uart_string(const char *str)
{
	if (IS_ENABLED(CONFIG_LOG_BACKEND_UART)) {
		LOG_RAW("%s", str);
		return;
	}

	/* Send characters until, but not including, null */
	for (size_t i = 0; str[i]; i++) {
		uart_poll_out(uart_dev, str[i]);
	}
}

static void response_handler(const char *response)
{
	/* Forward the data over UART */
	write_uart_string(response);
}

static void cmd_send(struct k_work *work)
{
	int               err;

	ARG_UNUSED(work);

    /* Sending through string format rather than raw buffer in case
     * the buffer contains characters that need to be escaped
     */
	// err = nrf_modem_at_cmd(at_buf, sizeof(at_buf), "%s", at_buf);
	// snprintf(at_buf, sizeof(at_buf), "%s\r", at_buf);
	// write_uart_string(at_buf);
	err = run_process(at_buf);
	if (err < 0) {
		LOG_ERR("Error while processing AT command: %d", err);
	}

	// write_uart_string(at_buf);
	at_buf_busy = false;
	uart_irq_rx_enable(uart_dev);
}

static void uart_rx_handler(uint8_t character)
{
	static bool inside_quotes;
	static size_t at_cmd_len;

	/* Handle control characters */
	switch (character) {
	case 0x08: /* Backspace. */
		/* Fall through. */
	case 0x7F: /* DEL character */
		if (at_cmd_len > 0) {
			at_cmd_len--;
		}
		return;
	}

	/* Handle termination characters, if outside quotes. */
	if (!inside_quotes) {
		switch (character) {
		case '\0':
			if (term_mode == MODE_NULL_TERM) {
				goto send;
			}
			LOG_WRN("Ignored null; would terminate string early.");
			return;
		case '\r':
			if (term_mode == MODE_CR) {
				goto send;
			}
			break;
		case '\n':
			if (term_mode == MODE_LF) {
				goto send;
			}
			if (term_mode == MODE_CR_LF &&
			    at_cmd_len > 0 &&
			    at_buf[at_cmd_len - 1] == '\r') {
				goto send;
			}
			break;
		}
	}

	/* Detect AT command buffer overflow, leaving space for null */
	if (at_cmd_len + 1 > sizeof(at_buf) - 1) {
		LOG_ERR("Buffer overflow, dropping '%c'\n", character);
		return;
	}

	/* Write character to AT buffer */
	at_buf[at_cmd_len] = character;
	at_cmd_len++;

	/* Handle special written character */
	if (character == '"') {
		inside_quotes = !inside_quotes;
	}

	return;
send:
	at_buf[at_cmd_len] = '\0'; /* Terminate the command string */

	/* Reset UART handler state */
	inside_quotes = false;
	at_cmd_len = 0;

	/* Check for the presence of one printable non-whitespace character */
	for (const char *c = at_buf;; c++) {
		if (*c > ' ') {
			break;
		} else if (*c == '\0') {
			return; /* Drop command, if it has no such character */
		}
	}

	/* Send the command, if there is one to send */
	if (at_buf[0]) {
		uart_irq_rx_disable(uart_dev); /* Stop UART to protect at_buf */
		at_buf_busy = true;
		k_work_submit_to_queue(&at_host_work_q, &cmd_send_work);
	}
}

static void isr(const struct device *dev, void *user_data)
{
	ARG_UNUSED(user_data);

	uint8_t character;

	uart_irq_update(dev);

	if (!uart_irq_rx_ready(dev)) {
		return;
	}

	/*
	 * Check that we are not sending data (buffer must be preserved then),
	 * and that a new character is available before handling each character
	 */
	while ((!at_buf_busy) &&
	       (uart_fifo_read(dev, &character, 1))) {
		uart_rx_handler(character);
	}
}

static int at_uart_init(const struct device *uart_dev)
{
	int err;
	uint8_t dummy;

	if (!device_is_ready(uart_dev)) {
		LOG_ERR("UART device not ready");
		return -ENODEV;
	}

	uint32_t start_time = k_uptime_get_32();

	/* Wait for the UART line to become valid */
	do {
		err = uart_err_check(uart_dev);
		if (err) {
			if (k_uptime_get_32() - start_time >
			    CONFIG_AT_HOST_UART_INIT_TIMEOUT) {
				LOG_ERR("UART check failed: %d. "
					"UART initialization timed out.", err);
				return -EIO;
			}

			LOG_INF("UART check failed: %d. "
				"Dropping buffer and retrying.", err);

			while (uart_fifo_read(uart_dev, &dummy, 1)) {
				/* Do nothing with the data */
			}
			k_sleep(K_MSEC(10));
		}
	} while (err);

	uart_irq_callback_set(uart_dev, isr);
	return err;
}
static int listen_comport(void)
{
	int err;
	enum term_modes mode = CONFIG_AT_HOST_TERMINATION;


	/* Choosing the termination mode */
	if (mode < MODE_COUNT) {
		term_mode = mode;
	} else {
		return -EINVAL;
	}

	/* Initialize the UART module */
	err = at_uart_init(uart_dev);
	if (err) {
		LOG_ERR("UART could not be initialized: %d", err);
		return -EFAULT;
	}

	k_work_init(&cmd_send_work, cmd_send);
	k_work_queue_start(&at_host_work_q, init_handler_stack_area,
			   K_THREAD_STACK_SIZEOF(init_handler_stack_area),
			   CONFIG_AT_HOST_THREAD_PRIO, NULL);
	uart_irq_rx_enable(uart_dev);

}

SYS_INIT(listen_comport, APPLICATION, CONFIG_APPLICATION_INIT_PRIORITY);

static int listen_comport(void)
{
	int err;
	enum term_modes mode = CONFIG_AT_HOST_TERMINATION;


	/* Choosing the termination mode */
	if (mode < MODE_COUNT) {
		term_mode = mode;
	} else {
		return -EINVAL;
	}

	/* Initialize the UART module */
	err = at_uart_init(uart_dev);
	if (err) {
		LOG_ERR("UART could not be initialized: %d", err);
		return -EFAULT;
	}

	k_work_init(&cmd_send_work, cmd_send);
	k_work_queue_start(&at_host_work_q, init_handler_stack_area,
			   K_THREAD_STACK_SIZEOF(init_handler_stack_area),
			   CONFIG_AT_HOST_THREAD_PRIO, NULL);
	uart_irq_rx_enable(uart_dev);

}

SYS_INIT(listen_comport, APPLICATION, CONFIG_APPLICATION_INIT_PRIORITY);

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

What is the best practice to read / write certs over zephyr_console line for a modem. #67182

Uh oh!

{{title}}

Uh oh!

Uh oh!

{{editor}}'s edit

{{editor}}'s edit

Uh oh!

Replies: 1 comment 1 reply

Uh oh!

{{title}}

Uh oh!

Uh oh!

{{title}}

Uh oh!

Select a reply

Uh oh!

What is the best practice to read / write certs over zephyr_console line for a modem. #67182

Uh oh!

Uh oh!

zafersn Jan 3, 2024

Replies: 1 comment · 1 reply

Uh oh!

ndrs-pst Jan 17, 2024

Uh oh!

zafersn Jan 17, 2024 Author

zafersn
Jan 3, 2024

Replies: 1 comment 1 reply

ndrs-pst
Jan 17, 2024

zafersn Jan 17, 2024
Author