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