linuxmsm/pd-mapper
0
0
Fork 0
mirror of https://github.com/linux-msm/pd-mapper.git synced 2026-02-25 13:12:10 -08:00
Code Issues Packages Projects Releases Wiki Activity

Compare commits

base: linuxmsm:master
Branches Tags
linuxmsm:master linuxmsm:json
linuxmsm:v1.1 linuxmsm:v1.0 linuxmsm:v0.0
..
compare: linuxmsm:json
Branches Tags
linuxmsm:master linuxmsm:json
linuxmsm:v1.1 linuxmsm:v1.0 linuxmsm:v0.0

2 Commits
master ... json

Author SHA1 Message Date
Bjorn Andersson
4f37097522 pd-mapper: Load JSON files 
Load mappings from JSON files instead of hard coding only the WLAN.

Signed-off-by: Bjorn Andersson <bjorn.andersson@linaro.org>
 2019-04-26 11:32:57 -07:00
Bjorn Andersson
d357527aa0 json: Introduce JSON parser 
Mappings are stored in JSON structured files, introduce a JSON parser to
load these.

Signed-off-by: Bjorn Andersson <bjorn.andersson@linaro.org>
 2019-04-26 00:21:45 -07:00
8 changed files with 16 additions and 758 deletions
Expand all files Collapse all files

11
Android.bp
View File

@@ -1,11 +0,0 @@
cc_binary {
name: "pd-mapper",
vendor: true,
srcs: [
"pd-mapper.c",
"assoc.c",
"json.c",
"servreg_loc.c",
],
shared_libs: ["libqrtr"],
}

22
Makefile
View File

@@ -1,29 +1,19 @@
PD_MAPPER := pd-mapper PD_MAPPER := pd-mapper
CFLAGS += -Wall -g -O2 CFLAGS := -Wall -g -O2
LDFLAGS += -lqrtr -llzma LDFLAGS := -lqrtr
prefix ?= /usr/local
bindir := $(prefix)/bin
servicedir := $(prefix)/lib/systemd/system
SRCS := pd-mapper.c \ SRCS := pd-mapper.c \
assoc.c \
json.c \ json.c \
servreg_loc.c \ servreg_loc.c
lzma_decomp.c
OBJS := $(SRCS:.c=.o) OBJS := $(SRCS:.c=.o)
$(PD_MAPPER): $(OBJS) $(PD_MAPPER): $(OBJS)
$(CC) -o $@ $^ $(LDFLAGS) $(CC) -o $@ $^ $(LDFLAGS)
pd-mapper.service: pd-mapper.service.in install: $(PD_MAPPER)
@sed 's+PD_MAPPER_PATH+$(bindir)+g' $< > $@ install -D -m 755 $< $(DESTDIR)$(prefix)/bin/$<
install: $(PD_MAPPER) pd-mapper.service
@install -D -m 755 $(PD_MAPPER) $(DESTDIR)$(bindir)/$(PD_MAPPER)
@install -D -m 644 pd-mapper.service $(DESTDIR)$(servicedir)/pd-mapper.service
clean: clean:
rm -f $(PD_MAPPER) $(OBJS) pd-mapper.service rm -f $(PD_MAPPER) $(OBJS)

158
assoc.c
View File

