extract_token(buf, ignetcfg, i, '\n');
extract_token(testnode, buf, 0, '|');
if (!strcasecmp(node, testnode)) {
- phree(ignetcfg);
+ free(ignetcfg);
return(MES_IGNET);
}
}
- phree(ignetcfg);
+ free(ignetcfg);
/*
* Then try nodes that are two or more hops away.
extract_token(buf, ignetmap, i, '\n');
extract_token(testnode, buf, 0, '|');
if (!strcasecmp(node, testnode)) {
- phree(ignetmap);
+ free(ignetmap);
return(MES_IGNET);
}
}
- phree(ignetmap);
+ free(ignetmap);
/* If we get to this point it's an invalid node name */
return (MES_ERROR);
FILE *fp;
fp = fopen("citadel.control", "r");
+ if (fp == NULL) {
+ lprintf(CTDL_CRIT, "Cannot open citadel.control: %s\n",
+ strerror(errno));
+ exit(errno);
+ }
fread((char *) &CitControl, sizeof(struct CitControl), 1, fp);
fclose(fp);
}
int num_msgs = 0;
char vset[SIZ];
+ lprintf(CTDL_DEBUG, "CtdlSetSeen(%ld, %d, %d)\n",
+ target_msgnum, target_setting, which_set);
+
/* Learn about the user and room in question */
CtdlGetRelationship(&vbuf, &CC->user, &CC->room);
/* Load the message list */
cdbfr = cdb_fetch(CDB_MSGLISTS, &CC->room.QRnumber, sizeof(long));
if (cdbfr != NULL) {
- msglist = mallok(cdbfr->len);
+ msglist = malloc(cdbfr->len);
memcpy(msglist, cdbfr->ptr, cdbfr->len);
num_msgs = cdbfr->len / sizeof(long);
cdb_free(cdbfr);
if (which_set == ctdlsetseen_answered) strcpy(vbuf.v_answered, newseen);
lprintf(CTDL_DEBUG, " after optimize: %s\n", newseen);
- phree(msglist);
+ free(msglist);
CtdlSetRelationship(&vbuf, &CC->user, &CC->room);
}
/* Load the message list */
cdbfr = cdb_fetch(CDB_MSGLISTS, &CC->room.QRnumber, sizeof(long));
if (cdbfr != NULL) {
- msglist = mallok(cdbfr->len);
+ msglist = malloc(cdbfr->len);
memcpy(msglist, cdbfr->ptr, cdbfr->len);
num_msgs = cdbfr->len / sizeof(long);
cdb_free(cdbfr);
if (num_msgs > 0) {
if (compare != NULL) {
for (a = 0; a < num_msgs; ++a) {
- msg = CtdlFetchMessage(msglist[a]);
+ msg = CtdlFetchMessage(msglist[a], 1);
if (msg != NULL) {
if (CtdlMsgCmp(msg, compare)) {
msglist[a] = 0L;
++num_processed;
}
}
- phree(msglist); /* Clean up */
+ free(msglist); /* Clean up */
return num_processed;
}
}
if (with_template) {
+ unbuffer_output();
cprintf("%d Send template then receive message list\n",
START_CHAT_MODE);
template = (struct CtdlMessage *)
- mallok(sizeof(struct CtdlMessage));
+ malloc(sizeof(struct CtdlMessage));
memset(template, 0, sizeof(struct CtdlMessage));
while(client_gets(buf), strcmp(buf,"000")) {
extract(tfield, buf, 0);
for (i='A'; i<='Z'; ++i) if (msgkeys[i]!=NULL) {
if (!strcasecmp(tfield, msgkeys[i])) {
template->cm_fields[i] =
- strdoop(tvalue);
+ strdup(tvalue);
}
}
}
+ buffer_output();
}
else {
cprintf("%d Message list...\n", LISTING_FOLLOWS);
* NOTE: Caller is responsible for freeing the returned CtdlMessage struct
* using the CtdlMessageFree() function.
*/
-struct CtdlMessage *CtdlFetchMessage(long msgnum)
+struct CtdlMessage *CtdlFetchMessage(long msgnum, int with_body)
{
struct cdbdata *dmsgtext;
struct CtdlMessage *ret = NULL;
cit_uint8_t field_header;
size_t field_length;
+ lprintf(CTDL_DEBUG, "CtdlFetchMessage(%ld, %d)\n", msgnum, with_body);
+
dmsgtext = cdb_fetch(CDB_MSGMAIN, &msgnum, sizeof(long));
if (dmsgtext == NULL) {
return NULL;
*/
ch = *mptr++;
if (ch != 255) {
- lprintf(CTDL_ERR, "Message %ld appears to be corrupted.\n", msgnum);
+ lprintf(CTDL_ERR,
+ "Message %ld appears to be corrupted.\n",
+ msgnum);
cdb_free(dmsgtext);
return NULL;
}
- ret = (struct CtdlMessage *) mallok(sizeof(struct CtdlMessage));
+ ret = (struct CtdlMessage *) malloc(sizeof(struct CtdlMessage));
memset(ret, 0, sizeof(struct CtdlMessage));
ret->cm_magic = CTDLMESSAGE_MAGIC;
if (field_length == 0)
break;
field_header = *mptr++;
- ret->cm_fields[field_header] = mallok(field_length);
+ ret->cm_fields[field_header] = malloc(field_length + 1);
strcpy(ret->cm_fields[field_header], mptr);
while (*mptr++ != 0); /* advance to next field */
cdb_free(dmsgtext);
- /* Always make sure there's something in the msg text field */
- if (ret->cm_fields['M'] == NULL)
- ret->cm_fields['M'] = strdoop("<no text>\n");
+ /* Always make sure there's something in the msg text field. If
+ * it's NULL, the message text is most likely stored separately,
+ * so go ahead and fetch that. Failing that, just set a dummy
+ * body so other code doesn't barf.
+ */
+ if ( (ret->cm_fields['M'] == NULL) && (with_body) ) {
+ dmsgtext = cdb_fetch(CDB_BIGMSGS, &msgnum, sizeof(long));
+ if (dmsgtext != NULL) {
+ ret->cm_fields['M'] = strdup(dmsgtext->ptr);
+ cdb_free(dmsgtext);
+ }
+ }
+ if (ret->cm_fields['M'] == NULL) {
+ ret->cm_fields['M'] = strdup("<no text>\n");
+ }
/* Perform "before read" hooks (aborting if any return nonzero) */
if (PerformMessageHooks(ret, EVT_BEFOREREAD) > 0) {
for (i = 0; i < 256; ++i)
if (msg->cm_fields[i] != NULL) {
- phree(msg->cm_fields[i]);
+ free(msg->cm_fields[i]);
}
msg->cm_magic = 0; /* just in case */
- phree(msg);
+ free(msg);
}
if (ptr[wlen-1] != '\n') {
cprintf("\n");
}
- phree(ptr);
+ free(ptr);
}
else if (strncasecmp(cbtype, "multipart/", 10)) {
cprintf("Part %s: %s (%s) (%ld bytes)\r\n",
int do_proto, /* do Citadel protocol responses? */
int crlf /* Use CRLF newlines instead of LF? */
) {
- struct CtdlMessage *TheMessage;
- int retcode;
+ struct CtdlMessage *TheMessage = NULL;
+ int retcode = om_no_such_msg;
lprintf(CTDL_DEBUG, "CtdlOutputMsg() msgnum=%ld, mode=%d\n",
msg_num, mode);
- TheMessage = NULL;
-
if ((!(CC->logged_in)) && (!(CC->internal_pgm))) {
if (do_proto) cprintf("%d Not logged in.\n",
ERROR + NOT_LOGGED_IN);
return(om_not_logged_in);
}
- /* FIXME ... small security issue
- * We need to check to make sure the requested message is actually
- * in the current room, and set msg_ok to 1 only if it is. This
- * functionality is currently missing because I'm in a hurry to replace
- * broken production code with nonbroken pre-beta code. :( -- ajc
- *
- if (!msg_ok) {
- if (do_proto) cprintf("%d Message %ld is not in this room.\n",
- ERROR + MESSAGE_NOT_FOUND, msg_num);
- return(om_no_such_msg);
- }
- */
+ /* FIXME: check message id against msglist for this room */
/*
- * Fetch the message from disk.
+ * Fetch the message from disk. If we're in sooper-fast headers
+ * only mode, request that we don't even bother loading the body
+ * into memory.
*/
- TheMessage = CtdlFetchMessage(msg_num);
+ if (headers_only == HEADERS_FAST) {
+ TheMessage = CtdlFetchMessage(msg_num, 0);
+ }
+ else {
+ TheMessage = CtdlFetchMessage(msg_num, 1);
+ }
if (TheMessage == NULL) {
if (do_proto) cprintf("%d Can't locate msg %ld on disk\n",
* Get a message off disk. (returns om_* values found in msgbase.h)
*
*/
-int CtdlOutputPreLoadedMsg(struct CtdlMessage *TheMessage,
+int CtdlOutputPreLoadedMsg(
+ struct CtdlMessage *TheMessage,
long msg_num,
int mode, /* how would you like that message? */
int headers_only, /* eschew the message body? */
int crlf /* Use CRLF newlines instead of LF? */
) {
int i, k;
- char buf[1024];
+ char buf[SIZ];
cit_uint8_t ch;
char allkeys[SIZ];
char display_name[SIZ];
char datestamp[SIZ];
/* */
+ lprintf(CTDL_DEBUG, "CtdlOutputPreLoadedMsg(TheMessage=%s, %ld, %d, %d, %d, %d\n",
+ ((TheMessage == NULL) ? "NULL" : "not null"),
+ msg_num,
+ mode, headers_only, do_proto, crlf);
+
snprintf(mid, sizeof mid, "%ld", msg_num);
nl = (crlf ? "\r\n" : "\n");
if (!is_valid_message(TheMessage)) {
- lprintf(CTDL_ERR, "ERROR: invalid preloaded message for output\n");
+ lprintf(CTDL_ERR,
+ "ERROR: invalid preloaded message for output\n");
return(om_no_such_msg);
}
strcpy(snode, NODENAME);
strcpy(lnode, HUMANNODE);
if (mode == MT_RFC822) {
- cprintf("X-UIDL: %ld%s", msg_num, nl);
for (i = 0; i < 256; ++i) {
if (TheMessage->cm_fields[i]) {
mptr = TheMessage->cm_fields[i];
if (i == 'A') {
- strcpy(luser, mptr);
- strcpy(suser, mptr);
+ safestrncpy(luser, mptr, sizeof luser);
+ safestrncpy(suser, mptr, sizeof suser);
}
-/****
- "Path:" removed for now because it confuses brain-dead Microsoft shitware
- into thinking that mail messages are newsgroup messages instead. When we
- add NNTP support back into Citadel we'll have to add code to only output
- this field when appropriate.
- else if (i == 'P') {
- cprintf("Path: %s%s", mptr, nl);
- }
- ****/
else if (i == 'U') {
cprintf("Subject: %s%s", mptr, nl);
subject_found = 1;
if (mode == MT_RFC822) {
if (!strcasecmp(snode, NODENAME)) {
- strcpy(snode, FQDN);
+ safestrncpy(snode, FQDN, sizeof snode);
}
/* Construct a fun message id */
/* end header processing loop ... at this point, we're in the text */
START_TEXT:
+ if (headers_only == HEADERS_FAST) goto DONE;
mptr = TheMessage->cm_fields['M'];
/* Tell the client about the MIME parts in this message */
}
msgnum = extract_long(cmdbuf, 0);
- msg = CtdlFetchMessage(msgnum);
+ msg = CtdlFetchMessage(msgnum, 1);
if (msg == NULL) {
cprintf("%d Message %ld not found.\n",
ERROR + MESSAGE_NOT_FOUND, msgnum);
}
cprintf("%d %ld\n", BINARY_FOLLOWS, (long)smr.len);
- client_write(smr.ser, smr.len);
- phree(smr.ser);
+ client_write((char *)smr.ser, (int)smr.len);
+ free(smr.ser);
}
if ( (flags & SM_VERIFY_GOODNESS)
|| (flags & SM_DO_REPL_CHECK)
) {
- msg = CtdlFetchMessage(msgid);
+ msg = CtdlFetchMessage(msgid, 1);
if (msg == NULL) return(ERROR + ILLEGAL_VALUE);
}
if (ReplicationChecks(msg) != 0) {
getroom(&CC->room, hold_rm);
if (msg != NULL) CtdlFreeMessage(msg);
- lprintf(CTDL_DEBUG, "Did replication, and newer exists\n");
+ lprintf(CTDL_DEBUG,
+ "Did replication, and newer exists\n");
return(0);
}
}
msglist = NULL;
num_msgs = 0;
} else {
- msglist = mallok(cdbfr->len);
+ msglist = malloc(cdbfr->len);
if (msglist == NULL)
lprintf(CTDL_ALERT, "ERROR malloc msglist!\n");
num_msgs = cdbfr->len / sizeof(long);
lputroom(&CC->room); /* unlock the room */
getroom(&CC->room, hold_rm);
if (msg != NULL) CtdlFreeMessage(msg);
+ free(msglist);
return(ERROR + ALREADY_EXISTS);
}
}
/* Now add the new message */
++num_msgs;
- msglist = reallok(msglist,
- (num_msgs * sizeof(long)));
+ msglist = realloc(msglist, (num_msgs * sizeof(long)));
if (msglist == NULL) {
lprintf(CTDL_ALERT, "ERROR: can't realloc message list!\n");
highest_msg = msglist[num_msgs - 1];
/* Write it back to disk. */
- cdb_store(CDB_MSGLISTS, &CC->room.QRnumber, sizeof(long),
- msglist, num_msgs * sizeof(long));
+ cdb_store(CDB_MSGLISTS, &CC->room.QRnumber, (int)sizeof(long),
+ msglist, (int)(num_msgs * sizeof(long)));
/* Free up the memory we used. */
- phree(msglist);
+ free(msglist);
/* Update the highest-message pointer and unlock the room. */
CC->room.QRhighest = highest_msg;
/*
- * Message base operation to send a message to the master file
+ * Message base operation to save a new message to the message store
* (returns new message number)
*
* This is the back end for CtdlSubmitMsg() and should not be directly
* called by server-side modules.
*
*/
-long send_message(struct CtdlMessage *msg, /* pointer to buffer */
- FILE *save_a_copy) /* save a copy to disk? */
-{
+long send_message(struct CtdlMessage *msg) {
long newmsgid;
long retval;
char msgidbuf[SIZ];
struct ser_ret smr;
+ int is_bigmsg = 0;
+ char *holdM = NULL;
/* Get a new message number */
newmsgid = get_new_message_number();
/* Generate an ID if we don't have one already */
if (msg->cm_fields['I']==NULL) {
- msg->cm_fields['I'] = strdoop(msgidbuf);
+ msg->cm_fields['I'] = strdup(msgidbuf);
}
-
+
+ /* If the message is big, set its body aside for storage elsewhere */
+ if (msg->cm_fields['M'] != NULL) {
+ if (strlen(msg->cm_fields['M']) > BIGMSG) {
+ is_bigmsg = 1;
+ holdM = msg->cm_fields['M'];
+ msg->cm_fields['M'] = NULL;
+ }
+ }
+
+ /* Serialize our data structure for storage in the database */
serialize_message(&smr, msg);
+ if (is_bigmsg) {
+ msg->cm_fields['M'] = holdM;
+ }
+
if (smr.len == 0) {
cprintf("%d Unable to serialize message\n",
ERROR + INTERNAL_ERROR);
}
/* Write our little bundle of joy into the message base */
- if (cdb_store(CDB_MSGMAIN, &newmsgid, sizeof(long),
+ if (cdb_store(CDB_MSGMAIN, &newmsgid, (int)sizeof(long),
smr.ser, smr.len) < 0) {
lprintf(CTDL_ERR, "Can't store message\n");
retval = 0L;
} else {
+ if (is_bigmsg) {
+ cdb_store(CDB_BIGMSGS,
+ &newmsgid,
+ (int)sizeof(long),
+ holdM,
+ (strlen(holdM) + 1)
+ );
+ }
retval = newmsgid;
}
- /* If the caller specified that a copy should be saved to a particular
- * file handle, do that now too.
- */
- if (save_a_copy != NULL) {
- fwrite(smr.ser, smr.len, 1, save_a_copy);
- }
-
/* Free the memory we used for the serialized message */
- phree(smr.ser);
+ free(smr.ser);
/* Return the *local* message ID to the caller
* (even if we're storing an incoming network message)
strlen(msg->cm_fields[(int)forder[i]]) + 2;
lprintf(CTDL_DEBUG, "serialize_message() calling malloc(%ld)\n", (long)ret->len);
- ret->ser = mallok(ret->len);
+ ret->ser = malloc(ret->len);
if (ret->ser == NULL) {
ret->len = 0;
return;
for (i=0; i<26; ++i) if (msg->cm_fields[(int)forder[i]] != NULL) {
ret->ser[wlen++] = (char)forder[i];
- strcpy(&ret->ser[wlen], msg->cm_fields[(int)forder[i]]);
+ strcpy((char *)&ret->ser[wlen], msg->cm_fields[(int)forder[i]]);
wlen = wlen + strlen(msg->cm_fields[(int)forder[i]]) + 1;
}
if (ret->len != wlen) lprintf(CTDL_ERR, "ERROR: len=%ld wlen=%ld\n",
time_t timestamp = (-1L);
lprintf(CTDL_DEBUG, "check_repl() found message %ld\n", msgnum);
- msg = CtdlFetchMessage(msgnum);
+ msg = CtdlFetchMessage(msgnum, 1);
if (msg == NULL) return;
if (msg->cm_fields['T'] != NULL) {
timestamp = atol(msg->cm_fields['T']);
/*
- * Check to see if any messages already exist which carry the same Extended ID
+ * Check to see if any messages already exist which carry the same Exclusive ID
* as this one.
*
* If any are found:
int abort_this = 0;
lprintf(CTDL_DEBUG, "ReplicationChecks() started\n");
- /* No extended id? Don't do anything. */
+ /* No exclusive id? Don't do anything. */
if (msg->cm_fields['E'] == NULL) return 0;
if (strlen(msg->cm_fields['E']) == 0) return 0;
- lprintf(CTDL_DEBUG, "Extended ID: <%s>\n", msg->cm_fields['E']);
+ lprintf(CTDL_DEBUG, "Exclusive ID: <%s>\n", msg->cm_fields['E']);
CtdlAllocUserData(SYM_REPL, sizeof(struct repl));
- strcpy(msg_repl->extended_id, msg->cm_fields['E']);
+ strcpy(msg_repl->exclusive_id, msg->cm_fields['E']);
msg_repl->highest = atol(msg->cm_fields['T']);
template = (struct CtdlMessage *) malloc(sizeof(struct CtdlMessage));
memset(template, 0, sizeof(struct CtdlMessage));
- template->cm_fields['E'] = strdoop(msg->cm_fields['E']);
+ template->cm_fields['E'] = strdup(msg->cm_fields['E']);
CtdlForEachMessage(MSGS_ALL, 0L, NULL, template, check_repl, NULL);
- /* If a newer message exists with the same Extended ID, abort
+ /* If a newer message exists with the same Exclusive ID, abort
* this save.
*/
if (msg_repl->highest > atol(msg->cm_fields['T']) ) {
if (msg->cm_fields['T'] == NULL) {
lprintf(CTDL_DEBUG, "Generating timestamp\n");
snprintf(aaa, sizeof aaa, "%ld", (long)time(NULL));
- msg->cm_fields['T'] = strdoop(aaa);
+ msg->cm_fields['T'] = strdup(aaa);
}
/* If this message has no path, we generate one.
if (msg->cm_fields['P'] == NULL) {
lprintf(CTDL_DEBUG, "Generating path\n");
if (msg->cm_fields['A'] != NULL) {
- msg->cm_fields['P'] = strdoop(msg->cm_fields['A']);
+ msg->cm_fields['P'] = strdup(msg->cm_fields['A']);
for (a=0; a<strlen(msg->cm_fields['P']); ++a) {
if (isspace(msg->cm_fields['P'][a])) {
msg->cm_fields['P'][a] = ' ';
}
}
else {
- msg->cm_fields['P'] = strdoop("unknown");
+ msg->cm_fields['P'] = strdup("unknown");
}
}
* If this message has no O (room) field, generate one.
*/
if (msg->cm_fields['O'] == NULL) {
- msg->cm_fields['O'] = strdoop(CC->room.QRname);
+ msg->cm_fields['O'] = strdup(CC->room.QRname);
}
/* Perform "before save" hooks (aborting if any return nonzero) */
lprintf(CTDL_DEBUG, "Performing before-save hooks\n");
if (PerformMessageHooks(msg, EVT_BEFORESAVE) > 0) return(-1);
- /* If this message has an Extended ID, perform replication checks */
+ /* If this message has an Exclusive ID, perform replication checks */
lprintf(CTDL_DEBUG, "Performing replication checks\n");
if (ReplicationChecks(msg) > 0) return(-1);
/* Save it to disk */
lprintf(CTDL_DEBUG, "Saving to disk\n");
- newmsgid = send_message(msg, NULL);
+ newmsgid = send_message(msg);
if (newmsgid <= 0L) return(-1);
/* Write a supplemental message info record. This doesn't have to
memset(&smi, 0, sizeof(struct MetaData));
smi.meta_msgnum = newmsgid;
smi.meta_refcount = 0;
- safestrncpy(smi.meta_content_type, content_type, 64);
+ safestrncpy(smi.meta_content_type, content_type, sizeof smi.meta_content_type);
PutMetaData(&smi);
/* Now figure out where to store the pointers */
hold_R = msg->cm_fields['R'];
hold_D = msg->cm_fields['D'];
- msg->cm_fields['R'] = mallok(SIZ);
- msg->cm_fields['D'] = mallok(SIZ);
+ msg->cm_fields['R'] = malloc(SIZ);
+ msg->cm_fields['D'] = malloc(SIZ);
extract_token(msg->cm_fields['R'], recipient, 0, '@');
extract_token(msg->cm_fields['D'], recipient, 1, '@');
fwrite(smr.ser, smr.len, 1, network_fp);
fclose(network_fp);
}
- phree(smr.ser);
+ free(smr.ser);
}
- phree(msg->cm_fields['R']);
- phree(msg->cm_fields['D']);
+ free(msg->cm_fields['R']);
+ free(msg->cm_fields['D']);
msg->cm_fields['R'] = hold_R;
msg->cm_fields['D'] = hold_D;
}
if (recps != NULL)
if (recps->num_internet > 0) {
lprintf(CTDL_DEBUG, "Generating delivery instructions\n");
- instr = mallok(SIZ * 2);
+ instr = malloc(SIZ * 2);
snprintf(instr, SIZ * 2,
"Content-type: %s\n\nmsgid|%ld\nsubmitted|%ld\n"
"bounceto|%s@%s\n",
"remote|%s|0||\n", recipient);
}
- imsg = mallok(sizeof(struct CtdlMessage));
+ imsg = malloc(sizeof(struct CtdlMessage));
memset(imsg, 0, sizeof(struct CtdlMessage));
imsg->cm_magic = CTDLMESSAGE_MAGIC;
imsg->cm_anon_type = MES_NORMAL;
imsg->cm_format_type = FMT_RFC822;
- imsg->cm_fields['A'] = strdoop("Citadel");
+ imsg->cm_fields['A'] = strdup("Citadel");
imsg->cm_fields['M'] = instr;
CtdlSubmitMsg(imsg, NULL, SMTP_SPOOLOUT_ROOM);
CtdlFreeMessage(imsg);
struct CtdlMessage *msg;
struct recptypes *recp = NULL;
- msg = mallok(sizeof(struct CtdlMessage));
+ msg = malloc(sizeof(struct CtdlMessage));
memset(msg, 0, sizeof(struct CtdlMessage));
msg->cm_magic = CTDLMESSAGE_MAGIC;
msg->cm_anon_type = MES_NORMAL;
msg->cm_format_type = format_type;
- msg->cm_fields['A'] = strdoop(from);
- if (room != NULL) msg->cm_fields['O'] = strdoop(room);
- msg->cm_fields['N'] = strdoop(NODENAME);
+ msg->cm_fields['A'] = strdup(from);
+ if (room != NULL) msg->cm_fields['O'] = strdup(room);
+ msg->cm_fields['N'] = strdup(NODENAME);
if (to != NULL) {
- msg->cm_fields['R'] = strdoop(to);
+ msg->cm_fields['R'] = strdup(to);
recp = validate_recipients(to);
}
if (subject != NULL) {
- msg->cm_fields['U'] = strdoop(subject);
+ msg->cm_fields['U'] = strdup(subject);
}
- msg->cm_fields['M'] = strdoop(text);
+ msg->cm_fields['M'] = strdup(text);
CtdlSubmitMsg(msg, recp, room);
CtdlFreeMessage(msg);
- if (recp != NULL) phree(recp);
+ if (recp != NULL) free(recp);
}
int finished = 0;
if (exist == NULL) {
- m = mallok(4096);
+ m = malloc(4096);
m[0] = 0;
buffer_len = 4096;
message_len = 0;
else {
message_len = strlen(exist);
buffer_len = message_len + 4096;
- m = reallok(exist, buffer_len);
+ m = realloc(exist, buffer_len);
if (m == NULL) {
- phree(exist);
+ free(exist);
return m;
}
}
/* augment the buffer if we have to */
if ((message_len + linelen) >= buffer_len) {
- ptr = reallok(m, (buffer_len * 2) );
+ ptr = realloc(m, (buffer_len * 2) );
if (ptr == NULL) { /* flush if can't allocate */
flushing = 1;
} else {
char buf[SIZ];
struct CtdlMessage *msg;
- msg = mallok(sizeof(struct CtdlMessage));
+ msg = malloc(sizeof(struct CtdlMessage));
memset(msg, 0, sizeof(struct CtdlMessage));
msg->cm_magic = CTDLMESSAGE_MAGIC;
msg->cm_anon_type = type;
striplt(recipient);
snprintf(buf, sizeof buf, "cit%ld", author->usernum); /* Path */
- msg->cm_fields['P'] = strdoop(buf);
+ msg->cm_fields['P'] = strdup(buf);
snprintf(buf, sizeof buf, "%ld", (long)time(NULL)); /* timestamp */
- msg->cm_fields['T'] = strdoop(buf);
+ msg->cm_fields['T'] = strdup(buf);
if (fake_name[0]) /* author */
- msg->cm_fields['A'] = strdoop(fake_name);
+ msg->cm_fields['A'] = strdup(fake_name);
else
- msg->cm_fields['A'] = strdoop(author->fullname);
+ msg->cm_fields['A'] = strdup(author->fullname);
if (CC->room.QRflags & QR_MAILBOX) { /* room */
- msg->cm_fields['O'] = strdoop(&CC->room.QRname[11]);
+ msg->cm_fields['O'] = strdup(&CC->room.QRname[11]);
}
else {
- msg->cm_fields['O'] = strdoop(CC->room.QRname);
+ msg->cm_fields['O'] = strdup(CC->room.QRname);
}
- msg->cm_fields['N'] = strdoop(NODENAME); /* nodename */
- msg->cm_fields['H'] = strdoop(HUMANNODE); /* hnodename */
+ msg->cm_fields['N'] = strdup(NODENAME); /* nodename */
+ msg->cm_fields['H'] = strdup(HUMANNODE); /* hnodename */
if (recipient[0] != 0) {
- msg->cm_fields['R'] = strdoop(recipient);
+ msg->cm_fields['R'] = strdup(recipient);
}
if (dest_node[0] != 0) {
- msg->cm_fields['D'] = strdoop(dest_node);
+ msg->cm_fields['D'] = strdup(dest_node);
}
if ( (author == &CC->user) && (strlen(CC->cs_inet_email) > 0) ) {
- msg->cm_fields['F'] = strdoop(CC->cs_inet_email);
+ msg->cm_fields['F'] = strdup(CC->cs_inet_email);
}
if (subject != NULL) {
striplt(subject);
if (strlen(subject) > 0) {
- msg->cm_fields['U'] = strdoop(subject);
+ msg->cm_fields['U'] = strdup(subject);
}
}
*/
int CtdlCheckInternetMailPermission(struct ctdluser *who) {
+ /* Do not allow twits to send Internet mail */
+ if (who->axlevel <= 2) return(0);
+
/* Globally enabled? */
if (config.c_restrict == 0) return(1);
struct recptypes *valid = NULL;
char subject[SIZ];
+ unbuffer_output();
+
post = extract_int(entargs, 0);
extract(recp, entargs, 1);
anon_flag = extract_int(entargs, 2);
if (valid->num_error > 0) {
cprintf("%d %s\n",
ERROR + NO_SUCH_USER, valid->errormsg);
- phree(valid);
+ free(valid);
return;
}
if (valid->num_internet > 0) {
cprintf("%d You do not have permission "
"to send Internet mail.\n",
ERROR + HIGHER_ACCESS_REQUIRED);
- phree(valid);
+ free(valid);
return;
}
}
&& (CC->user.axlevel < 4) ) {
cprintf("%d Higher access required for network mail.\n",
ERROR + HIGHER_ACCESS_REQUIRED);
- phree(valid);
+ free(valid);
return;
}
&& (!CC->internal_pgm)) {
cprintf("%d You don't have access to Internet mail.\n",
ERROR + HIGHER_ACCESS_REQUIRED);
- phree(valid);
+ free(valid);
return;
}
if (post == 0) {
cprintf("%d %s\n", CIT_OK,
((valid != NULL) ? valid->display_recp : "") );
- phree(valid);
+ free(valid);
return;
}
CtdlFreeMessage(msg);
}
CC->fake_postname[0] = '\0';
- phree(valid);
+ free(valid);
return;
}
cdbfr = cdb_fetch(CDB_MSGLISTS, &qrbuf.QRnumber, sizeof(long));
if (cdbfr != NULL) {
- msglist = mallok(cdbfr->len);
- dellist = mallok(cdbfr->len);
+ msglist = malloc(cdbfr->len);
+ dellist = malloc(cdbfr->len);
memcpy(msglist, cdbfr->ptr, cdbfr->len);
num_msgs = cdbfr->len / sizeof(long);
cdb_free(cdbfr);
}
num_msgs = sort_msglist(msglist, num_msgs);
- cdb_store(CDB_MSGLISTS, &qrbuf.QRnumber, sizeof(long),
- msglist, (num_msgs * sizeof(long)));
+ cdb_store(CDB_MSGLISTS, &qrbuf.QRnumber, (int)sizeof(long),
+ msglist, (int)(num_msgs * sizeof(long)));
qrbuf.QRhighest = msglist[num_msgs - 1];
}
}
/* Now free the memory we used, and go away. */
- if (msglist != NULL) phree(msglist);
- if (dellist != NULL) phree(dellist);
+ if (msglist != NULL) free(msglist);
+ if (dellist != NULL) free(dellist);
lprintf(CTDL_DEBUG, "%d message(s) deleted.\n", num_deleted);
return (num_deleted);
}
int err;
int is_copy = 0;
int ra;
+ int permit = 0;
num = extract_long(args, 0);
extract(targ, args, 1);
is_copy = extract_int(args, 2);
if (getroom(&qtemp, targ) != 0) {
- cprintf("%d '%s' does not exist.\n", ERROR + ROOM_NOT_FOUND, targ);
+ cprintf("%d '%s' does not exist.\n",
+ ERROR + ROOM_NOT_FOUND, targ);
return;
}
getuser(&CC->user, CC->curr_user);
ra = CtdlRoomAccess(&qtemp, &CC->user);
+
+ /* Check for permission to perform this operation.
+ * Remember: "CC->room" is source, "qtemp" is target.
+ */
+ permit = 0;
+
/* Aides can move/copy */
- if ((CC->user.axlevel < 6)
- /* Roomaides can move/copy */
- && (CC->user.usernum != CC->room.QRroomaide)
- /* Permit move/copy from personal rooms */
- && (!((CC->room.QRflags & QR_MAILBOX)
- && (qtemp.QRflags & QR_MAILBOX)))
- /* Permit only copy from public to personal room */
- && (!(is_copy && (CC->room.QRflags & QR_MAILBOX)
- || (qtemp.QRflags & QR_MAILBOX)))
- /* User must have access to target room */
- && !((ra & UA_KNOWN))) {
+ if (CC->user.axlevel >= 6) permit = 1;
+
+ /* Room aides can move/copy */
+ if (CC->user.usernum == CC->room.QRroomaide) permit = 1;
+
+ /* Permit move/copy from personal rooms */
+ if ((CC->room.QRflags & QR_MAILBOX)
+ && (qtemp.QRflags & QR_MAILBOX)) permit = 1;
+
+ /* Permit only copy from public to personal room */
+ if ( (is_copy)
+ && (!(CC->room.QRflags & QR_MAILBOX))
+ && (qtemp.QRflags & QR_MAILBOX)) permit = 1;
+
+ /* User must have access to target room */
+ if (!(ra & UA_KNOWN)) permit = 0;
+
+ if (!permit) {
cprintf("%d Higher access required.\n",
ERROR + HIGHER_ACCESS_REQUIRED);
return;
smibuf->meta_msgnum, smibuf->meta_refcount);
cdb_store(CDB_MSGMAIN,
- &TheIndex, sizeof(long),
- smibuf, sizeof(struct MetaData));
+ &TheIndex, (int)sizeof(long),
+ smibuf, (int)sizeof(struct MetaData));
}
if (smi.meta_refcount == 0) {
lprintf(CTDL_DEBUG, "Deleting message <%ld>\n", msgnum);
delnum = msgnum;
- cdb_delete(CDB_MSGMAIN, &delnum, sizeof(long));
+ cdb_delete(CDB_MSGMAIN, &delnum, (int)sizeof(long));
+ cdb_delete(CDB_BIGMSGS, &delnum, (int)sizeof(long));
/* We have to delete the metadata record too! */
delnum = (0L - msgnum);
- cdb_delete(CDB_MSGMAIN, &delnum, sizeof(long));
+ cdb_delete(CDB_MSGMAIN, &delnum, (int)sizeof(long));
}
}
rewind(fp);
lprintf(CTDL_DEBUG, "Raw length is %ld\n", (long)raw_length);
- raw_message = mallok((size_t)raw_length + 2);
+ raw_message = malloc((size_t)raw_length + 2);
fread(raw_message, (size_t)raw_length, 1, fp);
fclose(fp);
if (is_binary) {
- encoded_message = mallok((size_t)
+ encoded_message = malloc((size_t)
(((raw_length * 134) / 100) + 4096 ) );
}
else {
- encoded_message = mallok((size_t)(raw_length + 4096));
+ encoded_message = malloc((size_t)(raw_length + 4096));
}
sprintf(encoded_message, "Content-type: %s\n", content_type);
);
}
- phree(raw_message);
+ free(raw_message);
lprintf(CTDL_DEBUG, "Allocating\n");
- msg = mallok(sizeof(struct CtdlMessage));
+ msg = malloc(sizeof(struct CtdlMessage));
memset(msg, 0, sizeof(struct CtdlMessage));
msg->cm_magic = CTDLMESSAGE_MAGIC;
msg->cm_anon_type = MES_NORMAL;
msg->cm_format_type = 4;
- msg->cm_fields['A'] = strdoop(CC->user.fullname);
- msg->cm_fields['O'] = strdoop(req_room);
- msg->cm_fields['N'] = strdoop(config.c_nodename);
- msg->cm_fields['H'] = strdoop(config.c_humannode);
+ msg->cm_fields['A'] = strdup(CC->user.fullname);
+ msg->cm_fields['O'] = strdup(req_room);
+ msg->cm_fields['N'] = strdup(config.c_nodename);
+ msg->cm_fields['H'] = strdup(config.c_humannode);
msg->cm_flags = flags;
msg->cm_fields['M'] = encoded_message;
if (getroom(&qrbuf, roomname) != 0) {
create_room(roomname,
( (is_mailbox != NULL) ? 5 : 3 ),
- "", 0, 1, 0);
+ "", 0, 1, 0, VIEW_BBS);
}
/* If the caller specified this object as unique, delete all
* other objects of this type that are currently in the room.
conf = NULL;
}
else {
- msg = CtdlFetchMessage(msgnum);
+ msg = CtdlFetchMessage(msgnum, 1);
if (msg != NULL) {
- conf = strdoop(msg->cm_fields['M']);
+ conf = strdup(msg->cm_fields['M']);
CtdlFreeMessage(msg);
}
else {
if (recp == NULL) return(0);
if (recp->num_local == 0) {
- phree(recp);
+ free(recp);
return(0);
}
for (i=0; i<recp->num_local; ++i) {
extract(addr, recp->recp_local, i);
if (!strcasecmp(addr, CC->user.fullname)) {
- phree(recp);
+ free(recp);
return(1);
}
}
- phree(recp);
+ free(recp);
return(0);
}