25627928901

Committed 10 May 2026 11:48AM UTC coverage: 90.902% (-0.1%) from 91.021%

Build # 25627928901

Build Type

Pull #149

github

Committed by

web-flow

Commit Message

Merge 19834788f into 2e508015b

Pull Request Pull Request #149: Implement PIV PIN-protected data objects

Coverage Stats

282 of 319 new or added lines in 4 files covered. (88.4%)

125 existing lines in 2 files now uncovered.

9182 of 10101 relevant lines covered (90.9%)

317289.16 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

84.15

/src/fs.c

// SPDX-License-Identifier: Apache-2.0
#include <fs.h>
#include <device.h>

static lfs_t lfs;

static alignas(4) uint8_t file_buffer[LFS_CACHE_SIZE];

static struct lfs_file_config file_config = {.buffer = file_buffer};

int fs_format(const struct lfs_config *cfg) { return lfs_format(&lfs, cfg); }

int fs_mount(const struct lfs_config *cfg) { return lfs_mount(&lfs, cfg); }

int read_file(const char *path, void *buf, lfs_soff_t off, lfs_size_t len) {
  lfs_file_t f;
  lfs_ssize_t read_length;
  int err = lfs_file_opencfg(&lfs, &f, path, LFS_O_RDONLY, &file_config);
  if (err < 0) return err;
  err = lfs_file_seek(&lfs, &f, off, LFS_SEEK_SET);
  if (err < 0) goto err_close;
  read_length = lfs_file_read(&lfs, &f, buf, len);
  if (read_length < 0) {
    err = read_length;
    goto err_close;
  }
  err = lfs_file_close(&lfs, &f);
  if (err < 0) return err;
  return read_length;

err_close:
  lfs_file_close(&lfs, &f);
  return err;
}

int write_file(const char *path, const void *buf, lfs_soff_t off, lfs_size_t len, uint8_t trunc) {
  lfs_file_t f;
#ifdef TEST
  if (testmode_err_triggered(path, true)) {
    return LFS_ERR_IO;
  }
#endif
  int flags = LFS_O_WRONLY | LFS_O_CREAT;
  if (trunc) flags |= LFS_O_TRUNC;
  int err = lfs_file_opencfg(&lfs, &f, path, flags, &file_config);
  if (err < 0) return err;
  err = lfs_file_seek(&lfs, &f, off, LFS_SEEK_SET);
  if (err < 0) goto err_close;
  if (len > 0) {
    err = lfs_file_write(&lfs, &f, buf, len);
    if (err < 0) goto err_close;
  }
  err = lfs_file_close(&lfs, &f);
  if (err < 0) return err;
  return 0;
err_close:
  lfs_file_close(&lfs, &f);
  return err;
}

int append_file(const char *path, const void *buf, lfs_size_t len) {
  lfs_file_t f;
  int err = lfs_file_opencfg(&lfs, &f, path, LFS_O_WRONLY | LFS_O_CREAT, &file_config);
  if (err < 0) return err;
  err = lfs_file_seek(&lfs, &f, 0, LFS_SEEK_END);
  if (err < 0) goto err_close;
  if (len > 0) {
    err = lfs_file_write(&lfs, &f, buf, len);
    if (err < 0) goto err_close;
  }
  err = lfs_file_close(&lfs, &f);
  if (err < 0) return err;
  return 0;
err_close:
  lfs_file_close(&lfs, &f);
  return err;
}

int truncate_file(const char *path, lfs_size_t len) {
  lfs_file_t f;
  int flags = LFS_O_WRONLY | LFS_O_CREAT;
  int err = lfs_file_opencfg(&lfs, &f, path, flags, &file_config);
  if (err < 0) return err;
  err = lfs_file_truncate(&lfs, &f, len);
  if (err < 0) goto err_close;
  err = lfs_file_close(&lfs, &f);
  if (err < 0) return err;
  return 0;
err_close:
  lfs_file_close(&lfs, &f);
  return err;
}

int read_attr(const char *path, uint8_t attr, void *buf, lfs_size_t len) {
  return lfs_getattr(&lfs, path, attr, buf, len);
}

int write_attr(const char *path, uint8_t attr, const void *buf, lfs_size_t len) {
  return lfs_setattr(&lfs, path, attr, buf, len);
}

int get_file_size(const char *path) {
  lfs_file_t f;
  int err = lfs_file_opencfg(&lfs, &f, path, LFS_O_RDONLY, &file_config);
  if (err < 0) return err;
  int size = lfs_file_size(&lfs, &f);
  if (size < 0) {
    err = size;
    goto err_close;
  }
  err = lfs_file_close(&lfs, &f);
  if (err < 0) return err;
  return size;
err_close:
  lfs_file_close(&lfs, &f);
  return err;
}

int get_fs_size(void) { return (int)(lfs.cfg->block_size * lfs.cfg->block_count) / 1024; }

int get_fs_usage(void) {
  int blocks = lfs_fs_size(&lfs);
  if (blocks < 0) return blocks;
  return (int)(lfs.cfg->block_size * blocks) / 1024;
}

int fs_rename(const char *old, const char *new) { return lfs_rename(&lfs, old, new); }

int remove_file(const char *path) { return lfs_remove(&lfs, path); }

