/*
* Server functions which perform operations on room objects.
*
- * Copyright (c) 1987-2011 by the citadel.org team
+ * Copyright (c) 1987-2012 by the citadel.org team
*
* This program is open source software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 3 of the License, or
- * (at your option) any later version.
+ * it under the terms of the GNU General Public License, version 3.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "sysdep.h"
struct floor *floorcache[MAXFLOORS];
+/*
+ * Determine whether the currently logged in session has permission to read
+ * messages in the current room.
+ */
+int CtdlDoIHavePermissionToReadMessagesInThisRoom(void) {
+ if ( (!(CC->logged_in))
+ && (!(CC->internal_pgm))
+ && (!config.c_guest_logins)
+ ) {
+ return(om_not_logged_in);
+ }
+ return(om_ok);
+}
+
+/*
+ * Check to see whether we have permission to post a message in the current
+ * room. Returns a *CITADEL ERROR CODE* and puts a message in errmsgbuf, or
+ * returns 0 on success.
+ */
+int CtdlDoIHavePermissionToPostInThisRoom(
+ char *errmsgbuf,
+ size_t n,
+ const char* RemoteIdentifier,
+ PostType PostPublic,
+ int is_reply
+ ) {
+ int ra;
+
+ if (!(CC->logged_in) &&
+ (PostPublic == POST_LOGGED_IN)) {
+ snprintf(errmsgbuf, n, "Not logged in.");
+ return (ERROR + NOT_LOGGED_IN);
+ }
+ else if (PostPublic == CHECK_EXISTANCE) {
+ return (0); // We're Evaling whether a recipient exists
+ }
+ else if (!(CC->logged_in)) {
+
+ if ((CC->room.QRflags & QR_READONLY)) {
+ snprintf(errmsgbuf, n, "Not logged in.");
+ return (ERROR + NOT_LOGGED_IN);
+ }
+ if (CC->room.QRflags2 & QR2_MODERATED) {
+ snprintf(errmsgbuf, n, "Not logged in Moderation feature not yet implemented!");
+ return (ERROR + NOT_LOGGED_IN);
+ }
+ if ((PostPublic!=POST_LMTP) &&(CC->room.QRflags2 & QR2_SMTP_PUBLIC) == 0) {
+
+ return CtdlNetconfigCheckRoomaccess(errmsgbuf, n, RemoteIdentifier);
+ }
+ return (0);
+
+ }
+
+ if ((CC->user.axlevel < AxProbU)
+ && ((CC->room.QRflags & QR_MAILBOX) == 0)) {
+ snprintf(errmsgbuf, n, "Need to be validated to enter (except in %s> to sysop)", MAILROOM);
+ return (ERROR + HIGHER_ACCESS_REQUIRED);
+ }
+
+ CtdlRoomAccess(&CC->room, &CC->user, &ra, NULL);
+
+ if (ra & UA_POSTALLOWED) {
+ strcpy(errmsgbuf, "OK to post or reply here");
+ return(0);
+ }
+
+ if ( (ra & UA_REPLYALLOWED) && (is_reply) ) {
+ /*
+ * To be thorough, we ought to check to see if the message they are
+ * replying to is actually a valid one in this room, but unless this
+ * actually becomes a problem we'll go with high performance instead.
+ */
+ strcpy(errmsgbuf, "OK to reply here");
+ return(0);
+ }
+
+ if ( (ra & UA_REPLYALLOWED) && (!is_reply) ) {
+ /* Clarify what happened with a better error message */
+ snprintf(errmsgbuf, n, "You may only reply to existing messages here.");
+ return (ERROR + HIGHER_ACCESS_REQUIRED);
+ }
+
+ snprintf(errmsgbuf, n, "Higher access is required to post in this room.");
+ return (ERROR + HIGHER_ACCESS_REQUIRED);
+
+}
+
+/*
+ * Check whether the current user has permission to delete messages from
+ * the current room (returns 1 for yes, 0 for no)
+ */
+int CtdlDoIHavePermissionToDeleteMessagesFromThisRoom(void) {
+ int ra;
+ CtdlRoomAccess(&CC->room, &CC->user, &ra, NULL);
+ if (ra & UA_DELETEALLOWED) return(1);
+ return(0);
+}
+
/*
* Retrieve access control information for any user/room pair
*/
if (view != NULL) *view = vbuf.v_view;
}
+
/*
* Self-checking stuff for a room record read into memory
*/
/*
* CtdlGetRoom() - retrieve room data from disk
*/
-int CtdlGetRoom(struct ctdlroom *qrbuf, char *room_name)
+int CtdlGetRoom(struct ctdlroom *qrbuf, const char *room_name)
{
struct cdbdata *cdbqr;
char lowercase_name[ROOMNAMELEN];
char personal_lowercase_name[ROOMNAMELEN];
- char *dptr, *sptr, *eptr;
+ const char *sptr;
+ char *dptr, *eptr;
dptr = lowercase_name;
sptr = room_name;
len = bptr - lowercase_name;
if (qrbuf == NULL) {
- cdb_delete(CDB_ROOMS,
- lowercase_name, len);
+ cdb_delete(CDB_ROOMS, lowercase_name, len);
} else {
time(&qrbuf->QRmtime);
- cdb_store(CDB_ROOMS,
- lowercase_name, len,
- qrbuf, sizeof(struct ctdlroom));
+ cdb_store(CDB_ROOMS, lowercase_name, len, qrbuf, sizeof(struct ctdlroom));
}
}
}
-
/*
* CtdlPutRoomLock() - same as CtdlPutRoom() but unlocks the record (if supported)
*/
}
-/****************************************************************************/
-
/*
* CtdlGetFloorByName() - retrieve the number of the named floor
}
-
/*
* CtdlGetFloorByNameLock() - retrieve floor number for given floor and lock the floor list.
*/
}
+
/*
* lgetfloor() - same as CtdlGetFloor() but locks the record (if supported)
*/
}
-
/*
* CtdlPutFloor() - store floor data on disk
*/
}
-
/*
* CtdlPutFloorLock() - same as CtdlPutFloor() but unlocks the record (if supported)
*/
}
-
/*
* lputfloor() - same as CtdlPutFloor() but unlocks the record (if supported)
*/
/*
* Traverse the room file...
*/
-void CtdlForEachRoom(void (*CallBack) (struct ctdlroom *EachRoom, void *out_data),
- void *in_data)
+void CtdlForEachRoom(ForEachRoomCallBack CB, void *in_data)
{
struct ctdlroom qrbuf;
struct cdbdata *cdbqr;
memset(&qrbuf, 0, sizeof(struct ctdlroom));
memcpy(&qrbuf, cdbqr->ptr,
((cdbqr->len > sizeof(struct ctdlroom)) ?
- sizeof(struct ctdlroom) : cdbqr->len));
+ sizeof(struct ctdlroom) : cdbqr->len)
+ );
+ cdb_free(cdbqr);
+ room_sanity_check(&qrbuf);
+ if (qrbuf.QRflags & QR_INUSE) {
+ CB(&qrbuf, in_data);
+ }
+ }
+}
+
+/*
+ * Traverse the room file...
+ */
+void CtdlForEachNetCfgRoom(ForEachRoomNetCfgCallBack CB,
+ void *in_data,
+ RoomNetCfg filter)
+{
+ struct ctdlroom qrbuf;
+ struct cdbdata *cdbqr;
+
+ cdb_rewind(CDB_ROOMS);
+
+ while (cdbqr = cdb_next_item(CDB_ROOMS), cdbqr != NULL) {
+ memset(&qrbuf, 0, sizeof(struct ctdlroom));
+ memcpy(&qrbuf, cdbqr->ptr,
+ ((cdbqr->len > sizeof(struct ctdlroom)) ?
+ sizeof(struct ctdlroom) : cdbqr->len)
+ );
cdb_free(cdbqr);
room_sanity_check(&qrbuf);
if (qrbuf.QRflags & QR_INUSE)
- (*CallBack)(&qrbuf, in_data);
+ {
+ OneRoomNetCfg* RNCfg;
+ RNCfg = CtdlGetNetCfgForRoom(qrbuf.QRnumber);
+ if ((RNCfg != NULL) &&
+ ((filter == maxRoomNetCfg) ||
+ (RNCfg->NetConfigs[filter] != NULL)))
+ {
+ CB(&qrbuf, in_data, RNCfg);
+ }
+ }
}
}
struct cdbdata *cdbml;
/* Make sure the msglist we're deleting actually exists, otherwise
- * gdbm will complain when we try to delete an invalid record
+ * libdb will complain when we try to delete an invalid record
*/
cdbml = cdb_fetch(CDB_MSGLISTS, &whichroom->QRnumber, sizeof(long));
if (cdbml != NULL) {
}
-
/*
* Message pointer compare function for sort_msglist()
*/
int sort_msglist(long listptrs[], int oldcount)
{
int numitems;
+ int i = 0;
numitems = oldcount;
if (numitems < 2) {
qsort(listptrs, numitems, sizeof(long), sort_msglist_cmp);
/* and yank any nulls */
- while ((numitems > 0) && (listptrs[0] == 0L)) {
- memmove(&listptrs[0], &listptrs[1],
- (sizeof(long) * (numitems - 1)));
- --numitems;
+ while ((i < numitems) && (listptrs[i] == 0L)) i++;
+
+ if (i > 0)
+ {
+ memmove(&listptrs[0], &listptrs[i], (sizeof(long) * (numitems - i)));
+ numitems-=i;
}
return (numitems);
}
-
/*
* Back-back-end for all room listing commands
*/
CCC->curr_view = (int)vbuf.v_view;
if (display_result) {
- cprintf("%d%c%s|%d|%d|%d|%d|%ld|%ld|%d|%d|%d|%d|%d|%d|%d|%d|\n",
+ cprintf("%d%c%s|%d|%d|%d|%d|%ld|%ld|%d|%d|%d|%d|%d|%d|%d|%d|%ld|\n",
CIT_OK, CtdlCheckExpress(),
truncated_roomname,
(int)new_messages,
(int)vbuf.v_view,
(int)CCC->room.QRdefaultview,
(int)is_trash,
- (int)CCC->room.QRflags2
+ (int)CCC->room.QRflags2,
+ (long)CCC->room.QRmtime
);
}
}
}
/*
- * get room parameters (aide or room aide command)
+ * get room parameters (admin or room admin command)
*/
void cmd_getr(char *cmdbuf)
{
/*
- * set room parameters (aide or room aide command)
+ * set room parameters (admin or room admin command)
*/
void cmd_setr(char *args)
{
/*
- * get the name of the room aide for this room
+ * get the name of the room admin for this room
*/
void cmd_geta(char *cmdbuf)
{
/*
- * set the room aide for this room
+ * set the room admin for this room
*/
void cmd_seta(char *new_ra)
{
if (post_notice == 1) {
if (!IsEmptyStr(usbuf.fullname))
snprintf(buf, sizeof buf,
- "%s is now the room aide for \"%s\".\n",
+ "%s is now the room admin for \"%s\".\n",
usbuf.fullname, CC->room.QRname);
else
snprintf(buf, sizeof buf,
- "There is now no room aide for \"%s\".\n",
+ "There is now no room admin for \"%s\".\n",
CC->room.QRname);
- CtdlAideMessage(buf, "Aide Room Modification");
+ CtdlAideMessage(buf, "Admin Room Modification");
}
cprintf("%d Ok\n", CIT_OK);
}
*/
void cmd_rinf(char *gargs)
{
- char filename[128];
+ char filename[PATH_MAX];
char buf[SIZ];
FILE *info_fp;
}
/*
- * For normal rooms, just check for aide or room aide status.
+ * For normal rooms, just check for admin or room admin status.
*/
return(is_room_aide());
}
/*
- * aide command: kill the current room
+ * admin command: kill the current room
*/
void cmd_kill(char *argbuf)
{
}
/* If the room is private, and the system administrator has elected
- * to automatically grant room aide privileges, do so now.
+ * to automatically grant room admin privileges, do so now.
*/
if ((qrbuf.QRflags & QR_PRIVATE) && (CREATAIDE == 1)) {
qrbuf.QRroomaide = CC->user.usernum;
}
- /* Blog owners automatically become room aides of their blogs.
+ /* Blog owners automatically become room admins of their blogs.
* (In the future we will offer a site-wide configuration setting to suppress this behavior.)
*/
else if (new_room_view == VIEW_BLOG) {
qrbuf.QRroomaide = CC->user.usernum;
}
- /* Otherwise, set the room aide to undefined.
+ /* Otherwise, set the room admin to undefined.
*/
else {
qrbuf.QRroomaide = (-1L);
}
+
+/*
+ * cmd_stat() - return the modification time of the current room (maybe other things in the future)
+ */
+void cmd_stat(char *gargs)
+{
+ if (CtdlAccessCheck(ac_logged_in_or_guest)) return;
+ CtdlGetRoom(&CC->room, CC->room.QRname);
+ cprintf("%d %s|%ld|\n", CIT_OK, CC->room.QRname, CC->room.QRmtime);
+}
+
+
+
/*****************************************************************************/
/* MODULE INITIALIZATION STUFF */
/*****************************************************************************/
CtdlRegisterProtoHook(cmd_lzrm, "LZRM", "List zapped rooms");
CtdlRegisterProtoHook(cmd_lprm, "LPRM", "List public rooms");
CtdlRegisterProtoHook(cmd_goto, "GOTO", "Goto a named room");
+ CtdlRegisterProtoHook(cmd_stat, "STAT", "Get mtime of the current room");
CtdlRegisterProtoHook(cmd_whok, "WHOK", "List users who know this room");
CtdlRegisterProtoHook(cmd_rdir, "RDIR", "List files in room directory");
CtdlRegisterProtoHook(cmd_getr, "GETR", "Get room parameters");
CtdlRegisterProtoHook(cmd_setr, "SETR", "Set room parameters");
- CtdlRegisterProtoHook(cmd_geta, "GETA", "Get the room aide name");
- CtdlRegisterProtoHook(cmd_seta, "SETA", "Set the room aide for this room");
+ CtdlRegisterProtoHook(cmd_geta, "GETA", "Get the room admin name");
+ CtdlRegisterProtoHook(cmd_seta, "SETA", "Set the room admin for this room");
CtdlRegisterProtoHook(cmd_rinf, "RINF", "Fetch room info file");
CtdlRegisterProtoHook(cmd_kill, "KILL", "Kill (delete) the current room");
CtdlRegisterProtoHook(cmd_cre8, "CRE8", "Create a new room");