From 49acbab4774b6a9bdde34d6224b9812bea328c7c Mon Sep 17 00:00:00 2001
From: Kubat <mael.martin31@gmail.com>
Date: Tue, 12 May 2020 15:12:37 +0200
Subject: [PATCH] Try to not exceed the 80 chars limit for a lenght of a line
---
inc/common/macro.h | 2 +
src/cmd.c | 3 +-
src/common.c | 8 +--
src/config.c | 35 ++++++++-----
src/database/config.c | 31 +++++++-----
src/database/find.c | 35 ++++++++-----
src/database/open.c | 62 ++++++++++++++---------
src/database/playlist.c | 51 +++++++++++--------
src/database/queue.c | 103 ++++++++++++++++++++++++---------------
src/database/stickers.c | 16 +++---
src/database/update.c | 49 ++++++++++++-------
src/database/user.c | 9 ++--
src/mkv/write.c | 30 +++++++-----
src/module/module_sdl2.c | 62 ++++++++++++++---------
src/module/module_x11.c | 49 +++++++++++--------
src/module/repo.c | 94 +++++++++++++++++++++--------------
src/net/command.c | 8 ++-
src/net/listen.c | 21 +++++---
src/reg.c | 12 +++--
src/stack.c | 3 +-
src/uri.c | 3 +-
21 files changed, 430 insertions(+), 256 deletions(-)
diff --git a/inc/common/macro.h b/inc/common/macro.h
index 8b1b527e..1ba00aa1 100644
--- a/inc/common/macro.h
+++ b/inc/common/macro.h
@@ -167,3 +167,5 @@ typedef volatile enum {
#define STR_MATCH(str1, str2) (! strcasecmp(str1, str2))
#define STR_NMATCH(str1, str2, n) (! strncasecmp(str1, str2, n))
+
+#define sqlite3_column_chars BRACKETS_THAT(const char *) sqlite3_column_text
diff --git a/src/cmd.c b/src/cmd.c
index 70c5e9fa..d1a1893d 100644
--- a/src/cmd.c
+++ b/src/cmd.c
@@ -74,6 +74,7 @@ help:
help__();
not_exclusive:
- LOG_ERROR_SCT("COMMAND", "Failed to determine option, '%s' not exclusive", argv[0]);
+ LOG_ERROR_SCT("COMMAND", "Failed to determine option, '%s' not exclusive",
+ argv[0]);
exit(EXIT_FAILURE);
}
diff --git a/src/common.c b/src/common.c
index f31bff34..77cade84 100644
--- a/src/common.c
+++ b/src/common.c
@@ -11,7 +11,8 @@
void
__not_implemented(const char *func, char *file, int line)
{
- LOG_ERROR_SCT("GENERAL", "Function %s in file %s at line %d not implemented", func, file, line);
+ LOG_ERROR_SCT("GENERAL", "Function %s in file %s at line %d not "
+ "implemented", func, file, line);
abort();
}
@@ -145,7 +146,8 @@ safe_malloc(size_t size)
void *tmp;
tmp = malloc(size);
if (!tmp) {
- LOG_ERROR_SCT("GENERAL", "Out of memory, can't alloc '%ld' Bytes", size);
+ LOG_ERROR_SCT("GENERAL", "Out of memory, can't alloc "
+ "'%ld' Bytes", size);
exit(1);
}
return tmp;
@@ -163,7 +165,7 @@ int
read_self_exe(char *path, size_t len)
{
return ! (readlink(SELF_EXECUTABLE_LINUX, path, len - 1) > 0) ||
- (readlink(SELF_EXECUTABLE_FREEBSD, path, len - 1) > 0) ||
+ (readlink(SELF_EXECUTABLE_FREEBSD, path, len - 1) > 0) ||
(readlink(SELF_EXECUTABLE_SOLARIS, path, len - 1) > 0);
}
diff --git a/src/config.c b/src/config.c
index 3f2f016a..62cb5085 100644
--- a/src/config.c
+++ b/src/config.c
@@ -36,10 +36,13 @@ skip(char *s)
}
static int
-handler(volatile sqlite3 *user, const char *section, const char *name, const char *value)
+handler(volatile sqlite3 *user, const char *section, const char *name,
+ const char *value)
{
- RETURN_UNLESS(section && name && value, "I can't complete the database with incomplete lines", 1);
- RETURN_UNLESS(database_config_set(user, section, name, value), "Failed to update the database", 1);
+ RETURN_UNLESS(section && name && value,
+ "I can't complete the database with incomplete lines", 1);
+ RETURN_UNLESS(database_config_set(user, section, name, value),
+ "Failed to update the database", 1);
return 0;
}
@@ -77,7 +80,8 @@ ini_parse(const char *path, volatile sqlite3 *db)
else {
error = 1;
- LOG_ERROR_SCT("PARSER", "Invalid section name at line '%d'", linenum);
+ LOG_ERROR_SCT("PARSER", "Invalid section name at line '%d'",
+ linenum);
}
}
@@ -101,14 +105,16 @@ ini_parse(const char *path, volatile sqlite3 *db)
/* Handle the SECTION, NAME[:=]VALUE */
if (handler(db, section, name, value)) {
error = 1;
- LOG_ERROR_SCT("PARSER", "Failed to '[handle] %s, %s{:,=}%s' at line '%d'",
+ LOG_ERROR_SCT("PARSER", "Failed to '[handle] %s, "
+ "%s{:,=}%s' at line '%d'",
section, name, value, linenum);
}
}
else {
error = 1;
- LOG_ERROR_SCT("PARSER", "Invalid name[:=]value pair at line '%d'", linenum);
+ LOG_ERROR_SCT("PARSER", "Invalid name[:=]value pair at "
+ "line '%d'", linenum);
}
}
}
@@ -116,7 +122,8 @@ ini_parse(const char *path, volatile sqlite3 *db)
/* End of the function */
fclose(file);
if (error)
- LOG_ERROR_SCT("PARSER", "An error occured while parsing the file '%s'", path);
+ LOG_ERROR_SCT("PARSER", "An error occured while parsing the "
+ "file '%s'", path);
return error;
}
@@ -163,13 +170,15 @@ skip_this_strcat:
no_config_directory:
/* Try the '/opt/lektor' file. */
- memcpy(conf, "/opt/lektor/lektor.ini", sizeof("/opt/lektor/lektor.ini"));
+ memcpy(conf, "/opt/lektor/lektor.ini",
+ sizeof("/opt/lektor/lektor.ini"));
LOG_INFO("Trying %s", conf);
if (!access(conf, R_OK | F_OK))
goto found;
/* Try the '/usr/local/etc/lektor.ini' file. */
- memcpy(conf, "/usr/local/etc/lektor.ini", sizeof("/usr/local/etc/lektor.ini"));
+ memcpy(conf, "/usr/local/etc/lektor.ini",
+ sizeof("/usr/local/etc/lektor.ini"));
LOG_INFO("Trying %s", conf);
if (!access(conf, R_OK | F_OK))
goto found;
@@ -205,7 +214,7 @@ config_new(volatile sqlite3 *db, const char *conf)
return 0;
error:
- LOG_ERROR_SCT("CONFIG", "%s", "Errors detected in config, here is a default config:");
+ LOG_ERROR_SCT("CONFIG", "%s", "Errors detected, here is a default config");
config_default(stdout);
return 1;
}
@@ -222,8 +231,10 @@ config_open(volatile sqlite3 *db)
{
char conf_file[PATH_MAX];
int ret = 1;
- GOTO_IF(config_detect_file(conf_file, PATH_MAX), "Error while searching for a config file", error);
- GOTO_IF(config_new(db, conf_file), "Failed to read configuration file", error);
+ GOTO_IF(config_detect_file(conf_file, PATH_MAX),
+ "Error while searching for a config file", error);
+ GOTO_IF(config_new(db, conf_file),
+ "Failed to read configuration file", error);
ret = 0;
error:
return ret;
diff --git a/src/database/config.c b/src/database/config.c
index 07241a78..3c53210f 100644
--- a/src/database/config.c
+++ b/src/database/config.c
@@ -8,7 +8,8 @@
#include <string.h>
bool
-database_config_set(volatile sqlite3 *db, const char *section, const char *key, const char *value)
+database_config_set(volatile sqlite3 *db, const char *section, const char *key,
+ const char *value)
{
static const char *SQL_STMT =
"INSERT OR REPLACE INTO"
@@ -26,7 +27,8 @@ database_config_set(volatile sqlite3 *db, const char *section, const char *key,
code = sqlite3_step(stmt);
if (code != SQLITE_OK && code != SQLITE_DONE) {
- LOG_ERROR_SCT("DB", "Failed to insert or replace: %s", sqlite3_errmsg((sqlite3 *) db));
+ LOG_ERROR_SCT("DB", "Failed to insert or replace: %s",
+ sqlite3_errmsg((sqlite3 *) db));
goto error;
}
@@ -37,7 +39,8 @@ error:
}
bool
-database_config_get_text(volatile sqlite3 *db, const char *section, const char *key, char *value, size_t len)
+database_config_get_text(volatile sqlite3 *db, const char *section,
+ const char *key, char *value, size_t len)
{
static const char *SQL_STMT =
"SELECT value"
@@ -62,7 +65,8 @@ error:
}
bool
-database_config_exists(volatile sqlite3 *db, const char *section, const char *key)
+database_config_exists(volatile sqlite3 *db, const char *section,
+ const char *key)
{
static const char *SQL_STMT =
"SELECT value"
@@ -83,7 +87,8 @@ error:
}
bool
-database_config_get_int(volatile sqlite3 *db, const char *section, const char *key, int *value)
+database_config_get_int(volatile sqlite3 *db, const char *section,
+ const char *key, int *value)
{
static const char *SQL_STMT =
"SELECT CAST(value AS INTEGER)"
@@ -108,7 +113,8 @@ error:
bool
database_config_queue(volatile sqlite3 *db, const char *option, int value)
{
- static const char *SQL_STMT_TMP = "UPDATE queue_state SET %s = ? WHERE id = 42;";
+ static const char *SQL_STMT_TMP =
+ "UPDATE queue_state SET %s = ? WHERE id = 42;";
char SQL_STMT[LKT_MAX_SQLITE_STATEMENT];
sqlite3_stmt *stmt = 0;
bool ret = false;
@@ -137,7 +143,8 @@ error:
bool
database_get_config(volatile sqlite3 *db, const char *option, int *value)
{
- static const char *SQL_STMT_TMP = "SELECT %s FROM queue_state WHERE id = 42;";
+ static const char *SQL_STMT_TMP =
+ "SELECT %s FROM queue_state WHERE id = 42;";
char SQL_STMT[LKT_MAX_SQLITE_STATEMENT];
sqlite3_stmt *stmt = 0;
bool ret = false;
@@ -158,11 +165,11 @@ database_validate_conf(volatile sqlite3 *db)
const char *section;
#define section(_sct) section = _sct;
#define value_opt(name, value)
-#define value(name, value) \
- if (!database_config_exists(db, section, name)) { \
- LOG_ERROR_SCT("CONFIG", "Missing option \""name"\" in section \"%s\"", \
- section); \
- return false; \
+#define value(name, value) \
+ if (!database_config_exists(db, section, name)) { \
+ LOG_ERROR_SCT("CONFIG", "Missing option \""name"\" in section \"%s\"",\
+ section); \
+ return false; \
}
#include <lektor/config.inc>
#undef section
diff --git a/src/database/find.c b/src/database/find.c
index 5fbc5c46..41a1eac5 100644
--- a/src/database/find.c
+++ b/src/database/find.c
@@ -22,7 +22,8 @@ database_search_database_init(volatile sqlite3 *db, struct lkt_search *ret)
ret->type = lkt_search_database;
/* Search part */
- safe_snprintf(SQL_STMT, LKT_MAX_SQLITE_STATEMENT, SQL_STMT_TEMPLATE, ret->name, ret->msg_count, ret->continuation);
+ safe_snprintf(SQL_STMT, LKT_MAX_SQLITE_STATEMENT, SQL_STMT_TEMPLATE,
+ ret->name, ret->msg_count, ret->continuation);
SQLITE_PREPARE(db, ret->stmt, SQL_STMT, error);
SQLITE_BIND_TEXT(db, ret->stmt, 1, ret->ka_rgx, error);
ret->db = db;
@@ -35,7 +36,8 @@ error:
bool
database_search_sticker_init(volatile sqlite3 *db, struct lkt_search *ret)
{
- /* No bound checks in strcats, should be fine. Possible SQL injection, depend on the `type`. */
+ /* No bound checks in strcats, should be fine. Possible SQL injection,
+ depend on the `type`. */
static const char *SQL_all_types =
"SELECT name, sts.id, value FROM 'stickers' JOIN "
"( SELECT id, sticker, value, 'kara' FROM 'stickers.kara'"
@@ -78,7 +80,10 @@ database_search_queue_init(volatile sqlite3 *db, struct lkt_search *ret)
RETURN_UNLESS(ret, "Exit because return pointer is NULL", false);
static const char *SQL_STMT_TEMPLATE =
"WITH content AS ("
- " SELECT kara_id AS id, string AS any_col, LENGTH(CAST(kara_id AS TEXT)) AS len"
+ " SELECT"
+ " kara_id AS id,"
+ " string AS any_col,"
+ " LENGTH(CAST(kara_id AS TEXT)) AS len"
" FROM queue"
" JOIN kara "
" ON kara_id = kara.id AND %s LIKE ?)"
@@ -88,7 +93,8 @@ database_search_queue_init(volatile sqlite3 *db, struct lkt_search *ret)
ret->type = lkt_search_queue;
/* Search part */
- safe_snprintf(SQL_STMT, LKT_MAX_SQLITE_STATEMENT, SQL_STMT_TEMPLATE, ret->name, ret->msg_count, ret->continuation);
+ safe_snprintf(SQL_STMT, LKT_MAX_SQLITE_STATEMENT, SQL_STMT_TEMPLATE,
+ ret->name, ret->msg_count, ret->continuation);
SQLITE_PREPARE(db, ret->stmt, SQL_STMT, error);
SQLITE_BIND_TEXT(db, ret->stmt, 1, ret->ka_rgx, error);
ret->db = db;
@@ -104,14 +110,15 @@ database_search_iter(struct lkt_search *item)
const char *sql_row, *type;
int id, code, id_len;
RETURN_UNLESS(item, "Exit because item is NULL, end iterations", false);
- GOTO_UNLESS(item->call, "Call function is NULL, terminate the search", end);
+ GOTO_UNLESS(item->call, "NULL call function, terminate the search", end);
code = sqlite3_step(item->stmt);
if (code == SQLITE_DONE)
goto end;
if (code != SQLITE_ROW) {
- LOG_ERROR_SCT("DB", "Step failed, expected a ROW or a DONE: %s", sqlite3_errmsg((sqlite3 *) item->db));
+ LOG_ERROR_SCT("DB", "Step failed, expected a ROW or a DONE: %s",
+ sqlite3_errmsg((sqlite3 *) item->db));
goto end;
}
@@ -121,16 +128,18 @@ database_search_iter(struct lkt_search *item)
id = sqlite3_column_int(item->stmt, 0);
sql_row = (const char *) sqlite3_column_text(item->stmt, 1);
id_len = sqlite3_column_int(item->stmt, 2);
- return ((lkt_search_database_func) item->call)(item->srv, item->c, id, id_len, sql_row);
+ return ((lkt_search_database_func) item->call)
+ (item->srv, item->c, id, id_len, sql_row);
case lkt_search_sticker:
- sql_row = (const char *) sqlite3_column_text(item->stmt, 0); /* Name */
- id = sqlite3_column_int(item->stmt, 1); /* Id */
- code = sqlite3_column_int(item->stmt, 2); /* Value */
- type = (const char *) sqlite3_column_text(item->stmt, 3); /* Type */
- return ((lkt_search_sticker_func) item->call)(item->srv, item->c, sql_row, type, id, code);
+ sql_row = (const char *) sqlite3_column_text(item->stmt, 0); /* Name */
+ id = sqlite3_column_int(item->stmt, 1); /* Id */
+ code = sqlite3_column_int(item->stmt, 2); /* Val */
+ type = (const char *) sqlite3_column_text(item->stmt, 3); /* Type */
+ return ((lkt_search_sticker_func) item->call)
+ (item->srv, item->c, sql_row, type, id, code);
case lkt_search_playlist:
default:
- LOG_WARN_SCT("DB", "Search operation %d is not implemented", item->type);
+ LOG_WARN_SCT("DB", "Search type %d is not implemented", item->type);
goto end;
}
diff --git a/src/database/open.c b/src/database/open.c
index 3e09b743..dcaabf62 100644
--- a/src/database/open.c
+++ b/src/database/open.c
@@ -26,7 +26,8 @@ static inline void
__dec(volatile sqlite3 *db, const char *name)
{
char SQL[LKT_MAX_SQLITE_STATEMENT];
- safe_snprintf(SQL, LKT_MAX_SQLITE_STATEMENT, "UPDATE %s.misc SET opened = 0;", name);
+ safe_snprintf(SQL, LKT_MAX_SQLITE_STATEMENT,
+ "UPDATE %s.misc SET opened = 0;", name);
SQLITE_EXEC(db, SQL, error);
return;
error:
@@ -50,13 +51,15 @@ __close_databases(void)
static inline void
__inc(volatile sqlite3 *db, const char *name)
{
- SQLITE_EXEC(db, "UPDATE misc SET opened = (SELECT opened + 1 FROM misc);", error);
+ SQLITE_EXEC(db, "UPDATE misc SET opened = (SELECT opened + 1 FROM misc);",
+ error);
if (!atexited) {
atexited = 1;
if (stack_new(&db_stack))
goto out_of_memory;
if (atexit(__close_databases)) {
- LOG_ERROR_SCT("GENERAL", "%s", "Failed to set function in 'atexit'");
+ LOG_ERROR_SCT("GENERAL", "%s",
+ "Failed to set function in 'atexit'");
exit(EXIT_FAILURE);
}
struct named_db *item = malloc(sizeof(struct named_db));
@@ -86,14 +89,15 @@ is_sql_str_invalid(const char *str)
bool
database_new(volatile sqlite3 **db)
{
- static int flags = SQLITE_OPEN_READWRITE | /* Open in RW mode */
- SQLITE_OPEN_SHAREDCACHE | /* hHared cache for databases */
- SQLITE_OPEN_NOFOLLOW | /* Don't follow symlinks */
- SQLITE_OPEN_FULLMUTEX; /* Serialized */
- RETURN_IF(SQLITE_OK != sqlite3_enable_shared_cache(1), "Failed to enable shared cache", false);
- RETURN_IF(sqlite3_soft_heap_limit64(HEAP_LIMIT_SOFT) < 0, "Failed to set soft heap limit", false);
- RETURN_IF(sqlite3_hard_heap_limit64(HEAP_LIMIT_HARD) < 0, "Failed to set soft heap limit", false);
- RETURN_IF(SQLITE_OK != sqlite3_open_v2(":memory:", (sqlite3 **) db, flags, NULL), "Failed to open :memory:", false);
+ static int flags = SQLITE_OPEN_READWRITE |
+ SQLITE_OPEN_SHAREDCACHE |
+ SQLITE_OPEN_NOFOLLOW |
+ SQLITE_OPEN_FULLMUTEX;
+ if (SQLITE_OK != sqlite3_enable_shared_cache(1) ||
+ sqlite3_soft_heap_limit64(HEAP_LIMIT_SOFT) < 0 ||
+ sqlite3_hard_heap_limit64(HEAP_LIMIT_HARD) < 0 ||
+ SQLITE_OK != sqlite3_open_v2(":memory:", (sqlite3 **) db, flags, NULL))
+ return false;
SQLITE_EXEC(*db, (const char *) ___src_database_memory_sql, err_not_init);
return true;
err_not_init:
@@ -108,7 +112,8 @@ __attach(volatile sqlite3 *db, const char *name, const char *path)
char SQL_ATTACH[LKT_MAX_SQLITE_STATEMENT];
bool ret = false;
- safe_snprintf(SQL_ATTACH, LKT_MAX_SQLITE_STATEMENT, SQL_ATTACH_TEMPLATE, path, name);
+ safe_snprintf(SQL_ATTACH, LKT_MAX_SQLITE_STATEMENT, SQL_ATTACH_TEMPLATE,
+ path, name);
SQLITE_EXEC(db, SQL_ATTACH, err_no_attach);
LOG_INFO_SCT("DB", "Attached database '%s' with path '%s'", name, path);
ret = true;
@@ -123,7 +128,8 @@ __detach(volatile sqlite3 *db, const char *name)
char SQL_DETACH[LKT_MAX_SQLITE_STATEMENT];
bool ret = false;
- safe_snprintf(SQL_DETACH, LKT_MAX_SQLITE_STATEMENT, SQL_DETACH_TEMPLATE, name);
+ safe_snprintf(SQL_DETACH, LKT_MAX_SQLITE_STATEMENT,
+ SQL_DETACH_TEMPLATE, name);
SQLITE_EXEC(db, SQL_DETACH, err_no_detach);
LOG_INFO_SCT("DB", "Detached database '%s'", name);
ret = true;
@@ -154,7 +160,8 @@ error:
static inline bool
__is_attached(volatile sqlite3 *db, const char *name)
{
- static const char *SQL_STMT = "SELECT name FROM pragma_database_list WHERE name = ?;\n";
+ static const char *SQL_STMT =
+ "SELECT name FROM pragma_database_list WHERE name = ?;\n";
sqlite3_stmt *stmt = 0;
bool ret = false;
@@ -189,11 +196,13 @@ retry:
/* Need init */
init:
if (retry) {
- LOG_ERROR_SCT("DB", "Retry to init database '%s', this is an error", dbpath);
+ LOG_ERROR_SCT("DB", "Retry to init database '%s', this is an error",
+ dbpath);
return false;
}
retry = true;
- LOG_WARN_SCT("DB", "Database '%s' is not correctly initialized, init it", dbpath);
+ LOG_WARN_SCT("DB", "Database '%s' is not correctly initialized, init it",
+ dbpath);
__detach(db, PROTECTED_DATABASE) ;
if (database_init(dbpath))
goto retry;
@@ -206,8 +215,9 @@ init:
bool
database_attach(volatile sqlite3 *db, const char *name, const char *dbpath)
{
- RETURN_UNLESS(strcasecmp(PROTECTED_DATABASE, name), " The database "PROTECTED_DATABASE
- " is protected, can't attach a database with the same name", false);
+ RETURN_UNLESS(strcasecmp(PROTECTED_DATABASE, name), " The database "
+ PROTECTED_DATABASE " is protected, can't attach a "
+ "database with the same name", false);
if (is_sql_str_invalid(name)) {
LOG_ERROR("The database name '%s' is invalid", name);
@@ -220,7 +230,8 @@ database_attach(volatile sqlite3 *db, const char *name, const char *dbpath)
}
if (!__attach(db, name, dbpath)) {
- LOG_ERROR_SCT("DB", "Failed to attach database named '%s' with path '%s'", name, dbpath);
+ LOG_ERROR_SCT("DB", "Failed to attach database named '%s' with "
+ "path '%s'", name, dbpath);
return false;
}
@@ -231,8 +242,8 @@ database_attach(volatile sqlite3 *db, const char *name, const char *dbpath)
bool
database_detach(volatile sqlite3 *db, const char *name)
{
- RETURN_UNLESS(strcasecmp(PROTECTED_DATABASE, name), " The database "PROTECTED_DATABASE
- " is protected, can't detach it", false);
+ RETURN_UNLESS(strcasecmp(PROTECTED_DATABASE, name), " The database "
+ PROTECTED_DATABASE " is protected, can't detach it", false);
if (is_sql_str_invalid(name)) {
LOG_ERROR("The database name '%s' is invalid", name);
@@ -257,11 +268,14 @@ bool
database_init(const char *dbpath)
{
sqlite3 *db;
- GOTO_IF(SQLITE_OK != sqlite3_open(dbpath, &db), "Failed to open the database", error);
+ if (SQLITE_OK != sqlite3_open(dbpath, &db))
+ goto error;
SQLITE_EXEC(db, (const char *) ___src_database_disk_sql, error);
- LOG_INFO_SCT("DB", "Initialized the 'disk' database successfully, path was '%s'", dbpath);
+ LOG_INFO_SCT("DB", "Initialized the 'disk' database successfully, "
+ "path was '%s'", dbpath);
return true;
error:
- LOG_ERROR_SCT("DB", "Failed to init the 'disk' database, path was '%s'", dbpath);
+ LOG_ERROR_SCT("DB", "Failed to init the 'disk' database, path was '%s'",
+ dbpath);
return false;
}
diff --git a/src/database/playlist.c b/src/database/playlist.c
index b3d259ab..1c80ced4 100644
--- a/src/database/playlist.c
+++ b/src/database/playlist.c
@@ -13,7 +13,8 @@ bool
database_plt_create(volatile sqlite3 *db, const char *name)
{
static const char *SQL_STMT =
- "INSERT INTO playlist (name, last_update) VALUES (?, strftime('%s', 'now'));";
+ "INSERT INTO playlist (name, last_update) "
+ "VALUES (?, strftime('%s', 'now'));";
sqlite3_stmt *stmt = NULL;
bool sta = false;
SQLITE_PREPARE(db, stmt, SQL_STMT, error);
@@ -45,7 +46,8 @@ database_plt_remove_pos(volatile sqlite3 *db, const char *name, int pos)
{
static const char *SQL_STMT =
"DELETE FROM kara_playlist "
- "WHERE playlist_id = (SELECT id FROM playlist WHERE name = ? LIMIT 1) and kara_id = ?;";
+ "WHERE playlist_id = (SELECT id FROM playlist WHERE name = ? LIMIT 1) "
+ "AND kara_id = ?;";
sqlite3_stmt *stmt = NULL;
bool sta = false;
SQLITE_PREPARE(db, stmt, SQL_STMT, error);
@@ -62,7 +64,8 @@ bool
database_plt_clear(volatile sqlite3 *db, const char *name)
{
static const char *SQL_STMT =
- "DELETE FROM kara_playlist WHERE playlist_id = (SELECT id FROM playlist WHERE name = ?);";
+ "DELETE FROM kara_playlist "
+ "WHERE playlist_id = (SELECT id FROM playlist WHERE name = ?);";
sqlite3_stmt *stmt = NULL;
bool sta = false;
SQLITE_PREPARE(db, stmt, SQL_STMT, error);
@@ -75,9 +78,11 @@ error:
}
bool
-database_plt_rename(volatile sqlite3 *db, const char *old_name, const char *new_name)
+database_plt_rename(volatile sqlite3 *db, const char *old_name,
+ const char *new_name)
{
- static const char *SQL_STMT = "UPDATE playlist SET name = ? WHERE name = ?;";
+ static const char *SQL_STMT =
+ "UPDATE playlist SET name = ? WHERE name = ?;";
sqlite3_stmt *stmt = NULL;
bool sta = false;
SQLITE_PREPARE(db, stmt, SQL_STMT, error);
@@ -105,15 +110,17 @@ database_plt_export(volatile sqlite3 *db, const char *name)
goto error;
}
- GOTO_UNLESS(strcasecmp(name, PROTECTED_DATABASE), "Name '"PROTECTED_DATABASE
- "' is protected, you can't use it for a playlist name", error);
+ GOTO_UNLESS(strcasecmp(name, PROTECTED_DATABASE), "Name '"
+ PROTECTED_DATABASE "' is protected, you can't use "
+ "it for a playlist name", error);
safe_snprintf(SQL_STMT, LKT_MAX_SQLITE_STATEMENT, SQL_SCHEM, name);
SQLITE_PREPARE(db, stmt, SQL_STMT, error);
code = sqlite3_step(stmt);
if (code != SQLITE_DONE && code != SQLITE_OK) {
- LOG_ERROR_SCT("DB", "Failed to create schema: %s", sqlite3_errmsg((sqlite3 *) db));
+ LOG_ERROR_SCT("DB", "Failed to create schema: %s",
+ sqlite3_errmsg((sqlite3 *) db));
goto error;
}
@@ -128,7 +135,9 @@ database_plt_import(volatile sqlite3 *db, const char *name)
{
static const char *SQL_SCHEM =
"INSERT OR IGNORE INTO kara_playlist (kara_id, playlist_id)"
- " SELECT %s.content.kara_id, ( SELECT id FROM playlist WHERE name = %s LIMIT 1 )"
+ " SELECT"
+ " %s.content.kara_id,"
+ " ( SELECT id FROM playlist WHERE name = %s LIMIT 1 )"
" FROM %s.content;\n";
char SQL_STMT[LKT_MAX_SQLITE_STATEMENT], ret = false;
@@ -137,10 +146,12 @@ database_plt_import(volatile sqlite3 *db, const char *name)
goto error;
}
- GOTO_UNLESS(strcasecmp(name, PROTECTED_DATABASE), "Name '"PROTECTED_DATABASE
- "' is protected, you can't use it for a playlist name", error);
+ GOTO_UNLESS(strcasecmp(name, PROTECTED_DATABASE), "Name '"
+ PROTECTED_DATABASE "' is protected, you can't use "
+ "it for a playlist name", error);
- safe_snprintf(SQL_STMT, LKT_MAX_SQLITE_STATEMENT, SQL_SCHEM, name, name, name);
+ safe_snprintf(SQL_STMT, LKT_MAX_SQLITE_STATEMENT, SQL_SCHEM, name,
+ name, name);
SQLITE_EXEC(db, SQL_STMT, error);
ret = true;
error:
@@ -148,10 +159,12 @@ error:
}
bool
-database_plt_add_uri(volatile sqlite3 *db, const char *name, struct lkt_uri *uri)
+database_plt_add_uri(volatile sqlite3 *db, const char *name,
+ struct lkt_uri *uri)
{
static const char *SQL =
- "WITH plt_id(id) AS (SELECT playlist.id AS id FROM playlist WHERE name COLLATE nocase = ?) "
+ "WITH plt_id(id) AS (SELECT playlist.id AS id FROM playlist"
+ " WHERE name COLLATE nocase = ?) "
"INSERT INTO kara_playlist (kara_id, playlist_id) "
"SELECT plt_id.id, kara.id "
" FROM kara, plt_id "
@@ -163,20 +176,20 @@ database_plt_add_uri(volatile sqlite3 *db, const char *name, struct lkt_uri *uri
switch (uri->type) {
case uri_type:
- column = "category";
+ column = LKT_DATABASE_NAME_KTYPE;
break;
case uri_author:
- column = "author_name";
+ column = LKT_DATABASE_NAME_KAUTHOR;
break;
case uri_category:
- column = "type";
+ column = LKT_DATABASE_NAME_KCAT;
break;
case uri_language:
- column = "language";
+ column = LKT_DATABASE_NAME_KLANG;
break;
case uri_query:
case uri_fs:
- column = "file_path";
+ column = LKT_DATABASE_KARA_ALL;
break;
default:
return false;
diff --git a/src/database/queue.c b/src/database/queue.c
index ab868c7f..3559d3f2 100644
--- a/src/database/queue.c
+++ b/src/database/queue.c
@@ -27,7 +27,9 @@ sqlite_just_exec(database_config_queue_default,
bool
database_queue_set_paused(volatile sqlite3 *db, bool paused)
{
- const char *SQL = paused ? "UPDATE queue_state SET paused = 1;" : "UPDATE queue_state SET paused = 0;";
+ const char *SQL = paused ?
+ "UPDATE queue_state SET paused = 1;" :
+ "UPDATE queue_state SET paused = 0;" ;
SQLITE_EXEC(db, SQL, error);
return true;
error:
@@ -42,8 +44,8 @@ database_queue_state(volatile sqlite3 *db, struct lkt_queue_state *res)
{
static const char *SQL_STMT =
"SELECT"
- " volume, paused, random, repeat, single, current, duration, consume, "
- " (SELECT COUNT(*) FROM queue) AS length "
+ " volume, paused, random, repeat, single, current, duration, consume,"
+ " (SELECT COUNT(*) FROM queue) AS length "
"FROM queue_state;\n";
sqlite3_stmt *stmt = 0;
bool ret = false;
@@ -76,10 +78,12 @@ error:
}
bool
-database_queue_current_kara(volatile sqlite3 *db, struct kara_metadata *res, int *id)
+database_queue_current_kara(volatile sqlite3 *db, struct kara_metadata *res,
+ int *id)
{
static const char *SQL_STMT =
- "SELECT song_name, source_name, category, language, author_name, song_type, song_number, kara_id"
+ "SELECT song_name, source_name, category, language, author_name, "
+ "song_type, song_number, kara_id"
" FROM kara"
" JOIN queue ON kara_id = kara.id"
" JOIN queue_state ON current = position";
@@ -93,12 +97,12 @@ database_queue_current_kara(volatile sqlite3 *db, struct kara_metadata *res, int
Most of the time it won't be NULL. */
if (!res)
goto no_metadata;
- strncpy(res->song_name, (const char *) sqlite3_column_text(stmt, 0), LEKTOR_TAG_MAX - 1);
- strncpy(res->source_name, (const char *) sqlite3_column_text(stmt, 1), LEKTOR_TAG_MAX - 1);
- strncpy(res->category, (const char *) sqlite3_column_text(stmt, 2), LEKTOR_TAG_MAX - 1);
- strncpy(res->language, (const char *) sqlite3_column_text(stmt, 3), LEKTOR_TAG_MAX - 1);
- strncpy(res->author_name, (const char *) sqlite3_column_text(stmt, 4), LEKTOR_TAG_MAX - 1);
- strncpy(res->song_type, (const char *) sqlite3_column_text(stmt, 5), LEKTOR_TAG_MAX - 1);
+ strncpy(res->song_name, sqlite3_column_chars(stmt, 0), LEKTOR_TAG_MAX - 1);
+ strncpy(res->source_name, sqlite3_column_chars(stmt, 1), LEKTOR_TAG_MAX - 1);
+ strncpy(res->category, sqlite3_column_chars(stmt, 2), LEKTOR_TAG_MAX - 1);
+ strncpy(res->language, sqlite3_column_chars(stmt, 3), LEKTOR_TAG_MAX - 1);
+ strncpy(res->author_name, sqlite3_column_chars(stmt, 4), LEKTOR_TAG_MAX - 1);
+ strncpy(res->song_type, sqlite3_column_chars(stmt, 5), LEKTOR_TAG_MAX - 1);
res->song_number = sqlite3_column_int(stmt, 6);
no_metadata:
/* Most of the time this will be NULL. */
@@ -152,7 +156,8 @@ error:
}
static bool
-queue_add_with_col_like_str(volatile sqlite3 *db, const char *col, const char *val, int priority)
+queue_add_with_col_like_str(volatile sqlite3 *db, const char *col,
+ const char *val, int priority)
{
static const char *SQL_STMT =
/* Add correspondig karas into the queue */
@@ -166,7 +171,8 @@ queue_add_with_col_like_str(volatile sqlite3 *db, const char *col, const char *v
char SQL[LKT_MAX_SQLITE_STATEMENT];
sqlite3_stmt *stmt = NULL;
- /* Begin, transactions are atomic so we won't be anoyed by multi-threading */
+ /* Begin, transactions are atomic so we won't be anoyed
+ by multi-threading */
SQLITE_EXEC(db, "BEGIN TRANSACTION;", error);
/* Insert at the end of the queue */
@@ -177,7 +183,8 @@ queue_add_with_col_like_str(volatile sqlite3 *db, const char *col, const char *v
SQLITE_STEP_DONE(db, stmt, error);
sqlite3_finalize(stmt);
- /* Reorder kara that are after the current one, do this shit only if priority > 1... */
+ /* Reorder kara that are after the current one, do this shit only
+ if priority > 1... */
reorder(db, priority, error);
/* End */
@@ -191,7 +198,8 @@ error:
}
bool
-database_queue_add_plt(volatile sqlite3 *db, const char *plt_name, int priority)
+database_queue_add_plt(volatile sqlite3 *db, const char *plt_name,
+ int priority)
{
static const char *SQL_STMT =
/* Insert the playlist */
@@ -203,7 +211,8 @@ database_queue_add_plt(volatile sqlite3 *db, const char *plt_name, int priority)
" ORDER BY RANDOM();";
sqlite3_stmt *stmt = NULL;
- /* Begin, transactions are atomic so we won't be anoyed by multi-threading */
+ /* Begin, transactions are atomic so we won't be anoyed
+ by multi-threading */
SQLITE_EXEC(db, "BEGIN TRANSACTION;", error);
SQLITE_PREPARE(db, stmt, SQL_STMT, error);
@@ -227,7 +236,8 @@ error:
bool
database_queue_add_id(volatile sqlite3 *db, int id, int priority)
{
- static const char *SQL_STMT = "INSERT INTO queue (kara_id, priority) VALUES (?,?);";
+ static const char *SQL_STMT =
+ "INSERT INTO queue (kara_id, priority) VALUES (?,?);";
sqlite3_stmt *stmt = NULL;
SQLITE_EXEC(db, "BEGIN TRANSACTION;", error);
SQLITE_PREPARE(db, stmt, SQL_STMT, error);
@@ -253,21 +263,27 @@ database_queue_add_uri(volatile sqlite3 *db, struct lkt_uri *uri, int priority)
switch (uri->type) {
case uri_query:
case uri_fs:
- return queue_add_with_col_like_str(db, LKT_DATABASE_KARA_ALL, uri->value, priority);
+ return queue_add_with_col_like_str(db, LKT_DATABASE_KARA_ALL,
+ uri->value, priority);
case uri_id:
return database_queue_add_id(db, *(int *) uri->value, priority);
case uri_type:
- return queue_add_with_col_like_str(db, LKT_DATABASE_NAME_KTYPE, uri->value, priority);
+ return queue_add_with_col_like_str(db, LKT_DATABASE_NAME_KTYPE,
+ uri->value, priority);
case uri_category:
- return queue_add_with_col_like_str(db, LKT_DATABASE_NAME_KCAT, uri->value, priority);
+ return queue_add_with_col_like_str(db, LKT_DATABASE_NAME_KCAT,
+ uri->value, priority);
case uri_language:
- return queue_add_with_col_like_str(db, LKT_DATABASE_NAME_KLANG, uri->value, priority);
+ return queue_add_with_col_like_str(db, LKT_DATABASE_NAME_KLANG,
+ uri->value, priority);
case uri_author:
- return queue_add_with_col_like_str(db, LKT_DATABASE_NAME_KAUTHOR, uri->value, priority);
+ return queue_add_with_col_like_str(db, LKT_DATABASE_NAME_KAUTHOR,
+ uri->value, priority);
case uri_playlist:
return database_queue_add_plt(db, (char *) uri->value, priority);
default:
- LOG_WARN_SCT("DB", "Add to queue for uri of type %d is not implemented", uri->type);
+ LOG_WARN_SCT("DB", "Add to queue for uri of type %d is not"
+ " implemented", uri->type);
return false;
}
}
@@ -321,10 +337,11 @@ database_queue_next(volatile sqlite3 *db, char filepath[PATH_MAX])
if (code == SQLITE_ROW) {
id = MAX(1, sqlite3_column_int(stmt, 1));
- safe_snprintf(SQL_UPDATE, LKT_MAX_SQLITE_STATEMENT, "UPDATE queue_state SET current = %d;", id);
+ safe_snprintf(SQL_UPDATE, LKT_MAX_SQLITE_STATEMENT,
+ "UPDATE queue_state SET current = %d;", id);
if (filepath != NULL)
- strncpy(filepath, (const char *) sqlite3_column_text(stmt, 0), PATH_MAX);
+ strncpy(filepath, sqlite3_column_chars(stmt, 0), PATH_MAX);
else {
LOG_ERROR_SCT("DB", "Failed to get file, id was %d", id);
goto error;
@@ -332,12 +349,13 @@ database_queue_next(volatile sqlite3 *db, char filepath[PATH_MAX])
}
else if (code == SQLITE_DONE) {
- LOG_ERROR_SCT("DB", "%s", "Failed to get next, don't set current to NULL");
+ LOG_ERROR_SCT("DB", "%s", "Failed to get next");
goto error;
}
else {
- LOG_ERROR_SCT("DB", "Failed to fetch next kara: %s", sqlite3_errmsg((sqlite3 *) db));
+ LOG_ERROR_SCT("DB", "Failed to fetch next kara: %s",
+ sqlite3_errmsg((sqlite3 *) db));
goto error;
}
@@ -383,10 +401,11 @@ database_queue_prev(volatile sqlite3 *db, char filepath[PATH_MAX])
if (code == SQLITE_ROW) {
id = MAX(1, sqlite3_column_int(stmt, 1));
- safe_snprintf(SQL_UPDATE, LKT_MAX_SQLITE_STATEMENT, "UPDATE queue_state SET current = %d;", id);
+ safe_snprintf(SQL_UPDATE, LKT_MAX_SQLITE_STATEMENT,
+ "UPDATE queue_state SET current = %d;", id);
if (filepath != NULL)
- strncpy(filepath, (const char *) sqlite3_column_text(stmt, 0), PATH_MAX);
+ strncpy(filepath, sqlite3_column_chars(stmt, 0), PATH_MAX);
else {
LOG_ERROR_SCT("DB", "Failed to get file, position was %d", id);
goto error;
@@ -394,12 +413,13 @@ database_queue_prev(volatile sqlite3 *db, char filepath[PATH_MAX])
}
else if (code == SQLITE_DONE) {
- LOG_ERROR_SCT("DB", "%s", "Failed to get previous, don't set current to NULL");
+ LOG_ERROR_SCT("DB", "%s", "Failed to get previous");
goto error;
}
else {
- LOG_ERROR_SCT("DB", "Failed to fetch prev kara: %s", sqlite3_errmsg((sqlite3 *) db));
+ LOG_ERROR_SCT("DB", "Failed to fetch prev kara: %s",
+ sqlite3_errmsg((sqlite3 *) db));
goto error;
}
@@ -461,7 +481,8 @@ database_queue_play(volatile sqlite3 *db, int pos)
code = sqlite3_step(stmt);
if (code != SQLITE_OK && code != SQLITE_DONE) {
- LOG_ERROR_SCT("DB", "Failed to update queue_state: %s", sqlite3_errmsg((sqlite3 *) db));
+ LOG_ERROR_SCT("DB", "Failed to update queue_state: %s",
+ sqlite3_errmsg((sqlite3 *) db));
goto error;
}
@@ -473,7 +494,8 @@ error:
bool
database_queue_set_current_index(volatile sqlite3 *db, int idx)
{
- static const char *SQL_GET_TEMPLATE = "UPDATE queue_state SET current = %d;";
+ static const char *SQL_GET_TEMPLATE =
+ "UPDATE queue_state SET current = %d;";
char SQL_GET[LKT_MAX_SQLITE_STATEMENT];
if (idx <= 0) {
@@ -481,8 +503,8 @@ database_queue_set_current_index(volatile sqlite3 *db, int idx)
return false;
}
- RETURN_IF(safe_snprintf(SQL_GET, LKT_MAX_SQLITE_STATEMENT, SQL_GET_TEMPLATE, idx) < 0,
- "Snprintf failed", false);
+ if (safe_snprintf(SQL_GET, LKT_MAX_SQLITE_STATEMENT, SQL_GET_TEMPLATE, idx) < 0)
+ return false;
SQLITE_EXEC(db, SQL_GET, error);
return true;
error:
@@ -508,12 +530,13 @@ database_queue_get_current_file(volatile sqlite3 *db, char filepath[PATH_MAX])
code = sqlite3_step(stmt);
if (code == SQLITE_ROW) {
- strncpy(filepath, (const char *) sqlite3_column_text(stmt, 0), PATH_MAX);
+ strncpy(filepath, sqlite3_column_chars(stmt, 0), PATH_MAX);
filepath[PATH_MAX - 1] = '\0';
}
else {
- LOG_ERROR_SCT("DB", "Failed to fetch prev kara: %s", sqlite3_errmsg((sqlite3 *) db));
+ LOG_ERROR_SCT("DB", "Failed to fetch prev kara: %s",
+ sqlite3_errmsg((sqlite3 *) db));
goto error;
}
@@ -587,7 +610,8 @@ error:
}
bool
-database_queue_list(volatile sqlite3 *db, size_t from, size_t to, struct lkt_callback *callback)
+database_queue_list(volatile sqlite3 *db, size_t from, size_t to,
+ struct lkt_callback *callback)
{
const char *SQL_STMT =
"WITH content AS ("
@@ -641,7 +665,8 @@ error:
bool
database_queue_seekid(volatile sqlite3 *db, int id, int *out_pos)
{
- static const char *SQL_STMT = "SELECT position FROM queue WHERE kara_id = ? LIMIT 1";
+ static const char *SQL_STMT =
+ "SELECT position FROM queue WHERE kara_id = ? LIMIT 1";
int ret = 0;
sqlite3_stmt *stmt;
diff --git a/src/database/stickers.c b/src/database/stickers.c
index 223a9ac9..dc37fcbe 100644
--- a/src/database/stickers.c
+++ b/src/database/stickers.c
@@ -23,7 +23,8 @@ database_sticker_create(volatile sqlite3 *db, const char *name)
"WHERE (SELECT COUNT(*) FROM 'stickers' WHERE name = ?) = 0;";
sqlite3_stmt *stmt;
int ret = false;
- RETURN_IF(strlen(name) == 0, "A sticker name must be at least one character long", ret);
+ if (strlen(name) == 0)
+ return false;
SQLITE_PREPARE(db, stmt, INSERT, error);
SQLITE_BIND_TEXT(db, stmt, 1, name, error);
SQLITE_BIND_TEXT(db, stmt, 2, name, error);
@@ -40,7 +41,8 @@ database_sticker_delete(volatile sqlite3 *db, const char *name)
static const char *INSERT = "DELETE FROM 'stickers' WHERE name = ?;";
sqlite3_stmt *stmt;
int ret = false;
- RETURN_IF(strlen(name) == 0, "A sticker name must be at least one character long", ret);
+ if (strlen(name) == 0)
+ return false;
SQLITE_PREPARE(db, stmt, INSERT, error);
SQLITE_BIND_TEXT(db, stmt, 1, name, error);
SQLITE_STEP_DONE(db, stmt, error);
@@ -51,7 +53,8 @@ error:
}
bool
-database_sticker_set(volatile sqlite3 *db, const char *type, const char *name, int uri, int value)
+database_sticker_set(volatile sqlite3 *db, const char *type, const char *name,
+ int uri, int value)
{
static const char *SQL_TEMPLATE =
"INSERT OR REPLACE INTO 'stickers.%s' (id, sticker, value) "
@@ -87,7 +90,8 @@ error:
}
bool
-database_sticker_delete_specify(volatile sqlite3 *db, const char *type, int uri, const char *name)
+database_sticker_delete_specify(volatile sqlite3 *db, const char *type,
+ int uri, const char *name)
{
char SQL[LKT_MAX_SQLITE_STATEMENT];
sqlite3_stmt *stmt;
@@ -105,8 +109,8 @@ database_sticker_delete_specify(volatile sqlite3 *db, const char *type, int uri,
strncat(SQL, ";", LKT_MAX_SQLITE_STATEMENT - 1);
SQL[LKT_MAX_SQLITE_STATEMENT - 1] = 0;
} else {
- strncat(SQL, "AND sticker = (SELECT id FROM 'stickers' WHERE name = ? LIMIT 1);",
- LKT_MAX_SQLITE_STATEMENT - 1);
+ strncat(SQL, "AND sticker = (SELECT id FROM 'stickers' WHERE name = ?"
+ " LIMIT 1);", LKT_MAX_SQLITE_STATEMENT - 1);
SQL[LKT_MAX_SQLITE_STATEMENT - 1] = 0;
}
diff --git a/src/database/update.c b/src/database/update.c
index 4966e630..3a7f539a 100644
--- a/src/database/update.c
+++ b/src/database/update.c
@@ -18,9 +18,11 @@ __add_kara_to_update_job(volatile sqlite3 *db, size_t id)
{
static const char *SQL = NULL;
if (id)
- SQL = "INSERT INTO updates (job, kara_id) SELECT MAX(update_job), ? FROM misc;";
+ SQL = "INSERT INTO updates (job, kara_id) "
+ "SELECT MAX(update_job), ? FROM misc;";
else
- SQL = "INSERT INTO updates (job, kara_id) SELECT MAX(update_job), last_insert_rowid() FROM misc;";
+ SQL = "INSERT INTO updates (job, kara_id) "
+ "SELECT MAX(update_job), last_insert_rowid() FROM misc;";
sqlite3_stmt *stmt;
SQLITE_PREPARE(db, stmt, SQL, error);
SQLITE_BIND_INT(db, stmt, 1, (int) id, error);
@@ -36,11 +38,13 @@ __database_add_kara(volatile sqlite3 *db, const char *filename)
RETURN_UNLESS(db || filename, "Invalid argument", false);
static const char *SQL_STMT =
"INSERT INTO "
- "kara (song_name, source_name, category, song_type, language, file_path, is_new, author_name, author_year, song_number)"
+ "kara (song_name, source_name, category, song_type, language, "
+ "file_path, is_new, author_name, author_year, song_number)"
"SELECT ?, ?, ?, ?, ?, ?, ?, ?, strftime('%s','now'), ?";
static const char *SQL_STMT_WITH_ID =
"INSERT INTO "
- "kara (song_name, source_name, category, song_type, language, file_path, is_new, author_name, author_year, song_number, id)"
+ "kara (song_name, source_name, category, song_type, language, "
+ "file_path, is_new, author_name, author_year, song_number, id)"
"SELECT ?, ?, ?, ?, ?, ?, ?, ?, strftime('%s','now'), ?, ?";
sqlite3_stmt *stmt = NULL;
long code = SQLITE_OK, status = false, kara_id = 0;
@@ -51,7 +55,8 @@ __database_add_kara(volatile sqlite3 *db, const char *filename)
/* A timestamp */
code = safe_snprintf(year, 10, "%d", the_local_time->tm_year + 1900);
- RETURN_IF(code < 0 || code >= 10, "Failed to get the year of the current date", false);
+ if (code < 0 || code >= 10)
+ return false;
/* Metadata */
if (kara_metadata_read(&data, filename) != 0) {
@@ -89,7 +94,8 @@ __database_add_kara(volatile sqlite3 *db, const char *filename)
(sqlite3_bind_text(stmt, 8, data.author_name, -1, 0) != SQLITE_OK) ||
(sqlite3_bind_int (stmt, 9, data.song_number) != SQLITE_OK)
) {
- LOG_ERROR_SCT("DB", "Failed to bind for kara %s: %s", filename, sqlite3_errmsg((sqlite3 *) db));
+ LOG_ERROR_SCT("DB", "Failed to bind for kara %s: %s", filename,
+ sqlite3_errmsg((sqlite3 *) db));
goto error;
}
SQLITE_STEP_DONE(db, stmt, error);
@@ -108,7 +114,8 @@ error:
bool
database_update_set_available(volatile sqlite3 *db, int id)
{
- static const char *SQL_STMT = "UPDATE kara SET available = 1 WHERE id = ?;";
+ static const char *SQL_STMT =
+ "UPDATE kara SET available = 1 WHERE id = ?;";
sqlite3_stmt *stmt;
SQLITE_PREPARE(db, stmt, SQL_STMT, error);
SQLITE_BIND_INT(db, stmt, 1, id, error);
@@ -123,12 +130,14 @@ error:
}
bool
-database_update_add(volatile sqlite3 *db, const char *kara_path, struct kara_metadata *mdt, uint64_t id, bool avail)
+database_update_add(volatile sqlite3 *db, const char *kara_path,
+ struct kara_metadata *mdt, uint64_t id, bool avail)
{
RETURN_UNLESS(db && kara_path && mdt && id, "Invalid argument", false);
static const char *SQL_STMT =
- "INSERT OR REPLACE INTO "
- "kara (song_name, source_name, category, song_type, language, file_path, is_new, author_name, author_year, song_number, id, available)"
+ "INSERT OR REPLACE INTO kara (song_name, source_name, category, "
+ "song_type, language, file_path, is_new, author_name, author_year, "
+ "song_number, id, available)"
"SELECT ?, ?, ?, ?, ?, ?, ?, ?, strftime('%s','now'), ?, ?, ?";
sqlite3_stmt *stmt = NULL;
int code = SQLITE_OK, ret = false;
@@ -136,7 +145,8 @@ database_update_add(volatile sqlite3 *db, const char *kara_path, struct kara_met
struct tm *the_local_time = localtime(&the_time);
char year[10];
code = safe_snprintf(year, 10, "%d", the_local_time->tm_year + 1900);
- GOTO_IF(code < 0 || code >= 10, "Failed to get the year of the current date", error_no_sqlite);
+ if (code < 0 || code >= 10)
+ return false;
/* From here we initialize the sqlite stmt. */
@@ -162,7 +172,6 @@ database_update_add(volatile sqlite3 *db, const char *kara_path, struct kara_met
ret = __add_kara_to_update_job(db, id);
error:
sqlite3_finalize(stmt);
-error_no_sqlite:
return ret;
}
@@ -176,7 +185,8 @@ database_update(volatile sqlite3 *db, const char *kara_dir, int check_timestamp)
memset(path, 0, PATH_MAX * sizeof(char));
if (!(d = opendir(kara_dir))) {
- LOG_ERROR("Failed to open directory '%s': %s", kara_dir, strerror(errno));
+ LOG_ERROR_SCT("DB", "Failed to open directory '%s': %s", kara_dir,
+ strerror(errno));
return false;
}
@@ -188,7 +198,8 @@ database_update(volatile sqlite3 *db, const char *kara_dir, int check_timestamp)
if (dir->d_type == DT_REG) {
database_get_update(db, &db_timestamp, NULL, NULL);
if (check_timestamp && get_mtime(path) < db_timestamp) {
- LOG_INFO_SCT("DB", "Skip update of kara '%s' be cause of timestamps", path);
+ LOG_INFO_SCT("DB", "Skip update of kara '%s' be cause of "
+ "timestamps", path);
continue;
}
__database_add_kara(db, path);
@@ -236,9 +247,12 @@ out:
}
void
-database_get_update(volatile sqlite3 *db, long *timestamp, long *job, int *current)
+database_get_update(volatile sqlite3 *db, long *timestamp,
+ long *job, int *current)
{
- static const char *SQL = "SELECT last_update, update_job, last_update > last_end_update FROM misc WHERE id = 42;";
+ static const char *SQL =
+ "SELECT last_update, update_job, last_update > last_end_update "
+ "FROM misc WHERE id = 42;";
sqlite3_stmt *stmt;
SQLITE_PREPARE(db, stmt, SQL, error);
SQLITE_STEP_ROW(db, stmt, error);
@@ -250,7 +264,8 @@ database_get_update(volatile sqlite3 *db, long *timestamp, long *job, int *curre
*current = sqlite3_column_int(stmt, 2);
return;
error:
- LOG_WARN_SCT("DB", "Failed to get informations about the last update: %s", sqlite3_errmsg((sqlite3 *) db));
+ LOG_WARN_SCT("DB", "Failed to get informations about the last update: %s",
+ sqlite3_errmsg((sqlite3 *) db));
}
void
diff --git a/src/database/user.c b/src/database/user.c
index 8460216e..c39bd88c 100644
--- a/src/database/user.c
+++ b/src/database/user.c
@@ -7,13 +7,15 @@
bool
database_user_authentificate(volatile sqlite3 *db, const char *password)
{
- static const char *SQL_STMT = "SELECT username FROM users WHERE password = ?";
+ static const char *SQL_STMT =
+ "SELECT username FROM users WHERE password = ?";
sqlite3_stmt *stmt = 0;
bool ret = false;
SQLITE_PREPARE(db, stmt, SQL_STMT, error);
SQLITE_BIND_TEXT(db, stmt, 1, password, error);
SQLITE_STEP_ROW(db, stmt, error);
- LOG_INFO_SCT("DB", "User authentification for '%s'", sqlite3_column_text(stmt, 0));
+ LOG_INFO_SCT("DB", "User authentification for '%s'",
+ sqlite3_column_text(stmt, 0));
ret = true;
error:
sqlite3_finalize(stmt);
@@ -23,7 +25,8 @@ error:
bool
database_user_add(volatile sqlite3 *db, const char *username, const char *password)
{
- static const char *SQL_STMT = "INSERT INTO users (username, password) VALUES (?, ?)";
+ static const char *SQL_STMT =
+ "INSERT INTO users (username, password) VALUES (?, ?)";
sqlite3_stmt *stmt = 0;
bool ret = false;
SQLITE_PREPARE(db, stmt, SQL_STMT, error);
diff --git a/src/mkv/write.c b/src/mkv/write.c
index 7faa3999..66dab3b4 100644
--- a/src/mkv/write.c
+++ b/src/mkv/write.c
@@ -66,12 +66,14 @@ mkvpropedit__(const char *const args[])
if ((pid = fork()) == 0) {
if ((fd = open("/dev/null", O_WRONLY | O_TRUNC)) < 0) {
- LOG_ERROR_SCT("FORK", "%s", "Can't to open /dev/null in O_WRONLY O_TRUNC");
+ LOG_ERROR_SCT("FORK", "%s", "Can't to open /dev/null "
+ "in O_WRONLY O_TRUNC");
return false;
}
if (dup2(fd, 1) < 0) {
- LOG_ERROR_SCT("FORK", "%s", "Failed to duplicate /dev/null to stdout");
+ LOG_ERROR_SCT("FORK", "%s", "Failed to duplicate "
+ "/dev/null to stdout");
return false;
}
@@ -87,7 +89,8 @@ mkvpropedit__(const char *const args[])
else {
do {
if (waitpid(pid, &wstatus, WUNTRACED | WCONTINUED) == -1) {
- LOG_ERROR_SCT("FORK", "Failed to wait children: %s", strerror(errno));
+ LOG_ERROR_SCT("FORK", "Failed to wait children: %s",
+ strerror(errno));
return false;
}
} while (!WIFEXITED(wstatus) && !WIFSIGNALED(wstatus));
@@ -102,12 +105,13 @@ mkvpropedit__(const char *const args[])
}
int
-kara_metadata_write(struct kara_metadata *mdt, const char *filename, const char *mkvpropedit)
+kara_metadata_write(struct kara_metadata *mdt, const char *filename,
+ const char *mkvpropedit)
{
char tmpfilepath[PATH_MAX];
char *const metadafilepath = &tmpfilepath[4];
- const char *const args1[] = { mkvpropedit, "-t", "all:", filename, NULL };
- const char *const args2[] = { mkvpropedit, "-t", tmpfilepath, filename, NULL };
+ const char *args1[] = { mkvpropedit, "-t", "all:", filename, NULL };
+ const char *args2[] = { mkvpropedit, "-t", tmpfilepath, filename, NULL };
int fd, sta = -1;
memset(tmpfilepath, 0, PATH_MAX);
@@ -118,8 +122,9 @@ kara_metadata_write(struct kara_metadata *mdt, const char *filename, const char
goto error;
}
- if (dprintf(fd, METADATA_TEMPLATE, mdt->source_name, mdt->song_name, mdt->category,
- mdt->language, mdt->author_name, mdt->song_type, mdt->song_number) < 0) {
+ if (dprintf(fd, METADATA_TEMPLATE, mdt->source_name, mdt->song_name,
+ mdt->category, mdt->language, mdt->author_name, mdt->song_type,
+ mdt->song_number) < 0) {
LOG_ERROR("Failed to write to temporary file: %s", metadafilepath);
goto error;
}
@@ -150,8 +155,10 @@ metadata_from_path(char *const mkvfile, struct kara_metadata *meta)
"(jp|fr|en|ru|sp|it|ch|latin|multi|undefined)/(.+)/"
"(.+) - (OP|ED|IS|AMV|VOCA|PV|MV|LIVE)([[:digit:]]*) - (.+)\\.mkv$";
- if (!regex_init)
- GOTO_IF(regcomp(®ex, rgx, REG_EXTENDED), "Failed to compile regex", error);
+ if (!regex_init && regcomp(®ex, rgx, REG_EXTENDED)) {
+ LOG_ERROR_SCT("MPV", "%s", "Failed to compile regex");
+ goto error;
+ }
memset(meta, 0, sizeof(struct kara_metadata));
memset(msgbuf, 0, LEKTOR_TAG_MAX * sizeof(char));
@@ -195,7 +202,8 @@ metadata_set_directory(const char *kara_dir, const char *mkvpropedit)
memset(path, 0, PATH_MAX * sizeof(char));
if (!(d = opendir(kara_dir))) {
- LOG_ERROR("Failed to open directory '%s': %s", kara_dir, strerror(errno));
+ LOG_ERROR("Failed to open directory '%s': %s", kara_dir,
+ strerror(errno));
return 1;
}
diff --git a/src/module/module_sdl2.c b/src/module/module_sdl2.c
index 101ab1a8..43060f06 100644
--- a/src/module/module_sdl2.c
+++ b/src/module/module_sdl2.c
@@ -74,12 +74,13 @@ init_mpv__(mpv_handle **ctx, volatile sqlite3 *db)
*ctx = lmpv_prepare(db);
int status;
RETURN_IF((status = mpv_initialize(*ctx)) < 0, mpv_error_string(status), 1);
- RETURN_UNLESS(lmpv_observe_properties(*ctx), "Observe properties failed", 1);
+ RETURN_UNLESS(lmpv_observe_properties(*ctx), "Observe prop failed", 1);
return 0;
}
static inline bool
-init_mpv_gl__(mpv_handle *mpv, mpv_render_context **mpv_gl, mpv_render_param *params)
+init_mpv_gl__(mpv_handle *mpv, mpv_render_context **mpv_gl,
+ mpv_render_param *params)
{
int status;
RETURN_IF((status = mpv_render_context_create(mpv_gl, mpv, params)) < 0,
@@ -115,15 +116,18 @@ sdl_thread__(struct poller_thread_arg *arg)
SDL_SetHint(SDL_HINT_NO_SIGNAL_HANDLERS, "no"); /* It seems that sdl sucks. */
RETURN_IF(SDL_Init(SDL_INIT_VIDEO) < 0, "Failed to init SDL", NULL);
- sdl2->window = SDL_CreateWindow("lektord", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
- WIDTH, HEIGHT, SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE);
+ sdl2->window = SDL_CreateWindow("lektord", SDL_WINDOWPOS_CENTERED,
+ SDL_WINDOWPOS_CENTERED, WIDTH, HEIGHT,
+ SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN |
+ SDL_WINDOW_RESIZABLE);
RETURN_UNLESS(sdl2->window, "Failed to create the window", NULL);
sdl2->glcontext = SDL_GL_CreateContext((SDL_Window *) sdl2->window);
RETURN_UNLESS(sdl2->glcontext, "Failed to create the SDL context", NULL);
/* Init mpv here */
- RETURN_IF(init_mpv__((mpv_handle **) & sdl2->mpv, win->srv->db), "Failed to init mpv", false);
+ RETURN_IF(init_mpv__((mpv_handle **) & sdl2->mpv, win->srv->db),
+ "Failed to init mpv", false);
mpv_render_param params[] = {
{ MPV_RENDER_PARAM_API_TYPE, MPV_RENDER_API_TYPE_OPENGL },
@@ -134,7 +138,6 @@ sdl_thread__(struct poller_thread_arg *arg)
}
},
{
- // Can't use mpv_command with that thing, should change to mpv_command_async
MPV_RENDER_PARAM_ADVANCED_CONTROL, &(int)
{
1
@@ -143,7 +146,8 @@ sdl_thread__(struct poller_thread_arg *arg)
{0}
};
- RETURN_IF(init_mpv_gl__((mpv_handle *) sdl2->mpv, (mpv_render_context **) &sdl2->mpv_gl, params),
+ RETURN_IF(init_mpv_gl__((mpv_handle *) sdl2->mpv, (mpv_render_context **)
+ &sdl2->mpv_gl, params),
"Failed to init mpv_gl", false);
while (!sdl2->launched)
@@ -172,7 +176,8 @@ loop:
else if (event.key.keysym.sym == SDLK_RETURN ||
event.key.keysym.sym == SDLK_RETURN2 ||
event.key.keysym.sym == SDLK_KP_ENTER)
- command_next(sdl2->db, (struct lkt_win *) win, sdl2->mpd_idle_events);
+ command_next(sdl2->db, (struct lkt_win *) win,
+ sdl2->mpd_idle_events);
else if (event.key.keysym.sym == SDLK_LEFT) {
const char *cmd_seek[] = { "seek", "-5", "relative", NULL };
@@ -186,7 +191,8 @@ loop:
if (sdl2->is_fullscreen)
SDL_SetWindowFullscreen((SDL_Window *) sdl2->window, 0);
else
- SDL_SetWindowFullscreen((SDL_Window *) sdl2->window, SDL_WINDOW_FULLSCREEN);
+ SDL_SetWindowFullscreen((SDL_Window *) sdl2->window,
+ SDL_WINDOW_FULLSCREEN);
/* May use SDL_WINDOW_FULLSCREEN_DESKTOP, need to check. */
sdl2->is_fullscreen = 1 - sdl2->is_fullscreen;
}
@@ -194,9 +200,11 @@ loop:
case SDL_TEXTINPUT:
if (STR_MATCH(event.text.text, ">"))
- command_next(sdl2->db, (struct lkt_win *) win, sdl2->mpd_idle_events);
+ command_next(sdl2->db, (struct lkt_win *) win,
+ sdl2->mpd_idle_events);
else if (STR_MATCH(event.text.text, "<"))
- command_previous(sdl2->db, (struct lkt_win *) win, sdl2->mpd_idle_events);
+ command_previous(sdl2->db, (struct lkt_win *) win,
+ sdl2->mpd_idle_events);
else if (STR_MATCH(event.text.text, "o")) {
const char *cmd[] = { "show-progress", NULL };
mpv_command_async((mpv_handle *) sdl2->mpv, 0, cmd);
@@ -207,8 +215,10 @@ loop:
if (database_queue_current_kara(sdl2->db, &mdt, &id)) {
mdtcat(&mdt, &str);
const char *cmd[] = { "show-text", str, "4000", NULL };
- /* Same size, only on 64bit arch... FIXME: Do something else in 32bits */
- mpv_command_async((mpv_handle *) sdl2->mpv, (uint64_t) str, cmd);
+ /* Same size, only on 64bit arch...
+ FIXME: Do something else in 32bits */
+ mpv_command_async((mpv_handle *) sdl2->mpv,
+ (uint64_t) str, cmd);
}
} else
LOG_ERROR_SCT("WINDOW", "Not handled text '%s'", event.text.text);
@@ -216,14 +226,16 @@ loop:
default:
if (event.type == wakeup_on_mpv_render_update) {
- flags = mpv_render_context_update((mpv_render_context *) sdl2->mpv_gl);
+ flags = mpv_render_context_update((mpv_render_context *)
+ sdl2->mpv_gl);
if (flags & MPV_RENDER_UPDATE_FRAME)
redraw = 1;
}
if (event.type == wakeup_on_mpv_events)
- lmpv_handle((struct lkt_win *) win, (mpv_handle *) sdl2->mpv, sdl2->db,
- sdl2->mpd_idle_events, &sdl2->mpv_time_pos, &sdl2->mpv_duration);
+ lmpv_handle((struct lkt_win *) win, (mpv_handle *) sdl2->mpv,
+ sdl2->db, sdl2->mpd_idle_events, &sdl2->mpv_time_pos,
+ &sdl2->mpv_duration);
}
if (redraw) {
@@ -284,6 +296,7 @@ bool
module_sdl2_new(struct lkt_win *const win)
{
RETURN_UNLESS(win, "Invalid arguments", false);
+ struct poller_thread_arg *arg;
if (win->window == NULL) {
win->window = calloc(1, sizeof(struct module_sdl2_window));
@@ -298,16 +311,17 @@ module_sdl2_new(struct lkt_win *const win)
sdl2->mpd_idle_events = &win->srv->mpd_idle_events;
/* Start the SDL thread */
- struct poller_thread_arg *arg = calloc(1, sizeof(struct poller_thread_arg));
+ arg = malloc(sizeof(struct poller_thread_arg));
RETURN_UNLESS(arg, "Out of memory", false);
arg->args = win;
- RETURN_IF(poller_new(&((struct module_sdl2_window *) win->window)->self,
+ RETURN_IF(poller_new(&((struct module_sdl2_window *)win->window)->self,
sdl_thread__, arg),
"Failed to launch the SDL thread", false);
}
/* Finish */
- SDL_SetWindowTitle((SDL_Window *) ((struct module_sdl2_window *) win->window)->window, "Lektord");
+ SDL_SetWindowTitle((SDL_Window *) ((struct module_sdl2_window *)
+ win->window)->window, "Lektord");
SDL_DisableScreenSaver();
((struct module_sdl2_window *) win->window)->launched = 1;
return true;
@@ -339,7 +353,8 @@ bool
module_sdl2_toggle_pause(struct lkt_win *const win)
{
RETURN_UNLESS(win && win->window, "Invalid arguments", false);
- return ! lmpv_toggle_pause((mpv_handle *) ((struct module_sdl2_window *) win->window)->mpv);
+ return ! lmpv_toggle_pause((mpv_handle *) ((struct module_sdl2_window *)
+ win->window)->mpv);
}
bool
@@ -357,7 +372,9 @@ bool
module_sdl2_set_volume(struct lkt_win *const win, int vol)
{
RETURN_UNLESS(win && win->window, "Invalid arguments", false);
- return ! lmpv_set_volume((mpv_handle *) ((struct module_sdl2_window *) win->window)->mpv, vol);
+ return ! lmpv_set_volume((mpv_handle *)
+ ((struct module_sdl2_window *) win->window)->mpv,
+ vol);
}
bool
@@ -387,7 +404,8 @@ module_sdl2_attach(struct lkt_win *const win, void *server)
}
bool
-module_sdl2_handle_events(struct lkt_win *const win, volatile sqlite3 *db, mpd_idle_flag *mpd_idle_events)
+module_sdl2_handle_events(struct lkt_win *const win, volatile sqlite3 *db,
+ mpd_idle_flag *mpd_idle_events)
{
UNUSED(win, db, mpd_idle_events);
return true;
diff --git a/src/module/module_x11.c b/src/module/module_x11.c
index 17c67093..6b1d4572 100644
--- a/src/module/module_x11.c
+++ b/src/module/module_x11.c
@@ -80,22 +80,23 @@ lx11_new(struct module_x11_window *ret)
RETURN_UNLESS(ret->master_display, "Can't open display", false);
ret->screen = DefaultScreen(ret->master_display);
Colormap colormap = DefaultColormap(ret->master_display, ret->screen);
- XAllocNamedColor(ret->master_display, colormap, "black", &ret->black, &ret->black);
+ XAllocNamedColor(ret->master_display, colormap, "black",
+ &ret->black, &ret->black);
// Initialize container window attributes
ret->attrs.event_mask
- = SubstructureRedirectMask // handle child window requests (MapRequest)
- | SubstructureNotifyMask // handle child window notifications (DestroyNotify)
- | StructureNotifyMask // handle container notifications (ConfigureNotify)
- | ExposureMask // handle container redraw (Expose)
- | KeyReleaseMask // handle release key (KeyRelease)
- | VisibilityChangeMask // handle... I don't know
+ = SubstructureRedirectMask
+ | SubstructureNotifyMask
+ | StructureNotifyMask
+ | ExposureMask
+ | KeyReleaseMask
+ | VisibilityChangeMask
;
- ret->attrs.do_not_propagate_mask = 1; // do not hide any events from child window
- ret->attrs.background_pixel = ret->black.pixel; // background color
- unsigned long attrs_mask = CWEventMask // enable attrs.event_mask
- | NoEventMask // enable attrs.do_not_propagate_mask
- | CWBackPixel // enable attrs.background_pixel
+ ret->attrs.do_not_propagate_mask = 1;
+ ret->attrs.background_pixel = ret->black.pixel;
+ unsigned long attrs_mask = CWEventMask
+ | NoEventMask
+ | CWBackPixel
;
// Create and map container window
@@ -103,9 +104,9 @@ lx11_new(struct module_x11_window *ret)
0, 0, WIDTH, HEIGHT, 1, CopyFromParent, InputOutput,
CopyFromParent, attrs_mask, &ret->attrs);
- XMapWindow(ret->master_display, ret->master_win); // Make window visible
- XStoreName(ret->master_display, ret->master_win, "Lektor Player"); // Set window title
- ret->wm_delete = XInternAtom(ret->master_display, "WM_DELETE_WINDOW", True); // Get WM_DELETE_WINDOW atom
+ XMapWindow(ret->master_display, ret->master_win);
+ XStoreName(ret->master_display, ret->master_win, "Lektor Player");
+ ret->wm_delete = XInternAtom(ret->master_display, "WM_DELETE_WINDOW", True);
XSetWMProtocols(ret->master_display, ret->master_win, &ret->wm_delete, 1);
ret->child_display = NULL;
@@ -123,7 +124,8 @@ lx11_handle(struct module_x11_window *win)
for (;;) {
- if (!XCheckWindowEvent(win->master_display, win->master_win, win->attrs.event_mask, &event))
+ if (!XCheckWindowEvent(win->master_display, win->master_win,
+ win->attrs.event_mask, &event))
return true;
// Map child window when it requests and store its display and window id
@@ -134,12 +136,14 @@ lx11_handle(struct module_x11_window *win)
win->child_win = event.xmaprequest.window;
}
- // Propagate resize event to child window, and also resize it after MapRequest
+ // Propagate resize event to child window, and also resize it
+ // after MapRequest
if (event.type == ConfigureNotify || event.type == MapRequest) {
if (win->child_win) {
// Get container window attributes
XWindowAttributes attrs;
- XGetWindowAttributes(win->master_display, win->master_win, &attrs);
+ XGetWindowAttributes(win->master_display, win->master_win,
+ &attrs);
// Move and resize child
XMoveResizeWindow(win->child_display, win->child_win,
@@ -246,7 +250,8 @@ bool
module_x11_set_volume(struct lkt_win *const win, int vol)
{
RETURN_UNLESS(win && win->window, "Invalid arguments", false);
- return ! lmpv_set_volume(((struct module_x11_window *) win->window)->mpv, vol);
+ return ! lmpv_set_volume(((struct module_x11_window *) win->window)->mpv,
+ vol);
}
bool
@@ -268,10 +273,12 @@ module_x11_get_elapsed(struct lkt_win *const win, int *elapsed_sec)
}
bool
-module_x11_handle_events(struct lkt_win *const win, volatile sqlite3 *db, mpd_idle_flag *mpd_idle_events)
+module_x11_handle_events(struct lkt_win *const win, volatile sqlite3 *db,
+ mpd_idle_flag *mpd_idle_events)
{
RETURN_UNLESS(win && win->window, "Invalid arguments", false);
struct module_x11_window *xwin = win->window;
return lx11_handle(xwin) &&
- ! lmpv_handle(win, xwin->mpv, db, mpd_idle_events, &xwin->mpv_time_pos, &xwin->mpv_duration);
+ ! lmpv_handle(win, xwin->mpv, db, mpd_idle_events,
+ &xwin->mpv_time_pos, &xwin->mpv_duration);
}
diff --git a/src/module/repo.c b/src/module/repo.c
index 48e240df..c12a40c2 100644
--- a/src/module/repo.c
+++ b/src/module/repo.c
@@ -111,11 +111,13 @@ repo_free(struct lkt_repo *const repo)
}
int
-safe_json_get_string(struct json_object *jobj, const char *key, char *content, const size_t len)
+safe_json_get_string(struct json_object *jobj, const char *key,
+ char *content, const size_t len)
{
const char *got;
struct json_object *field;
- RETURN_UNLESS(json_object_object_get_ex(jobj, key, &field), "Key not found in json", 1);
+ RETURN_UNLESS(json_object_object_get_ex(jobj, key, &field),
+ "Key not found in json", 1);
got = json_object_get_string(field);
RETURN_UNLESS(got, "Got a NULL for the key, may be an error", 1);
strncpy(content, got, len - 1);
@@ -127,10 +129,12 @@ int
safe_json_get_int32(struct json_object *json, const char *key, int32_t *ret)
{
struct json_object *field;
- RETURN_UNLESS(json_object_object_get_ex(json, key, &field), "Key not found", 1);
+ RETURN_UNLESS(json_object_object_get_ex(json, key, &field),
+ "Key not found", 1);
errno = 0;
*ret = json_object_get_int(field);
- RETURN_IF(*ret == INT32_MAX || *ret == INT32_MIN, "Out of bound 32bit integer", 1);
+ RETURN_IF(*ret == INT32_MAX || *ret == INT32_MIN,
+ "Out of bound 32bit integer", 1);
return 0;
}
@@ -165,7 +169,8 @@ __json_sync(struct lkt_repo *const repo, struct json_object **json)
res = curl_easy_perform(curl_handle);
if (res != CURLE_OK) {
- LOG_ERROR_SCT("CURL", "curl_easy_perform failed: %s", curl_easy_strerror(res));
+ LOG_ERROR_SCT("CURL", "curl_easy_perform failed: %s",
+ curl_easy_strerror(res));
free(file.mem);
goto err;
}
@@ -178,7 +183,8 @@ err:
}
int
-repo_get_id(struct lkt_repo *const repo, const uint64_t id, struct kara_metadata *mdt)
+repo_get_id(struct lkt_repo *const repo, const uint64_t id,
+ struct kara_metadata *mdt)
{
RETURN_UNLESS(mdt, "Invalid argument", 1);
CURL *curl_handle;
@@ -200,7 +206,8 @@ repo_get_id(struct lkt_repo *const repo, const uint64_t id, struct kara_metadata
curl_easy_setopt(curl_handle, CURLOPT_USERAGENT, "libcurl-agent/1.0");
if (CURLE_OK != (res = curl_easy_perform(curl_handle))) {
- LOG_ERROR_SCT("CURL", "curl_easy_perform failed: %s", curl_easy_strerror(res));
+ LOG_ERROR_SCT("CURL", "curl_easy_perform failed: %s",
+ curl_easy_strerror(res));
free(file.mem);
curl_easy_cleanup(curl_handle);
return 1;
@@ -212,18 +219,20 @@ repo_get_id(struct lkt_repo *const repo, const uint64_t id, struct kara_metadata
jobj = json_tokener_parse(file.mem);
if (json_object_object_get_ex(jobj, "message", &field)) {
- LOG_ERROR("Kara with id %lu not found, message is: %s", id, json_object_get_string(field));
+ LOG_ERROR("Kara with id %lu not found, message is: %s", id,
+ json_object_get_string(field));
goto err;
}
LOG_INFO("Got kara with id %lu", id);
- err |= safe_json_get_string(jobj, "song_name", mdt->song_name, LEKTOR_TAG_MAX);
- err |= safe_json_get_string(jobj, "source_name", mdt->source_name, LEKTOR_TAG_MAX);
- err |= safe_json_get_string(jobj, "category", mdt->category, LEKTOR_TAG_MAX);
- err |= safe_json_get_string(jobj, "language", mdt->language, LEKTOR_TAG_MAX);
- err |= safe_json_get_string(jobj, "author_name", mdt->author_name, LEKTOR_TAG_MAX);
- err |= safe_json_get_string(jobj, "song_type", mdt->song_type, LEKTOR_TAG_MAX);
- GOTO_IF(err || safe_json_get_int32(jobj, "song_number", &mdt->song_number), "Invalid json", err);
+ err |= safe_json_get_string(jobj, "song_name", mdt->song_name, LEKTOR_TAG_MAX);
+ err |= safe_json_get_string(jobj, "source_name", mdt->source_name, LEKTOR_TAG_MAX);
+ err |= safe_json_get_string(jobj, "category", mdt->category, LEKTOR_TAG_MAX);
+ err |= safe_json_get_string(jobj, "language", mdt->language, LEKTOR_TAG_MAX);
+ err |= safe_json_get_string(jobj, "author_name", mdt->author_name, LEKTOR_TAG_MAX);
+ err |= safe_json_get_string(jobj, "song_type", mdt->song_type, LEKTOR_TAG_MAX);
+ GOTO_IF(err || safe_json_get_int32(jobj, "song_number", &mdt->song_number),
+ "Invalid json", err);
ret = 0;
err:
json_object_put(jobj); /* Delete object. */
@@ -235,8 +244,9 @@ __download_kara(const char *url, const char *path, int override)
{
CURL *curl_handle;
errno = 0;
- char *ct, ret = 1;
- int fd = open(path, O_WRONLY | O_APPEND | O_CREAT | O_EXCL | O_NOFOLLOW, S_IRUSR | S_IWUSR);
+ char ret = 1;
+ int fd = open(path, O_WRONLY | O_APPEND | O_CREAT | O_EXCL | O_NOFOLLOW,
+ S_IRUSR | S_IWUSR);
retest:
if (fd < 0) {
@@ -272,12 +282,8 @@ retest:
curl_easy_setopt(curl_handle, CURLOPT_USERAGENT, "libcurl-agent/1.0");
if (CURLE_OK != (ret = curl_easy_perform(curl_handle))) {
- LOG_ERROR_SCT("CURL", "curl_easy_perform failed: %s", curl_easy_strerror(ret));
- goto err;
- }
-
- if (CURLE_OK != (ret = curl_easy_getinfo(curl_handle, CURLINFO_CONTENT_TYPE, &ct))) {
- LOG_ERROR_SCT("CURL", "Failed to get Content-Type: %s", curl_easy_strerror(ret));
+ LOG_ERROR_SCT("CURL", "curl_easy_perform failed: %s",
+ curl_easy_strerror(ret));
goto err;
}
@@ -288,7 +294,8 @@ err:
}
int
-repo_download_id_sync(struct lkt_repo *const repo, const uint64_t id, const char *kara_path, struct kara_metadata *mdt_ret)
+repo_download_id_sync(struct lkt_repo *const repo, const uint64_t id,
+ const char *kara_path, struct kara_metadata *mdt_ret)
{
RETURN_UNLESS(kara_path, "Invalid argument", 1);
struct kara_metadata mdt;
@@ -303,11 +310,13 @@ repo_download_id_sync(struct lkt_repo *const repo, const uint64_t id, const char
safe_snprintf(url, URL_MAX_LEN, repo->get_id_file, id);
if (__download_kara(url, kara_path, false)) {
- LOG_ERROR_SCT("REPO", "Failed to download kara '%s' with url '%s'", kara_path, url);
+ LOG_ERROR_SCT("REPO", "Failed to download kara '%s' with url '%s'",
+ kara_path, url);
return 1;
}
- if (repo->db && !database_update_add((sqlite3 *) repo->db, kara_path, mdt_ret ? mdt_ret : &mdt, id, true)) {
+ if (repo->db && !database_update_add((sqlite3 *) repo->db, kara_path,
+ mdt_ret ? mdt_ret : &mdt, id, true)) {
LOG_ERROR("%s", "Failed to add kara to database");
return 1;
}
@@ -318,7 +327,8 @@ repo_download_id_sync(struct lkt_repo *const repo, const uint64_t id, const char
/* Get all the kara, make them unavailable */
void
-__handle_got_json(volatile sqlite3 *db, struct lkt_repo *repo, struct json_object *json)
+__handle_got_json(volatile sqlite3 *db, struct lkt_repo *repo,
+ struct json_object *json)
{
size_t i, len = json_object_array_length(json);
struct json_object *kara_json;
@@ -329,8 +339,10 @@ __handle_got_json(volatile sqlite3 *db, struct lkt_repo *repo, struct json_objec
int current_id;
struct lkt_state *srv = repo->srv;
- RETURN_UNLESS(len > 0 && json_object_get_array(json), "Json invalid or array empty", NOTHING);
- RETURN_UNLESS(database_config_get_text(db, "externals", "mkvpropedit", mkvpropedit, PATH_MAX - 1),
+ RETURN_UNLESS(len > 0 && json_object_get_array(json),
+ "Json invalid or array empty", NOTHING);
+ RETURN_UNLESS(database_config_get_text(db, "externals", "mkvpropedit",
+ mkvpropedit, PATH_MAX - 1),
"Can't get the mkvpropedit executable path", NOTHING);
LOG_INFO_SCT("REPO", "Starting to process json for repo %s", repo->name);
@@ -345,12 +357,14 @@ __handle_got_json(volatile sqlite3 *db, struct lkt_repo *repo, struct json_objec
/* Craft a fake filepath here, it will be used later. */
size_t kara_dir_len = strlen(repo->kara_dir);
- memcpy(kara.filename, repo->kara_dir, sizeof(char) * (kara_dir_len + 1));
+ memcpy(kara.filename, repo->kara_dir,
+ sizeof(char) * (kara_dir_len + 1));
if (kara.filename[kara_dir_len - 1] != '/') {
strncat(kara.filename, "/", PATH_MAX - 1);
kara.filename[++kara_dir_len] = 0;
}
- safe_snprintf(kara.filename + kara_dir_len, PATH_MAX - kara_dir_len, "%d.mkv", integer);
+ safe_snprintf(kara.filename + kara_dir_len, PATH_MAX - kara_dir_len,
+ "%d.mkv", integer);
/* Reads the json */
err |= safe_json_get_string(kara_json, "song_name", kara.mdt.song_name, LEKTOR_TAG_MAX);
@@ -373,14 +387,16 @@ __handle_got_json(volatile sqlite3 *db, struct lkt_repo *repo, struct json_objec
! kara_metadata_equals(&kara.mdt, kara.filename)) {
database_update_touch(db, kara.id);
database_update_set_available(db, kara.id);
- LOG_INFO_SCT("REPO", "Ignore kara '%ld' with path '%s'", kara.id, kara.filename);
+ LOG_INFO_SCT("REPO", "Ignore kara '%ld' with path '%s'",
+ kara.id, kara.filename);
continue;
}
current_id = 0;
database_queue_current_kara(db, NULL, ¤t_id);
if (current_id == (int) kara.id) {
- LOG_WARN_SCT("REPO", "Update currently playing kara %d, skip it", current_id);
+ LOG_WARN_SCT("REPO", "Update currently playing kara %d, skip it",
+ current_id);
char *current_path = safe_malloc(PATH_MAX * sizeof(char));
database_queue_skip_current(db, current_path);
srv->win.load_file(&srv->win, current_path);
@@ -388,19 +404,22 @@ __handle_got_json(volatile sqlite3 *db, struct lkt_repo *repo, struct json_objec
}
if (!database_update_add(db, kara.filename, &kara.mdt, kara.id, false)) {
- LOG_ERROR_SCT("REPO", "Could not add unavailable kara %ld to db", kara.id);
+ LOG_ERROR_SCT("REPO", "Could not add unavailable kara %ld to db",
+ kara.id);
continue;
}
safe_snprintf(url, URL_MAX_LEN, repo->get_id_file, kara.id);
if (__download_kara(url, kara.filename, true)) {
- LOG_WARN_SCT("REPO", "Could not download kara %ld at path '%s'", kara.id, kara.filename);
+ LOG_WARN_SCT("REPO", "Could not download kara %ld at path '%s'",
+ kara.id, kara.filename);
continue;
}
if (kara_metadata_write(&kara.mdt, kara.filename, mkvpropedit)) {
- LOG_WARN_SCT("REPO", "Could not write metadata to kara '%ld' with path '%s'", kara.id, kara.filename);
+ LOG_WARN_SCT("REPO", "Could not write metadata to kara '%ld' with "
+ "path '%s'", kara.id, kara.filename);
continue;
}
@@ -410,7 +429,8 @@ __handle_got_json(volatile sqlite3 *db, struct lkt_repo *repo, struct json_objec
}
database_stamp(db);
- LOG_INFO_SCT("REPO", "Added kara %ld from repo %s, filepath is %s", kara.id, repo->name, kara.filename);
+ LOG_INFO_SCT("REPO", "Added kara %ld from repo %s, filepath is %s",
+ kara.id, repo->name, kara.filename);
}
}
diff --git a/src/net/command.c b/src/net/command.c
index b23744f2..c4f2f61a 100644
--- a/src/net/command.c
+++ b/src/net/command.c
@@ -13,9 +13,13 @@ lkt_command_parse(char *raw)
{
errno = 0;
char *endptr;
- struct lkt_command res = { .name = raw, .args = {0}, .cont = strtol(raw, &endptr, 10) };
+ struct lkt_command res = {
+ .name = raw,
+ .args = {0},
+ .cont = strtol(raw, &endptr, 10)
+ };
- if ((errno == ERANGE && (res.cont == LONG_MAX || res.cont == LONG_MIN)) || (errno != 0)) {
+ if (errno != 0) {
res.cont = 0;
goto skip_cont;
}
diff --git a/src/net/listen.c b/src/net/listen.c
index 09b9f4da..3713cd19 100644
--- a/src/net/listen.c
+++ b/src/net/listen.c
@@ -77,8 +77,8 @@ void
lkt_state_send(struct lkt_state *srv, size_t c, struct lkt_message *msg)
{
struct lkt_client *cli = &srv->clients[c - 1];
- RETURN_IF(cli->buffer_out_len >= BUFFER_OUT_MAX, "Cannot send message to client, buffer_out is full",
- NOTHING);
+ RETURN_IF(cli->buffer_out_len >= BUFFER_OUT_MAX, "Cannot send message to "
+ "client, buffer_out is full", NOTHING);
cli->buffer_out[cli->buffer_out_len++] = msg;
srv->fds[c].events |= POLLOUT;
}
@@ -87,7 +87,8 @@ static inline void
send_continue(struct lkt_state *srv, size_t c, int i)
{
struct lkt_message *cont = lkt_message_new();
- cont->data_len = safe_snprintf(cont->data, LKT_MESSAGE_MAX, "continue: %d\n", i);
+ cont->data_len = safe_snprintf(cont->data, LKT_MESSAGE_MAX,
+ "continue: %d\n", i);
lkt_state_send(srv, c, cont);
}
@@ -280,7 +281,8 @@ handle_simple_command(struct lkt_state *srv, size_t c, struct lkt_command cmd)
continuation = lkt_get_continuation(srv, c);
if (continuation > 0) {
- LOG_INFO_SCT("NETWORK", "Client should continue from '%d'", continuation);
+ LOG_INFO_SCT("NETWORK", "Client should continue from '%d'",
+ continuation);
send_continue(srv, c, continuation);
}
send_status(srv, c, err, cmd.name);
@@ -400,7 +402,8 @@ handle_outgoing_data(struct lkt_state *srv, size_t c)
return 0;
}
if (errno == EPIPE) {
- LOG_WARN_SCT("NETWORK", "Client %ld is out, free all its messages", c);
+ LOG_WARN_SCT("NETWORK", "Client %ld is out, free all its "
+ "messages", c);
handle_disconnected_client(srv, i);
}
return -1;
@@ -510,7 +513,8 @@ accept_all(int listen_fd, struct pollfd *fds, size_t fds_max, size_t *fds_len)
}
if (*fds_len == fds_max) {
- LOG_ERROR_SCT("NETWORK", "Maximum number '%ld' of file descriptors reached", fds_max);
+ LOG_ERROR_SCT("NETWORK", "Maximum number '%ld' of file descriptors"
+ " reached", fds_max);
break;
}
@@ -574,7 +578,7 @@ handle_network_events(struct lkt_state *srv)
srv->fds[i].fd = -1;
srv->fds[i].revents &= ~ (POLLHUP | POLLERR);
handle_disconnected_client(srv, i);
- printf(" * handle_network_events: client %ld is out: POLLHUP | POOLERR\n", i);
+ LOG_WARN_SCT("NETWORK", "Client %ld is out", i);
continue;
}
if (srv->fds[i].revents & POLLIN) {
@@ -665,7 +669,8 @@ handle_idle_events(struct lkt_state *srv)
strncat(msg->data, "message ", LKT_MESSAGE_MAX - 1);
msg->data_len = strlen(msg->data);
- LOG_INFO_SCT("COMMAND", "Sending '%s' (len: %ld) to client %ld", msg->data, msg->data_len, i);
+ LOG_INFO_SCT("COMMAND", "Sending '%s' (len: %ld) to client %ld",
+ msg->data, msg->data_len, i);
msg->data[msg->data_len - 1] = '\n';
msg->data[msg->data_len] = '\0';
lkt_state_send(srv, i, msg);
diff --git a/src/reg.c b/src/reg.c
index e89570c3..0f847f9b 100644
--- a/src/reg.c
+++ b/src/reg.c
@@ -60,7 +60,8 @@ reg_set(struct module_reg *_reg)
}
int
-load_so(const char *const mod_path, const char *const mod_init, void *mod, struct lkt_state *srv)
+load_so(const char *const mod_path, const char *const mod_init, void *mod,
+ struct lkt_state *srv)
{
/* An init function takes two arguments: the module pointer and a void*
which is the handler for the .so file. It the role of the module to
@@ -74,7 +75,8 @@ load_so(const char *const mod_path, const char *const mod_init, void *mod, struc
if (module_set_function)
return module_set_function(mod, srv, handle);
else {
- LOG_ERROR_SCT("LOAD", "Failed to find init symbol %s in file %s", mod_init, mod_path);
+ LOG_ERROR_SCT("LOAD", "Failed to find init symbol %s "
+ "in file %s", mod_init, mod_path);
return 1;
}
}
@@ -90,8 +92,10 @@ load_module_by_name(struct lkt_state *srv, const char *name, void *mod)
mod_path[0] = '\0';
}
- if (!database_config_get_text(srv->db, name, "load_function", mod_load, INI_MAX_LINE_LEN)) {
- LOG_ERROR_SCT("CONFIG", "Module named %s is incomplete or is not defined in config file", name);
+ if (!database_config_get_text(srv->db, name, "load_function",
+ mod_load, INI_MAX_LINE_LEN)) {
+ LOG_ERROR_SCT("CONFIG", "Module named %s is incomplete or "
+ "is not defined in config file", name);
return 1;
}
diff --git a/src/stack.c b/src/stack.c
index a2d40eaf..683a54db 100644
--- a/src/stack.c
+++ b/src/stack.c
@@ -51,7 +51,8 @@ stack_push(struct stack *lst, void *item)
return 1;
if (lst->size == lst->len) {
- volatile void **new = realloc(lst->contents, lst->size * 2 * sizeof(void *));
+ volatile void **new = realloc(lst->contents,
+ lst->size * 2 * sizeof(void *));
if (NULL == new)
return 1;
diff --git a/src/uri.c b/src/uri.c
index 4f6fe569..20c9119c 100644
--- a/src/uri.c
+++ b/src/uri.c
@@ -113,7 +113,8 @@ __lkt_to_str(struct lkt_uri *uri, char *ret, size_t len)
safe_snprintf(ret, len, "search=%s", (char *) uri->value);
break;
default:
- LOG_ERROR("URI type %d may not be supported by kurisu, generate an error", uri->type);
+ LOG_ERROR("URI type %d may not be supported by kurisu, generate "
+ "an error", uri->type);
return 1;
}
--
GitLab