@@ -1,158 +0,0 @@
/*
* Copyright (c) 2013, Bjorn Andersson <bjorn@kryo.se>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its contributors
* may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "assoc.h"
static unsigned long assoc_hash(const char *value)
{
unsigned long hash = 0;
unsigned long g;
const char *v = value;
while (*v) {
hash = (hash << 4) + *(v++);
g = hash & 0xF0000000L;
if (g)
hash ^= g >> 24;
hash &= ~g;
}
return hash;
}
void assoc_init(struct assoc *assoc, unsigned long size)
{
assert(size > 0);
assoc->size = size;
assoc->fill = 0;
assoc->keys = calloc(size, sizeof(const char *));
assoc->values = malloc(size * sizeof(void *));
}
void *assoc_get(struct assoc *assoc, const char *key)
{
unsigned long hash;
hash = assoc_hash(key) % assoc->size;
while (assoc->keys[hash]) {
if (!strcmp(assoc->keys[hash], key))
return assoc->values[hash];
hash = (hash + 1) % assoc->size;
}
return NULL;
}
static void _assoc_set(struct assoc *assoc, const char *key, void *value)
{
struct assoc new_set;
unsigned long hash;
unsigned long i;
assert(assoc->fill < assoc->size);
/* Grow set at 80% utilization */
if (5 * assoc->fill > 4 * assoc->size) {
assoc_init(&new_set, assoc->size * 5 / 4);
for (i = 0; i < assoc->size; i++)
if (assoc->keys[i])
assoc_set(&new_set, assoc->keys[i],
assoc->values[i]);
free(assoc->keys);
free(assoc->values);
assoc->keys = new_set.keys;
assoc->values = new_set.values;
assoc->fill = new_set.fill;
assoc->size = new_set.size;
}
hash = assoc_hash(key) % assoc->size;
while (assoc->keys[hash]) {
if (!strcmp(assoc->keys[hash], key)) {
assoc->values[hash] = value;
return;
}
hash = (hash + 1) % assoc->size;
}
assoc->keys[hash] = key;
assoc->values[hash] = value;
assoc->fill++;
}
void assoc_set(struct assoc *assoc, const char *key, void *value)
{
_assoc_set(assoc, strdup(key), value);
}
const char *assoc_next(struct assoc *assoc, void **value, unsigned long *iter)
{
unsigned long it = *iter;
while (it < assoc->size && !assoc->keys[it])
it++;
if (it == assoc->size)
return NULL;
*iter = it + 1;
if (it < assoc->size) {
if (value)
*value = assoc->values[it];
return assoc->keys[it];
} else {
return NULL;
}
}
void assoc_destroy(struct assoc *assoc)
{
unsigned long i;
for (i = 0; i < assoc->size; i++)
free((void*)assoc->keys[i]);
free(assoc->keys);
free(assoc->values);
assoc->size = 0;
}

54
assoc.h
View File