1	// SPDX-License-Identifier: Apache-2.0
2	#include <fs.h>
3	#include <device.h>
4
5	static lfs_t lfs;
6
7	static alignas(4) uint8_t file_buffer[LFS_CACHE_SIZE];
8
9	static struct lfs_file_config file_config = {.buffer = file_buffer};
10
11	int fs_format(const struct lfs_config *cfg) { return lfs_format(&lfs, cfg); }	8✔
12
13	int fs_mount(const struct lfs_config *cfg) { return lfs_mount(&lfs, cfg); }	10✔
14
15	int read_file(const char path, void buf, lfs_soff_t off, lfs_size_t len) {
16	lfs_file_t f;	153,625✔
17	lfs_ssize_t read_length;
18	int err = lfs_file_opencfg(&lfs, &f, path, LFS_O_RDONLY, &file_config);	153,625✔
19	if (err < 0) return err;	153,625✔
20	err = lfs_file_seek(&lfs, &f, off, LFS_SEEK_SET);	153,622✔
21	if (err < 0) goto err_close;	153,622✔
22	read_length = lfs_file_read(&lfs, &f, buf, len);	153,621✔
23	if (read_length < 0) {	153,621✔
24	err = read_length;	×
25	goto err_close;	×
26	}
27	err = lfs_file_close(&lfs, &f);	153,621✔
28	if (err < 0) return err;	153,621✔
29	return read_length;	153,621✔
30
31	err_close:	1✔
32	lfs_file_close(&lfs, &f);	1✔
33	return err;	1✔
34	}
35
36	int write_file(const char path, const void buf, lfs_soff_t off, lfs_size_t len, uint8_t trunc) {
37	lfs_file_t f;	3,916✔
38	#ifdef TEST
39	if (testmode_err_triggered(path, true)) {	3,916✔
40	return LFS_ERR_IO;	6✔
41	}
42	#endif
43	int flags = LFS_O_WRONLY \| LFS_O_CREAT;	3,910✔
44	if (trunc) flags \|= LFS_O_TRUNC;	3,910✔
45	int err = lfs_file_opencfg(&lfs, &f, path, flags, &file_config);	3,910✔
46	if (err < 0) return err;	3,910✔
47	err = lfs_file_seek(&lfs, &f, off, LFS_SEEK_SET);	3,910✔
48	if (err < 0) goto err_close;	3,910✔
49	if (len > 0) {	3,909✔
50	err = lfs_file_write(&lfs, &f, buf, len);	3,450✔
51	if (err < 0) goto err_close;	3,450✔
52	}
53	err = lfs_file_close(&lfs, &f);	3,909✔
54	if (err < 0) return err;	3,909✔
55	return 0;	3,909✔
56	err_close:	1✔
57	lfs_file_close(&lfs, &f);	1✔
58	return err;	1✔
59	}
60
61	int append_file(const char path, const void buf, lfs_size_t len) {
62	lfs_file_t f;	256✔
63	int err = lfs_file_opencfg(&lfs, &f, path, LFS_O_WRONLY \| LFS_O_CREAT, &file_config);	256✔
64	if (err < 0) return err;	256✔
65	err = lfs_file_seek(&lfs, &f, 0, LFS_SEEK_END);	256✔
66	if (err < 0) goto err_close;	256✔
67	if (len > 0) {	256✔
68	err = lfs_file_write(&lfs, &f, buf, len);	256✔
69	if (err < 0) goto err_close;	256✔
70	}
71	err = lfs_file_close(&lfs, &f);	256✔
72	if (err < 0) return err;	256✔
73	return 0;	256✔
74	err_close:	×
75	lfs_file_close(&lfs, &f);	×
76	return err;	×
77	}
78
79	int truncate_file(const char *path, lfs_size_t len) {
80	lfs_file_t f;	10✔
81	int flags = LFS_O_WRONLY \| LFS_O_CREAT;	10✔
82	int err = lfs_file_opencfg(&lfs, &f, path, flags, &file_config);	10✔
83	if (err < 0) return err;	10✔
84	err = lfs_file_truncate(&lfs, &f, len);	10✔
85	if (err < 0) goto err_close;	10✔
86	err = lfs_file_close(&lfs, &f);	10✔
87	if (err < 0) return err;	10✔
88	return 0;	10✔
89	err_close:	×
90	lfs_file_close(&lfs, &f);	×
91	return err;	×
92	}
93
94	int read_attr(const char path, uint8_t attr, void buf, lfs_size_t len) {
95	return lfs_getattr(&lfs, path, attr, buf, len);	19,371✔
96	}
97
98	int write_attr(const char path, uint8_t attr, const void buf, lfs_size_t len) {
99	return lfs_setattr(&lfs, path, attr, buf, len);	4,163✔
100	}
101
102	int get_file_size(const char *path) {
103	lfs_file_t f;	8,639✔
104	int err = lfs_file_opencfg(&lfs, &f, path, LFS_O_RDONLY, &file_config);	8,639✔
105	if (err < 0) return err;	8,639✔
106	int size = lfs_file_size(&lfs, &f);	8,382✔
107	if (size < 0) {	8,382✔
UNCOV 108	err = size;	×
UNCOV 109	goto err_close;	×
110	}
111	err = lfs_file_close(&lfs, &f);	8,382✔
112	if (err < 0) return err;	8,382✔
113	return size;	8,382✔
UNCOV 114	err_close:	×
UNCOV 115	lfs_file_close(&lfs, &f);	×
UNCOV 116	return err;	×
117	}
118
119	int get_fs_size(void) { return (int)(lfs.cfg->block_size * lfs.cfg->block_count) / 1024; }	3✔
120
121	int get_fs_usage(void) {
122	int blocks = lfs_fs_size(&lfs);	3✔
123	if (blocks < 0) return blocks;	3✔
124	return (int)(lfs.cfg->block_size * blocks) / 1024;	3✔
125	}
126
127	int fs_rename(const char old, const char new) { return lfs_rename(&lfs, old, new); }	3✔
128
129	int remove_file(const char *path) { return lfs_remove(&lfs, path); }	518✔

canokeys / canokey-core / 25627928901

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous