/*
* List users (searchstring may be empty to list all users)
*/
void cmd_list(char *cmdbuf)
{
char searchstring[256];
extract_token(searchstring, cmdbuf, 0, '|', sizeof searchstring);
striplt(searchstring);
cprintf("%d \n", LISTING_FOLLOWS);
ForEachUser(ListThisUser, (void *)searchstring );
cprintf("000\n");
}
/*
* check_control - check the control record has sensible values for message, user and room numbers
*/
void check_control(void)
{
syslog(LOG_INFO, "Checking/re-building control record\n");
get_control();
// Find highest room number and message number.
CtdlForEachRoom(control_find_highest, NULL);
ForEachUser(control_find_user, NULL);
put_control();
}
std::vector<Instruction*> DefUseManager::GetAnnotations(uint32_t id) const {
std::vector<Instruction*> annos;
const Instruction* def = GetDef(id);
if (!def) return annos;
ForEachUser(def, [&annos](Instruction* user) {
if (IsAnnotationInst(user->opcode())) {
annos.push_back(user);
}
});
return annos;
}
int PurgeRooms(void) {
struct PurgeList *pptr;
int num_rooms_purged = 0;
struct ctdlroom qrbuf;
struct ValidUser *vuptr;
char *transcript = NULL;
syslog(LOG_DEBUG, "PurgeRooms() called");
/* Load up a table full of valid user numbers so we can delete
* user-owned rooms for users who no longer exist */
ForEachUser(AddValidUser, NULL);
/* Then cycle through the room file */
CtdlForEachRoom(DoPurgeRooms, NULL);
/* Free the valid user list */
while (ValidUserList != NULL) {
vuptr = ValidUserList->next;
free(ValidUserList);
ValidUserList = vuptr;
}
transcript = malloc(SIZ);
strcpy(transcript, "The following rooms have been auto-purged:\n");
while (RoomPurgeList != NULL) {
if (CtdlGetRoom(&qrbuf, RoomPurgeList->name) == 0) {
transcript=realloc(transcript, strlen(transcript)+SIZ);
snprintf(&transcript[strlen(transcript)], SIZ, " %s\n",
qrbuf.QRname);
CtdlDeleteRoom(&qrbuf);
}
pptr = RoomPurgeList->next;
free(RoomPurgeList);
RoomPurgeList = pptr;
++num_rooms_purged;
}
if (num_rooms_purged > 0) CtdlAideMessage(transcript, "Room Autopurger Message");
free(transcript);
syslog(LOG_DEBUG, "Purged %d rooms.", num_rooms_purged);
return(num_rooms_purged);
}
/*
* Purge visits
*
* This is a really cumbersome "garbage collection" function. We have to
* delete visits which refer to rooms and/or users which no longer exist. In
* order to prevent endless traversals of the room and user files, we first
* build linked lists of rooms and users which _do_ exist on the system, then
* traverse the visit file, checking each record against those two lists and
* purging the ones that do not have a match on _both_ lists. (Remember, if
* either the room or user being referred to is no longer on the system, the
* record is completely useless.)
*/
int PurgeVisits(void) {
struct cdbdata *cdbvisit;
visit vbuf;
struct VPurgeList *VisitPurgeList = NULL;
struct VPurgeList *vptr;
int purged = 0;
char IndexBuf[32];
int IndexLen;
struct ValidRoom *vrptr;
struct ValidUser *vuptr;
int RoomIsValid, UserIsValid;
/* First, load up a table full of valid room/gen combinations */
CtdlForEachRoom(AddValidRoom, NULL);
/* Then load up a table full of valid user numbers */
ForEachUser(AddValidUser, NULL);
/* Now traverse through the visits, purging irrelevant records... */
cdb_rewind(CDB_VISIT);
while(cdbvisit = cdb_next_item(CDB_VISIT), cdbvisit != NULL) {
memset(&vbuf, 0, sizeof(visit));
memcpy(&vbuf, cdbvisit->ptr,
( (cdbvisit->len > sizeof(visit)) ?
sizeof(visit) : cdbvisit->len) );
cdb_free(cdbvisit);
RoomIsValid = 0;
UserIsValid = 0;
/* Check to see if the room exists */
for (vrptr=ValidRoomList; vrptr!=NULL; vrptr=vrptr->next) {
if ( (vrptr->vr_roomnum==vbuf.v_roomnum)
&& (vrptr->vr_roomgen==vbuf.v_roomgen))
RoomIsValid = 1;
}
/* Check to see if the user exists */
for (vuptr=ValidUserList; vuptr!=NULL; vuptr=vuptr->next) {
if (vuptr->vu_usernum == vbuf.v_usernum)
UserIsValid = 1;
}
/* Put the record on the purge list if it's dead */
if ((RoomIsValid==0) || (UserIsValid==0)) {
vptr = (struct VPurgeList *)
malloc(sizeof(struct VPurgeList));
vptr->next = VisitPurgeList;
vptr->vp_roomnum = vbuf.v_roomnum;
vptr->vp_roomgen = vbuf.v_roomgen;
vptr->vp_usernum = vbuf.v_usernum;
VisitPurgeList = vptr;
}
}
/* Free the valid room/gen combination list */
while (ValidRoomList != NULL) {
vrptr = ValidRoomList->next;
free(ValidRoomList);
ValidRoomList = vrptr;
}
/* Free the valid user list */
while (ValidUserList != NULL) {
vuptr = ValidUserList->next;
free(ValidUserList);
ValidUserList = vuptr;
}
/* Now delete every visit on the purged list */
while (VisitPurgeList != NULL) {
IndexLen = GenerateRelationshipIndex(IndexBuf,
VisitPurgeList->vp_roomnum,
VisitPurgeList->vp_roomgen,
VisitPurgeList->vp_usernum);
cdb_delete(CDB_VISIT, IndexBuf, IndexLen);
vptr = VisitPurgeList->next;
free(VisitPurgeList);
VisitPurgeList = vptr;
++purged;
}
return(purged);
}
int PurgeUsers(void) {
struct PurgeList *pptr;
int num_users_purged = 0;
char *transcript = NULL;
syslog(LOG_DEBUG, "PurgeUsers() called");
users_not_purged = 0;
switch(config.c_auth_mode) {
case AUTHMODE_NATIVE:
ForEachUser(do_user_purge, NULL);
break;
case AUTHMODE_HOST:
ForEachUser(do_uid_user_purge, NULL);
break;
default:
syslog(LOG_DEBUG, "User purge for auth mode %d is not implemented.",
config.c_auth_mode);
break;
}
transcript = malloc(SIZ);
if (users_not_purged == 0) {
strcpy(transcript, "The auto-purger was told to purge every user. It is\n"
"refusing to do this because it usually indicates a problem\n"
"such as an inability to communicate with a name service.\n"
);
while (UserPurgeList != NULL) {
pptr = UserPurgeList->next;
free(UserPurgeList);
UserPurgeList = pptr;
++num_users_purged;
}
}
else {
strcpy(transcript, "The following users have been auto-purged:\n");
while (UserPurgeList != NULL) {
transcript=realloc(transcript, strlen(transcript)+SIZ);
snprintf(&transcript[strlen(transcript)], SIZ, " %s\n",
UserPurgeList->name);
purge_user(UserPurgeList->name);
pptr = UserPurgeList->next;
free(UserPurgeList);
UserPurgeList = pptr;
++num_users_purged;
}
}
if (num_users_purged > 0) CtdlAideMessage(transcript, "User Purge Message");
free(transcript);
if(users_corrupt_msg)
{
CtdlAideMessage(users_corrupt_msg, "User Corruption Message");
free (users_corrupt_msg);
users_corrupt_msg = NULL;
}
if(users_zero_msg)
{
CtdlAideMessage(users_zero_msg, "User Zero Message");
free (users_zero_msg);
users_zero_msg = NULL;
}
syslog(LOG_DEBUG, "Purged %d users.", num_users_purged);
return(num_users_purged);
}
uint32_t DefUseManager::NumUsers(const Instruction* def) const {
uint32_t count = 0;
ForEachUser(def, [&count](Instruction*) { ++count; });
return count;
}
void DefUseManager::ForEachUser(
uint32_t id, const std::function<void(Instruction*)>& f) const {
ForEachUser(GetDef(id), f);
}
void SaveUsers(void)
{
ForEachUser(SaveEachUser);
}