@@ -1,54 +0,0 @@
/*
* Copyright (c) 2013, Bjorn Andersson <bjorn@kryo.se>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its contributors
* may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __ASSOC_H__
#define __ASSOC_H__
struct assoc {
unsigned long size;
unsigned long fill;
const char **keys;
void **values;
};
void assoc_init(struct assoc *assoc, unsigned long size);
void *assoc_get(struct assoc *assoc, const char *key);
void assoc_set(struct assoc *assoc, const char *key, void *value);
const char *assoc_next(struct assoc *assoc, void **value, unsigned long *iter);
void assoc_destroy(struct assoc *assoc);
#define assoc_foreach(key, value, assoc, iter) \
for ((iter) = 0, (key) = assoc_next((assoc), (value), &(iter)); \
(key); \
(key) = assoc_next((assoc), (value), &(iter)))
#endif

11
json.c
View File

@@ -32,7 +32,6 @@
#include <ctype.h> #include <ctype.h>
#include <errno.h> #include <errno.h>
#include <fcntl.h> #include <fcntl.h>
#include <lzma.h>
#include <stdarg.h> #include <stdarg.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
@@ -82,7 +81,7 @@ static int json_parse_string(struct json_value *value)
return 0; return 0;
} }
while ((ch = input()) && ch != '"' && b - buf < sizeof(buf) - 1) while ((ch = input()) && ch != '"')
*b++ = ch; *b++ = ch;
*b = '\0'; *b = '\0';
@@ -315,8 +314,6 @@ struct json_value *json_parse(const char *json)
return root; return root;
} }
extern int lzma_decomp(const char *file);
struct json_value *json_parse_file(const char *file) struct json_value *json_parse_file(const char *file)
{ {
struct json_value *root; struct json_value *root;
@@ -324,11 +321,7 @@ struct json_value *json_parse_file(const char *file)
int ret; int ret;
int fd; int fd;
if ((strlen(file) > 3) && !strcmp(&file[strlen(file)-3], ".xz"))
fd = lzma_decomp(file);
else
fd = open(file, O_RDONLY); fd = open(file, O_RDONLY);
if (fd < 0) { if (fd < 0) {
fprintf(stderr, "failed to open %s: %s\n", file, strerror(errno)); fprintf(stderr, "failed to open %s: %s\n", file, strerror(errno));
return NULL; return NULL;
@@ -357,7 +350,7 @@ struct json_value *json_parse_file(const char *file)
ret = json_parse_value(root); ret = json_parse_value(root);
if (ret != 1) { if (ret != 1) {
json_free(root); free(root);
return NULL; return NULL;
} }

287
lzma_decomp.c
View File

@@ -1,287 +0,0 @@
/*
* Original Author: Lasse Collin
* LZMA boilerplate decompression example.
*
* Imported to pd-mapper by Jeremy Linton
* who reworked the main() into lzma_decomp()
* which returns a FD to a decompressed/unlinked
* file.
*
* This file has been put into the public domain.
* You can do whatever you want with this file.
*
*/
#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <lzma.h>
static bool
init_decoder(lzma_stream *strm)
{
// Initialize a .xz decoder. The decoder supports a memory usage limit
// and a set of flags.
//
// The memory usage of the decompressor depends on the settings used
// to compress a .xz file. It can vary from less than a megabyte to
// a few gigabytes, but in practice (at least for now) it rarely
// exceeds 65 MiB because that's how much memory is required to
// decompress files created with "xz -9". Settings requiring more
// memory take extra effort to use and don't (at least for now)
// provide significantly better compression in most cases.
//
// Memory usage limit is useful if it is important that the
// decompressor won't consume gigabytes of memory. The need
// for limiting depends on the application. In this example,
// no memory usage limiting is used. This is done by setting
// the limit to UINT64_MAX.
//
// The .xz format allows concatenating compressed files as is:
//
// echo foo | xz > foobar.xz
// echo bar | xz >> foobar.xz
//
// When decompressing normal standalone .xz files, LZMA_CONCATENATED
// should always be used to support decompression of concatenated
// .xz files. If LZMA_CONCATENATED isn't used, the decoder will stop
// after the first .xz stream. This can be useful when .xz data has
// been embedded inside another file format.
//
// Flags other than LZMA_CONCATENATED are supported too, and can
// be combined with bitwise-or. See lzma/container.h
// (src/liblzma/api/lzma/container.h in the source package or e.g.
// /usr/include/lzma/container.h depending on the install prefix)
// for details.
lzma_ret ret = lzma_stream_decoder(
strm, UINT64_MAX, LZMA_CONCATENATED);
// Return successfully if the initialization went fine.
if (ret == LZMA_OK)
return true;
// Something went wrong. The possible errors are documented in
// lzma/container.h (src/liblzma/api/lzma/container.h in the source
// package or e.g. /usr/include/lzma/container.h depending on the
// install prefix).
//
// Note that LZMA_MEMLIMIT_ERROR is never possible here. If you
// specify a very tiny limit, the error will be delayed until
// the first headers have been parsed by a call to lzma_code().
const char *msg;
switch (ret) {
case LZMA_MEM_ERROR:
msg = "Memory allocation failed";
break;
case LZMA_OPTIONS_ERROR:
msg = "Unsupported decompressor flags";
break;
default:
// This is most likely LZMA_PROG_ERROR indicating a bug in
// this program or in liblzma. It is inconvenient to have a
// separate error message for errors that should be impossible
// to occur, but knowing the error code is important for
// debugging. That's why it is good to print the error code
// at least when there is no good error message to show.
msg = "Unknown error, possibly a bug";
break;
}
fprintf(stderr, "Error initializing the decoder: %s (error code %u)\n",
msg, ret);
return false;
}
static bool
decompress(lzma_stream *strm, const char *inname, FILE *infile, int outfile)
{
// When LZMA_CONCATENATED flag was used when initializing the decoder,
// we need to tell lzma_code() when there will be no more input.
// This is done by setting action to LZMA_FINISH instead of LZMA_RUN
// in the same way as it is done when encoding.
//
// When LZMA_CONCATENATED isn't used, there is no need to use
// LZMA_FINISH to tell when all the input has been read, but it
// is still OK to use it if you want. When LZMA_CONCATENATED isn't
// used, the decoder will stop after the first .xz stream. In that
// case some unused data may be left in strm->next_in.
lzma_action action = LZMA_RUN;
uint8_t inbuf[BUFSIZ];
uint8_t outbuf[BUFSIZ];
strm->next_in = NULL;
strm->avail_in = 0;
strm->next_out = outbuf;
strm->avail_out = sizeof(outbuf);
while (true) {
if (strm->avail_in == 0 && !feof(infile)) {
strm->next_in = inbuf;
strm->avail_in = fread(inbuf, 1, sizeof(inbuf),
infile);
if (ferror(infile)) {
fprintf(stderr, "%s: Read error: %s\n",
inname, strerror(errno));
return false;
}
// Once the end of the input file has been reached,
// we need to tell lzma_code() that no more input
// will be coming. As said before, this isn't required
// if the LZMA_CONCATENATED flag isn't used when
// initializing the decoder.
if (feof(infile))
action = LZMA_FINISH;
}
lzma_ret ret = lzma_code(strm, action);
if (strm->avail_out == 0 || ret == LZMA_STREAM_END) {
size_t write_size = sizeof(outbuf) - strm->avail_out;
if (write(outfile, outbuf, write_size) != write_size) {
fprintf(stderr, "Write error: %s\n",
strerror(errno));
return false;
}
strm->next_out = outbuf;
strm->avail_out = sizeof(outbuf);
}
if (ret != LZMA_OK) {
// Once everything has been decoded successfully, the
// return value of lzma_code() will be LZMA_STREAM_END.
//
// It is important to check for LZMA_STREAM_END. Do not
// assume that getting ret != LZMA_OK would mean that
// everything has gone well or that when you aren't
// getting more output it must have successfully
// decoded everything.
if (ret == LZMA_STREAM_END)
return true;
// It's not LZMA_OK nor LZMA_STREAM_END,
// so it must be an error code. See lzma/base.h
// (src/liblzma/api/lzma/base.h in the source package
// or e.g. /usr/include/lzma/base.h depending on the
// install prefix) for the list and documentation of
// possible values. Many values listen in lzma_ret
// enumeration aren't possible in this example, but
// can be made possible by enabling memory usage limit
// or adding flags to the decoder initialization.
const char *msg;
switch (ret) {
case LZMA_MEM_ERROR:
msg = "Memory allocation failed";
break;
case LZMA_FORMAT_ERROR:
// .xz magic bytes weren't found.
msg = "The input is not in the .xz format";
break;
case LZMA_OPTIONS_ERROR:
// For example, the headers specify a filter
// that isn't supported by this liblzma
// version (or it hasn't been enabled when
// building liblzma, but no-one sane does
// that unless building liblzma for an
// embedded system). Upgrading to a newer
// liblzma might help.
//
// Note that it is unlikely that the file has
// accidentally became corrupt if you get this
// error. The integrity of the .xz headers is
// always verified with a CRC32, so
// unintentionally corrupt files can be
// distinguished from unsupported files.
msg = "Unsupported compression options";
break;
case LZMA_DATA_ERROR:
msg = "Compressed file is corrupt";
break;
case LZMA_BUF_ERROR:
// Typically this error means that a valid
// file has got truncated, but it might also
// be a damaged part in the file that makes
// the decoder think the file is truncated.
// If you prefer, you can use the same error
// message for this as for LZMA_DATA_ERROR.
msg = "Compressed file is truncated or "
"otherwise corrupt";
break;
default:
// This is most likely LZMA_PROG_ERROR.
msg = "Unknown error, possibly a bug";
break;
}
fprintf(stderr, "%s: Decoder error: "
"%s (error code %u)\n",
inname, msg, ret);
return false;
}
}
}
#define TEMP_TEMPLATE "/tmp/pd-mapperXXXXXX"
int lzma_decomp(const char *file)
{
int return_fd;
char temp_file[sizeof(TEMP_TEMPLATE)];
lzma_stream strm = LZMA_STREAM_INIT;
strcpy(temp_file, TEMP_TEMPLATE);
return_fd = mkstemp(temp_file);
if (return_fd < 0)
return return_fd;
unlink(temp_file);
// Try to decompress all files.
if (!init_decoder(&strm)) {
// Decoder initialization failed. There's no point
// to retry it so we need to exit.
close(return_fd);
return -1;
}
FILE *infile = fopen(file, "rb");
if (infile == NULL) {
fprintf(stderr, "%s: Error opening the input file: %s\n",
file, strerror(errno));
close(return_fd);
return_fd = -1;
} else {
if (!decompress(&strm, file, infile, return_fd)) {
close(return_fd);
return_fd = -1;
} else {
lseek(return_fd, 0, SEEK_SET);
}
fclose(infile);
}
// Free the memory allocated for the decoder. This only needs to be
// done after the last file.
lzma_end(&strm);
return return_fd;
}

