diff --git a/packages/redis/fix-deps-lua.patch b/packages/redis/fix-deps-lua.patch new file mode 100644 index 000000000..6598ac1f8 --- /dev/null +++ b/packages/redis/fix-deps-lua.patch @@ -0,0 +1,24 @@ +diff -uNr redis-6.0.1/deps/lua/src/luaconf.h redis-6.0.1.mod/deps/lua/src/luaconf.h +--- redis-6.0.1/deps/lua/src/luaconf.h 2020-05-02 01:10:20.000000000 +0300 ++++ redis-6.0.1.mod/deps/lua/src/luaconf.h 2020-05-13 12:58:07.276076703 +0300 +@@ -94,7 +94,7 @@ + ".\\?.dll;" LUA_CDIR"?.dll;" LUA_CDIR"loadall.dll" + + #else +-#define LUA_ROOT "/usr/local/" ++#define LUA_ROOT "@TERMUX_PREFIX@" + #define LUA_LDIR LUA_ROOT "share/lua/5.1/" + #define LUA_CDIR LUA_ROOT "lib/lua/5.1/" + #define LUA_PATH_DEFAULT \ +@@ -645,9 +645,9 @@ + + #if defined(LUA_USE_MKSTEMP) + #include +-#define LUA_TMPNAMBUFSIZE 32 ++#define LUA_TMPNAMBUFSIZE 256 + #define lua_tmpnam(b,e) { \ +- strcpy(b, "/tmp/lua_XXXXXX"); \ ++ strcpy(b, "@TERMUX_PREFIX@/tmp/lua_XXXXXX"); \ + e = mkstemp(b); \ + if (e != -1) close(e); \ + e = (e == -1); } diff --git a/packages/redis/fix-user-redef.patch b/packages/redis/fix-user-redef.patch new file mode 100644 index 000000000..139c12798 --- /dev/null +++ b/packages/redis/fix-user-redef.patch @@ -0,0 +1,432 @@ +diff -uNr redis-6.0.1/src/acl.c redis-6.0.1.mod/src/acl.c +--- redis-6.0.1/src/acl.c 2020-05-02 01:10:20.000000000 +0300 ++++ redis-6.0.1.mod/src/acl.c 2020-05-13 13:06:20.789831765 +0300 +@@ -38,7 +38,7 @@ + + rax *Users; /* Table mapping usernames to user structures. */ + +-user *DefaultUser; /* Global reference to the default user. ++rduser *DefaultUser; /* Global reference to the default user. + Every new connection is associated to it, if no + AUTH or HELLO is used to authenticate with a + different user. */ +@@ -93,9 +93,9 @@ + {NULL,0} /* Terminator. */ + }; + +-void ACLResetSubcommandsForCommand(user *u, unsigned long id); +-void ACLResetSubcommands(user *u); +-void ACLAddAllowedSubcommand(user *u, unsigned long id, const char *sub); ++void ACLResetSubcommandsForCommand(rduser *u, unsigned long id); ++void ACLResetSubcommands(rduser *u); ++void ACLAddAllowedSubcommand(rduser *u, unsigned long id, const char *sub); + void ACLFreeLogEntry(void *le); + + /* The length of the string representation of a hashed password. */ +@@ -214,9 +214,9 @@ + * the structure representing the user. + * + * If the user with such name already exists NULL is returned. */ +-user *ACLCreateUser(const char *name, size_t namelen) { ++rduser *ACLCreateUser(const char *name, size_t namelen) { + if (raxFind(Users,(unsigned char*)name,namelen) != raxNotFound) return NULL; +- user *u = zmalloc(sizeof(*u)); ++ rduser *u = zmalloc(sizeof(*u)); + u->name = sdsnewlen(name,namelen); + u->flags = USER_FLAG_DISABLED; + u->allowed_subcommands = NULL; +@@ -237,11 +237,11 @@ + * we can use in order to validate ACL rules or for other similar reasons. + * The user will not get linked to the Users radix tree. The returned + * user should be released with ACLFreeUser() as usually. */ +-user *ACLCreateUnlinkedUser(void) { ++rduser *ACLCreateUnlinkedUser(void) { + char username[64]; + for (int j = 0; ; j++) { + snprintf(username,sizeof(username),"__fakeuser:%d__",j); +- user *fakeuser = ACLCreateUser(username,strlen(username)); ++ rduser *fakeuser = ACLCreateUser(username,strlen(username)); + if (fakeuser == NULL) continue; + int retval = raxRemove(Users,(unsigned char*) username, + strlen(username),NULL); +@@ -252,7 +252,7 @@ + + /* Release the memory used by the user structure. Note that this function + * will not remove the user from the Users global radix tree. */ +-void ACLFreeUser(user *u) { ++void ACLFreeUser(rduser *u) { + sdsfree(u->name); + listRelease(u->passwords); + listRelease(u->patterns); +@@ -263,7 +263,7 @@ + /* When a user is deleted we need to cycle the active + * connections in order to kill all the pending ones that + * are authenticated with such user. */ +-void ACLFreeUserAndKillClients(user *u) { ++void ACLFreeUserAndKillClients(rduser *u) { + listIter li; + listNode *ln; + listRewind(server.clients,&li); +@@ -287,7 +287,7 @@ + /* Copy the user ACL rules from the source user 'src' to the destination + * user 'dst' so that at the end of the process they'll have exactly the + * same rules (but the names will continue to be the original ones). */ +-void ACLCopyUser(user *dst, user *src) { ++void ACLCopyUser(rduser *dst, rduser *src) { + listRelease(dst->passwords); + listRelease(dst->patterns); + dst->passwords = listDup(src->passwords); +@@ -336,7 +336,7 @@ + * + * If the bit overflows the user internal representation, zero is returned + * in order to disallow the execution of the command in such edge case. */ +-int ACLGetUserCommandBit(user *u, unsigned long id) { ++int ACLGetUserCommandBit(rduser *u, unsigned long id) { + uint64_t word, bit; + if (ACLGetCommandBitCoordinates(id,&word,&bit) == C_ERR) return 0; + return (u->allowed_commands[word] & bit) != 0; +@@ -345,7 +345,7 @@ + /* When +@all or allcommands is given, we set a reserved bit as well that we + * can later test, to see if the user has the right to execute "future commands", + * that is, commands loaded later via modules. */ +-int ACLUserCanExecuteFutureCommands(user *u) { ++int ACLUserCanExecuteFutureCommands(rduser *u) { + return ACLGetUserCommandBit(u,USER_COMMAND_BITS_COUNT-1); + } + +@@ -354,7 +354,7 @@ + * is performed. As a side effect of calling this function with a value of + * zero, the user flag ALLCOMMANDS is cleared since it is no longer possible + * to skip the command bit explicit test. */ +-void ACLSetUserCommandBit(user *u, unsigned long id, int value) { ++void ACLSetUserCommandBit(rduser *u, unsigned long id, int value) { + uint64_t word, bit; + if (value == 0) u->flags &= ~USER_FLAG_ALLCOMMANDS; + if (ACLGetCommandBitCoordinates(id,&word,&bit) == C_ERR) return; +@@ -370,7 +370,7 @@ + * value. Since the category passed by the user may be non existing, the + * function returns C_ERR if the category was not found, or C_OK if it was + * found and the operation was performed. */ +-int ACLSetUserCommandBitsForCategory(user *u, const char *category, int value) { ++int ACLSetUserCommandBitsForCategory(rduser *u, const char *category, int value) { + uint64_t cflag = ACLGetCommandCategoryFlagByName(category); + if (!cflag) return C_ERR; + dictIterator *di = dictGetIterator(server.orig_commands); +@@ -391,7 +391,7 @@ + * in the subset of commands flagged with the specified category name. + * If the category name is not valid, C_ERR is returned, otherwise C_OK is + * returned and on and off are populated by reference. */ +-int ACLCountCategoryBitsForUser(user *u, unsigned long *on, unsigned long *off, ++int ACLCountCategoryBitsForUser(rduser *u, unsigned long *on, unsigned long *off, + const char *category) + { + uint64_t cflag = ACLGetCommandCategoryFlagByName(category); +@@ -420,7 +420,7 @@ + * as on/off, passwords and so forth. The returned string always starts with + * the +@all or -@all rule, depending on the user bitmap, and is followed, if + * needed, by the other rules needed to narrow or extend what the user can do. */ +-sds ACLDescribeUserCommandRules(user *u) { ++sds ACLDescribeUserCommandRules(rduser *u) { + sds rules = sdsempty(); + int additive; /* If true we start from -@all and add, otherwise if + false we start from +@all and remove. */ +@@ -428,8 +428,8 @@ + /* This code is based on a trick: as we generate the rules, we apply + * them to a fake user, so that as we go we still know what are the + * bit differences we should try to address by emitting more rules. */ +- user fu = {0}; +- user *fakeuser = &fu; ++ rduser fu = {0}; ++ rduser *fakeuser = &fu; + + /* Here we want to understand if we should start with +@all and remove + * the commands corresponding to the bits that are not set in the user +@@ -520,7 +520,7 @@ + * the ACLDescribeUserCommandRules() function. This is the function we call + * when we want to rewrite the configuration files describing ACLs and + * in order to show users with ACL LIST. */ +-sds ACLDescribeUser(user *u) { ++sds ACLDescribeUser(rduser *u) { + sds res = sdsempty(); + + /* Flags. */ +@@ -579,7 +579,7 @@ + + /* Flush the array of allowed subcommands for the specified user + * and command ID. */ +-void ACLResetSubcommandsForCommand(user *u, unsigned long id) { ++void ACLResetSubcommandsForCommand(rduser *u, unsigned long id) { + if (u->allowed_subcommands && u->allowed_subcommands[id]) { + for (int i = 0; u->allowed_subcommands[id][i]; i++) + sdsfree(u->allowed_subcommands[id][i]); +@@ -591,7 +591,7 @@ + /* Flush the entire table of subcommands. This is useful on +@all, -@all + * or similar to return back to the minimal memory usage (and checks to do) + * for the user. */ +-void ACLResetSubcommands(user *u) { ++void ACLResetSubcommands(rduser *u) { + if (u->allowed_subcommands == NULL) return; + for (int j = 0; j < USER_COMMAND_BITS_COUNT; j++) { + if (u->allowed_subcommands[j]) { +@@ -607,7 +607,7 @@ + + /* Add a subcommand to the list of subcommands for the user 'u' and + * the command id specified. */ +-void ACLAddAllowedSubcommand(user *u, unsigned long id, const char *sub) { ++void ACLAddAllowedSubcommand(rduser *u, unsigned long id, const char *sub) { + /* If this is the first subcommand to be configured for + * this user, we have to allocate the subcommands array. */ + if (u->allowed_subcommands == NULL) { +@@ -714,7 +714,7 @@ + * ENODEV: The password you are trying to remove from the user does not exist. + * EBADMSG: The hash you are trying to add is not a valid hash. + */ +-int ACLSetUser(user *u, const char *op, ssize_t oplen) { ++int ACLSetUser(rduser *u, const char *op, ssize_t oplen) { + if (oplen == -1) oplen = strlen(op); + if (!strcasecmp(op,"on")) { + u->flags |= USER_FLAG_ENABLED; +@@ -943,7 +943,7 @@ + * ENONENT: if the specified user does not exist at all. + */ + int ACLCheckUserCredentials(robj *username, robj *password) { +- user *u = ACLGetUserByName(username->ptr,sdslen(username->ptr)); ++ rduser *u = ACLGetUserByName(username->ptr,sdslen(username->ptr)); + if (u == NULL) { + errno = ENOENT; + return C_ERR; +@@ -1033,7 +1033,7 @@ + } + + /* Return an username by its name, or NULL if the user does not exist. */ +-user *ACLGetUserByName(const char *name, size_t namelen) { ++rduser *ACLGetUserByName(const char *name, size_t namelen) { + void *myuser = raxFind(Users,(unsigned char*)name,namelen); + if (myuser == raxNotFound) return NULL; + return myuser; +@@ -1049,7 +1049,7 @@ + * command, the second if the command is denied because the user is trying + * to access keys that are not among the specified patterns. */ + int ACLCheckCommandPerm(client *c, int *keyidxptr) { +- user *u = c->user; ++ rduser *u = c->user; + uint64_t id = c->cmd->id; + + /* If there is no associated user, the connection can run anything. */ +@@ -1151,7 +1151,7 @@ + + /* Try to apply the user rules in a fake user to see if they + * are actually valid. */ +- user *fakeuser = ACLCreateUnlinkedUser(); ++ rduser *fakeuser = ACLCreateUnlinkedUser(); + + for (int j = 2; j < argc; j++) { + if (ACLSetUser(fakeuser,argv[j],sdslen(argv[j])) == C_ERR) { +@@ -1188,7 +1188,7 @@ + return C_ERR; + } + +- user *u = ACLCreateUser(username,sdslen(username)); ++ rduser *u = ACLCreateUser(username,sdslen(username)); + if (!u) { + u = ACLGetUserByName(username,sdslen(username)); + serverAssert(u != NULL); +@@ -1267,13 +1267,13 @@ + + /* We need a fake user to validate the rules before making changes + * to the real user mentioned in the ACL line. */ +- user *fakeuser = ACLCreateUnlinkedUser(); ++ rduser *fakeuser = ACLCreateUnlinkedUser(); + + /* We do all the loading in a fresh instance of the Users radix tree, + * so if there are errors loading the ACL file we can rollback to the + * old version. */ + rax *old_users = Users; +- user *old_default_user = DefaultUser; ++ rduser *old_default_user = DefaultUser; + Users = raxNew(); + ACLInitDefaultUser(); + +@@ -1345,7 +1345,7 @@ + + /* We can finally lookup the user and apply the rule. If the + * user already exists we always reset it to start. */ +- user *u = ACLCreateUser(argv[1],sdslen(argv[1])); ++ rduser *u = ACLCreateUser(argv[1],sdslen(argv[1])); + if (!u) { + u = ACLGetUserByName(argv[1],sdslen(argv[1])); + serverAssert(u != NULL); +@@ -1369,7 +1369,7 @@ + /* The default user pointer is referenced in different places: instead + * of replacing such occurrences it is much simpler to copy the new + * default user configuration in the old one. */ +- user *new = ACLGetUserByName("default",7); ++ rduser *new = ACLGetUserByName("default",7); + serverAssert(new != NULL); + ACLCopyUser(DefaultUser,new); + ACLFreeUser(new); +@@ -1401,7 +1401,7 @@ + raxStart(&ri,Users); + raxSeek(&ri,"^",NULL,0); + while(raxNext(&ri)) { +- user *u = ri.data; ++ rduser *u = ri.data; + /* Return information in the configuration file format. */ + sds user = sdsnew("user "); + user = sdscatsds(user,u->name); +@@ -1641,8 +1641,8 @@ + * before applying to an existing user or creating a new user. If all + * arguments are valid the user parameters will all be applied together. + * If there are any errors then none of the changes will be applied. */ +- user *tempu = ACLCreateUnlinkedUser(); +- user *u = ACLGetUserByName(username,sdslen(username)); ++ rduser *tempu = ACLCreateUnlinkedUser(); ++ rduser *u = ACLGetUserByName(username,sdslen(username)); + if (u) ACLCopyUser(tempu, u); + + for (int j = 3; j < c->argc; j++) { +@@ -1675,7 +1675,7 @@ + + for (int j = 2; j < c->argc; j++) { + sds username = c->argv[j]->ptr; +- user *u; ++ rduser *u; + if (raxRemove(Users,(unsigned char*)username, + sdslen(username), + (void**)&u)) +@@ -1686,7 +1686,7 @@ + } + addReplyLongLong(c,deleted); + } else if (!strcasecmp(sub,"getuser") && c->argc == 3) { +- user *u = ACLGetUserByName(c->argv[2]->ptr,sdslen(c->argv[2]->ptr)); ++ rduser *u = ACLGetUserByName(c->argv[2]->ptr,sdslen(c->argv[2]->ptr)); + if (u == NULL) { + addReplyNull(c); + return; +@@ -1746,7 +1746,7 @@ + raxStart(&ri,Users); + raxSeek(&ri,"^",NULL,0); + while(raxNext(&ri)) { +- user *u = ri.data; ++ rduser *u = ri.data; + if (justnames) { + addReplyBulkCBuffer(c,u->name,sdslen(u->name)); + } else { +diff -uNr redis-6.0.1/src/config.c redis-6.0.1.mod/src/config.c +--- redis-6.0.1/src/config.c 2020-05-02 01:10:20.000000000 +0300 ++++ redis-6.0.1.mod/src/config.c 2020-05-13 13:02:29.309037552 +0300 +@@ -1238,7 +1238,7 @@ + raxStart(&ri,Users); + raxSeek(&ri,"^",NULL,0); + while(raxNext(&ri)) { +- user *u = ri.data; ++ rduser *u = ri.data; + sds line = sdsnew("user "); + line = sdscatsds(line,u->name); + line = sdscatlen(line," ",1); +diff -uNr redis-6.0.1/src/module.c redis-6.0.1.mod/src/module.c +--- redis-6.0.1/src/module.c 2020-05-02 01:10:20.000000000 +0300 ++++ redis-6.0.1.mod/src/module.c 2020-05-13 13:03:22.169208993 +0300 +@@ -366,7 +366,7 @@ + * able to create users, set ACLs to such users, and later authenticate + * clients using such newly created users. */ + typedef struct RedisModuleUser { +- user *user; /* Reference to the real redis user */ ++ rduser *user; /* Reference to the real redis user */ + } RedisModuleUser; + + +@@ -5482,7 +5482,7 @@ + * For expensive authentication operations, it is recommended to block the + * client and do the authentication in the background and then attach the user + * to the client in a threadsafe context. */ +-static int authenticateClientWithUser(RedisModuleCtx *ctx, user *user, RedisModuleUserChangedFunc callback, void *privdata, uint64_t *client_id) { ++static int authenticateClientWithUser(RedisModuleCtx *ctx, rduser *user, RedisModuleUserChangedFunc callback, void *privdata, uint64_t *client_id) { + if (user->flags & USER_FLAG_DISABLED) { + return REDISMODULE_ERR; + } +@@ -5521,7 +5521,7 @@ + * See authenticateClientWithUser for information about callback, client_id, + * and general usage for authentication. */ + int RM_AuthenticateClientWithACLUser(RedisModuleCtx *ctx, const char *name, size_t len, RedisModuleUserChangedFunc callback, void *privdata, uint64_t *client_id) { +- user *acl_user = ACLGetUserByName(name, len); ++ rduser *acl_user = ACLGetUserByName(name, len); + + if (!acl_user) { + return REDISMODULE_ERR; +diff -uNr redis-6.0.1/src/networking.c redis-6.0.1.mod/src/networking.c +--- redis-6.0.1/src/networking.c 2020-05-02 01:10:20.000000000 +0300 ++++ redis-6.0.1.mod/src/networking.c 2020-05-13 13:01:50.424915874 +0300 +@@ -2121,7 +2121,7 @@ + /* CLIENT KILL + * CLIENT KILL