From 34e6eeef656a205d4f65f128cb17bc81cca3b4d3 Mon Sep 17 00:00:00 2001 From: Nikias Bassen Date: Tue, 11 Nov 2014 15:52:36 +0100 Subject: Move utils to convenience library --- common/Makefile.am | 10 ++ common/utils.c | 324 +++++++++++++++++++++++++++++++++++++++++++++++++++++ common/utils.h | 92 +++++++++++++++ 3 files changed, 426 insertions(+) create mode 100644 common/Makefile.am create mode 100644 common/utils.c create mode 100644 common/utils.h (limited to 'common') diff --git a/common/Makefile.am b/common/Makefile.am new file mode 100644 index 0000000..b4a65b9 --- /dev/null +++ b/common/Makefile.am @@ -0,0 +1,10 @@ +AM_CPPFLAGS = -I$(top_srcdir)/include -I$(top_srcdir) -I$(top_srcdir)/src + +AM_CFLAGS = $(GLOBAL_CFLAGS) $(libplist_CFLAGS) +AM_LDFLAGS = $(libplist_LIBS) + +noinst_LTLIBRARIES = libinternalcommon.la +libinternalcommon_la_LIBADD = +libinternalcommon_la_LDFLAGS = $(AM_LDFLAGS) -no-undefined +libinternalcommon_la_SOURCES = \ + utils.c utils.h diff --git a/common/utils.c b/common/utils.c new file mode 100644 index 0000000..ceb65e1 --- /dev/null +++ b/common/utils.c @@ -0,0 +1,324 @@ +/* + * utils.c + * + * Copyright (C) 2009 Hector Martin + * Copyright (C) 2009 Nikias Bassen + * Copyright (c) 2013 Federico Mena Quintero + * + * This library is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 2.1 of the + * License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#include +#include +#include +#include +#include +#include + +#include "utils.h" + +#include "log.h" +#define util_error(...) usbmuxd_log(LL_ERROR, __VA_ARGS__) + +void fdlist_create(struct fdlist *list) +{ + list->count = 0; + list->capacity = 4; + list->owners = malloc(sizeof(*list->owners) * list->capacity); + list->fds = malloc(sizeof(*list->fds) * list->capacity); +} +void fdlist_add(struct fdlist *list, enum fdowner owner, int fd, short events) +{ + if(list->count == list->capacity) { + list->capacity *= 2; + list->owners = realloc(list->owners, sizeof(*list->owners) * list->capacity); + list->fds = realloc(list->fds, sizeof(*list->fds) * list->capacity); + } + list->owners[list->count] = owner; + list->fds[list->count].fd = fd; + list->fds[list->count].events = events; + list->fds[list->count].revents = 0; + list->count++; +} + +void fdlist_free(struct fdlist *list) +{ + list->count = 0; + list->capacity = 0; + free(list->owners); + list->owners = NULL; + free(list->fds); + list->fds = NULL; +} + +void fdlist_reset(struct fdlist *list) +{ + list->count = 0; +} + +#define CAPACITY_STEP 8 + +void collection_init(struct collection *col) +{ + col->list = malloc(sizeof(void *) * CAPACITY_STEP); + memset(col->list, 0, sizeof(void *) * CAPACITY_STEP); + col->capacity = CAPACITY_STEP; +} + +void collection_free(struct collection *col) +{ + free(col->list); + col->list = NULL; + col->capacity = 0; +} + +void collection_add(struct collection *col, void *element) +{ + int i; + for(i=0; icapacity; i++) { + if(!col->list[i]) { + col->list[i] = element; + return; + } + } + col->list = realloc(col->list, sizeof(void*) * (col->capacity + CAPACITY_STEP)); + memset(&col->list[col->capacity], 0, sizeof(void *) * CAPACITY_STEP); + col->list[col->capacity] = element; + col->capacity += CAPACITY_STEP; +} + +void collection_remove(struct collection *col, void *element) +{ + int i; + for(i=0; icapacity; i++) { + if(col->list[i] == element) { + col->list[i] = NULL; + return; + } + } + util_error("collection_remove: element %p not present in collection %p (cap %d)", element, col, col->capacity); +} + +int collection_count(struct collection *col) +{ + int i, cnt = 0; + for(i=0; icapacity; i++) { + if(col->list[i]) + cnt++; + } + return cnt; +} + +void collection_copy(struct collection *dest, struct collection *src) +{ + if (!dest || !src) return; + dest->capacity = src->capacity; + dest->list = malloc(sizeof(void*) * src->capacity); + memcpy(dest->list, src->list, sizeof(void*) * src->capacity); +} + +#ifndef HAVE_STPCPY +/** + * Copy characters from one string into another + * + * @note: The strings should not overlap, as the behavior is undefined. + * + * @s1: The source string. + * @s2: The destination string. + * + * @return a pointer to the terminating `\0' character of @s1, + * or NULL if @s1 or @s2 is NULL. + */ +char *stpcpy(char * s1, const char * s2) +{ + if (s1 == NULL || s2 == NULL) + return NULL; + + strcpy(s1, s2); + + return s1 + strlen(s2); +} +#endif + +/** + * Concatenate strings into a newly allocated string + * + * @note: Specify NULL for the last string in the varargs list + * + * @str: The first string in the list + * @...: Subsequent strings. Use NULL for the last item. + * + * @return a newly allocated string, or NULL if @str is NULL. This will also + * return NULL and set errno to ENOMEM if memory is exhausted. + */ +char *string_concat(const char *str, ...) +{ + size_t len; + va_list args; + char *s; + char *result; + char *dest; + + if (!str) + return NULL; + + /* Compute final length */ + + len = strlen(str) + 1; /* plus 1 for the null terminator */ + + va_start(args, str); + s = va_arg(args, char *); + while (s) { + len += strlen(s); + s = va_arg(args, char*); + } + va_end(args); + + /* Concat each string */ + + result = malloc(len); + if (!result) + return NULL; /* errno remains set */ + + dest = result; + + dest = stpcpy(dest, str); + + va_start(args, str); + s = va_arg(args, char *); + while (s) { + dest = stpcpy(dest, s); + s = va_arg(args, char *); + } + va_end(args); + + return result; +} + +void buffer_read_from_filename(const char *filename, char **buffer, uint64_t *length) +{ + FILE *f; + uint64_t size; + + *length = 0; + + f = fopen(filename, "rb"); + if (!f) { + return; + } + + fseek(f, 0, SEEK_END); + size = ftell(f); + rewind(f); + + if (size == 0) { + fclose(f); + return; + } + + *buffer = (char*)malloc(sizeof(char)*(size+1)); + if (fread(*buffer, sizeof(char), size, f) != size) { + usbmuxd_log(LL_ERROR, "%s: ERROR: couldn't read %d bytes from %s", __func__, (int)size, filename); + } + fclose(f); + + *length = size; +} + +void buffer_write_to_filename(const char *filename, const char *buffer, uint64_t length) +{ + FILE *f; + + f = fopen(filename, "wb"); + if (f) { + fwrite(buffer, sizeof(char), length, f); + fclose(f); + } +} + +int plist_read_from_filename(plist_t *plist, const char *filename) +{ + char *buffer = NULL; + uint64_t length; + + if (!filename) + return 0; + + buffer_read_from_filename(filename, &buffer, &length); + + if (!buffer) { + return 0; + } + + if ((length > 8) && (memcmp(buffer, "bplist00", 8) == 0)) { + plist_from_bin(buffer, length, plist); + } else { + plist_from_xml(buffer, length, plist); + } + + free(buffer); + + return 1; +} + +int plist_write_to_filename(plist_t plist, const char *filename, enum plist_format_t format) +{ + char *buffer = NULL; + uint32_t length; + + if (!plist || !filename) + return 0; + + if (format == PLIST_FORMAT_XML) + plist_to_xml(plist, &buffer, &length); + else if (format == PLIST_FORMAT_BINARY) + plist_to_bin(plist, &buffer, &length); + else + return 0; + + buffer_write_to_filename(filename, buffer, length); + + free(buffer); + + return 1; +} + +void get_tick_count(struct timeval * tv) +{ + struct timespec ts; + if(0 == clock_gettime(CLOCK_MONOTONIC, &ts)) { + tv->tv_sec = ts.tv_sec; + tv->tv_usec = ts.tv_nsec / 1000; + } else { + gettimeofday(tv, NULL); + } +} + +/** + * Get number of milliseconds since the epoch. + */ +uint64_t mstime64(void) +{ + struct timeval tv; + get_tick_count(&tv); + + // Careful, avoid overflow on 32 bit systems + // time_t could be 4 bytes + return ((long long)tv.tv_sec) * 1000LL + ((long long)tv.tv_usec) / 1000LL; +} diff --git a/common/utils.h b/common/utils.h new file mode 100644 index 0000000..1137a93 --- /dev/null +++ b/common/utils.h @@ -0,0 +1,92 @@ +/* + * utils.h + * + * Copyright (C) 2009 Hector Martin + * Copyright (C) 2009 Nikias Bassen + * + * This library is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 2.1 of the + * License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef UTILS_H +#define UTILS_H + +#include +#include + +enum fdowner { + FD_LISTEN, + FD_CLIENT, + FD_USB +}; + +struct fdlist { + int count; + int capacity; + enum fdowner *owners; + struct pollfd *fds; +}; + +void fdlist_create(struct fdlist *list); +void fdlist_add(struct fdlist *list, enum fdowner owner, int fd, short events); +void fdlist_free(struct fdlist *list); +void fdlist_reset(struct fdlist *list); + +struct collection { + void **list; + int capacity; +}; + +void collection_init(struct collection *col); +void collection_add(struct collection *col, void *element); +void collection_remove(struct collection *col, void *element); +int collection_count(struct collection *col); +void collection_free(struct collection *col); +void collection_copy(struct collection *dest, struct collection *src); + +#define MERGE_(a,b) a ## _ ## b +#define LABEL_(a,b) MERGE_(a, b) +#define UNIQUE_VAR(a) LABEL_(a, __LINE__) + +#define FOREACH(var, col) \ + do { \ + int UNIQUE_VAR(_iter); \ + for(UNIQUE_VAR(_iter)=0; UNIQUE_VAR(_iter)<(col)->capacity; UNIQUE_VAR(_iter)++) { \ + if(!(col)->list[UNIQUE_VAR(_iter)]) continue; \ + var = (col)->list[UNIQUE_VAR(_iter)]; + +#define ENDFOREACH \ + } \ + } while(0); + +#ifndef HAVE_STPCPY +char *stpcpy(char * s1, const char * s2); +#endif +char *string_concat(const char *str, ...); + +void buffer_read_from_filename(const char *filename, char **buffer, uint64_t *length); +void buffer_write_to_filename(const char *filename, const char *buffer, uint64_t length); + +enum plist_format_t { + PLIST_FORMAT_XML, + PLIST_FORMAT_BINARY +}; + +int plist_read_from_filename(plist_t *plist, const char *filename); +int plist_write_to_filename(plist_t plist, const char *filename, enum plist_format_t format); + +uint64_t mstime64(void); +void get_tick_count(struct timeval * tv); + +#endif -- cgit v1.1-32-gdbae