216
pd-mapper.c
View File

@@ -28,21 +28,13 @@
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE. * POSSIBILITY OF SUCH DAMAGE.
*/ */
#include <sys/stat.h>
#include <sys/types.h>
#include <err.h>
#include <errno.h> #include <errno.h>
#include <dirent.h>
#include <fcntl.h>
#include <libgen.h>
#include <libqrtr.h> #include <libqrtr.h>
#include <limits.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <unistd.h> #include <unistd.h>
#include "assoc.h"
#include "json.h" #include "json.h"
#include "servreg_loc.h" #include "servreg_loc.h"
@@ -119,7 +111,7 @@ respond:
} }
} }
static int pd_load_map(const char *file) static int pd_maps_load(const char *file)
{ {
static int num_pd_maps; static int num_pd_maps;
struct json_value *sr_service; struct json_value *sr_service;
@@ -193,207 +185,6 @@ static int pd_load_map(const char *file)
return 0; return 0;
} }
static int concat_path(char *base_path, char *firmware_path, char *path, size_t path_len)
{
if (strlen(base_path) + 1 + strlen(firmware_path) + 1 >= path_len) {
warn("Path length exceeded %lu\n", path_len);
return -1;
}
strcpy(path, base_path);
strcat(path, "/");
strcat(path, firmware_path);
return 0;
}
#ifndef ANDROID
#define FIRMWARE_BASE "/lib/firmware/"
#define FIRMWARE_PARAM_PATH "/sys/module/firmware_class/parameters/path"
static DIR *opendir_firmware(char *firmware_path, char *out_path_opened, size_t out_path_size)
{
int ret = 0, n;
DIR *fw_dir = NULL;
int fw_param_path = open(FIRMWARE_PARAM_PATH, O_RDONLY);
char fw_sysfs_path[PATH_MAX];
if (fw_param_path < 0) {
warn("Cannot open sysfs path: %s", FIRMWARE_PARAM_PATH);
close(fw_param_path);
goto err;
}
n = read(fw_param_path, fw_sysfs_path, sizeof(char) * PATH_MAX);
close(fw_param_path);
if (n < 0) {
warn("Cannot read sysfs path: %s", FIRMWARE_PARAM_PATH);
goto err;
}
/* path not set in sysfs */
if (n <= 1)
goto err;
fw_sysfs_path[n - 1] = '\0';
ret = concat_path(fw_sysfs_path, firmware_path, out_path_opened, out_path_size);
if (ret)
goto err;
fw_dir = opendir(out_path_opened);
if (!fw_dir)
goto err;
return fw_dir;
err:
ret = concat_path(FIRMWARE_BASE, firmware_path, out_path_opened, out_path_size);
if (ret)
return fw_dir;
fw_dir = opendir(out_path_opened);
if (!fw_dir)
warn("Cannot open firmware path: %s", fw_sysfs_path);
return fw_dir;
}
#else
#define FIRMWARE_BASE "/vendor/firmware/"
DIR opendir_firmware(char *firmware_path)
{
return open_concat_path("/vendor/firmware/", firmware_path);
}
#endif
static char *known_extensions[] = {
".jsn.xz",
".jsn",
NULL,
};
static int pd_enumerate_jsons(struct assoc *json_set)
{
char firmware_value[PATH_MAX];
char *firmware_value_copy = NULL;
char *firmware_path = NULL;
char json_path[PATH_MAX];
char firmware_attr[32];
struct dirent *fw_de;
char path[PATH_MAX];
struct dirent *de;
int firmware_fd;
DIR *class_dir;
int class_fd;
DIR *fw_dir;
size_t len;
size_t n;
class_fd = open("/sys/class/remoteproc", O_RDONLY | O_DIRECTORY);
if (class_fd < 0) {
warn("failed to open remoteproc class");
return -1;
}
class_dir = fdopendir(class_fd);
if (!class_dir) {
warn("failed to opendir");
goto close_class;
}
while ((de = readdir(class_dir)) != NULL) {
if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, ".."))
continue;
if (strlen(de->d_name) + sizeof("/firmware") > sizeof(firmware_attr))
continue;
strcpy(firmware_attr, de->d_name);
strcat(firmware_attr, "/firmware");
firmware_fd = openat(class_fd, firmware_attr, O_RDONLY);
if (firmware_fd < 0)
continue;
n = read(firmware_fd, firmware_value, sizeof(firmware_value));
close(firmware_fd);
if (n < 0) {
continue;
}
firmware_value[n] = '\0';
/* dirname() function can (and will) modify the parameter, so make a copy */
firmware_value_copy = strdup(firmware_value);
firmware_path = dirname(firmware_value_copy);
fw_dir = opendir_firmware(firmware_path, path, sizeof(path));
if (!fw_dir)
continue;
while ((fw_de = readdir(fw_dir)) != NULL) {
int extens_index;
bool found = false;
if (!strcmp(fw_de->d_name, ".") || !strcmp(fw_de->d_name, ".."))
continue;
len = strlen(fw_de->d_name);
for (extens_index = 0; known_extensions[extens_index] != NULL; extens_index++) {
int extens_len = strlen(known_extensions[extens_index]);
if (len > extens_len &&
!strcmp(&fw_de->d_name[len - extens_len], known_extensions[extens_index])) {
found = true;
break;
}
}
if (!found)
continue;
if (strlen(path) + 1 + strlen(fw_de->d_name) + 1 > sizeof(json_path))
continue;
strcpy(json_path, path);
strcat(json_path, "/");
strcat(json_path, fw_de->d_name);
assoc_set(json_set, json_path, NULL);
}
closedir(fw_dir);
free(firmware_value_copy);
}
closedir(class_dir);
close_class:
close(class_fd);
return 0;
}
static int pd_load_maps(void)
{
struct assoc json_set;
unsigned long it;
const char *jsn;
int ret = 0;
assoc_init(&json_set, 20);
pd_enumerate_jsons(&json_set);
assoc_foreach(jsn, NULL, &json_set, it) {
ret = pd_load_map(jsn);
if (ret < 0)
break;
}
assoc_destroy(&json_set);
return ret;
}
int main(int argc, char **argv) int main(int argc, char **argv)
{ {
struct sockaddr_qrtr sq; struct sockaddr_qrtr sq;
@@ -403,10 +194,13 @@ int main(int argc, char **argv)
char buf[4096]; char buf[4096];
int ret; int ret;
int fd; int fd;
int i;
ret = pd_load_maps(); for (i = 1; i < argc; i++) {
ret = pd_maps_load(argv[i]);
if (ret) if (ret)
exit(1); exit(1);
}
if (!pd_maps) { if (!pd_maps) {
fprintf(stderr, "no pd maps available\n"); fprintf(stderr, "no pd maps available\n");

9
pd-mapper.service.in
View File

@@ -1,9 +0,0 @@
[Unit]
Description=Qualcomm PD mapper service
[Service]
ExecStart=PD_MAPPER_PATH/pd-mapper
Restart=always
[Install]
WantedBy=multi-user.target