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);
}
/* 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);
++num_processed;
}
}
- phree(msglist); /* Clean up */
+ free(msglist); /* Clean up */
return num_processed;
}
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);
}
}
}
struct CtdlMessage *CtdlFetchMessage(long msgnum)
{
struct cdbdata *dmsgtext;
+ struct cdbdata *dbigmsg;
struct CtdlMessage *ret = NULL;
char *mptr;
cit_uint8_t ch;
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);
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) {
+
+ dbigmsg = cdb_fetch(CDB_BIGMSGS, &msgnum, sizeof(long));
+ if (dmsgtext == NULL) {
+ ret->cm_fields['M'] = strdup("<no text>\n");
+ }
+ else {
+ ret->cm_fields['M'] = strdup(dbigmsg->ptr);
+ cdb_free(dbigmsg);
+ }
+ }
/* 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",
strcpy(display_name, "<unknown>");
if (TheMessage->cm_fields['A']) {
strcpy(buf, TheMessage->cm_fields['A']);
- PerformUserHooks(buf, (-1L), EVT_OUTPUTMSG);
if (TheMessage->cm_anon_type == MES_ANONONLY) {
strcpy(display_name, "****");
}
}
cprintf(">%s", nl);
- PerformUserHooks(luser, (-1L), EVT_OUTPUTMSG);
-
if (!is_room_aide() && (TheMessage->cm_anon_type == MES_ANONONLY)) {
cprintf("From: x@x.org (----)%s", nl);
}
/* 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 */
cprintf("%d %ld\n", BINARY_FOLLOWS, (long)smr.len);
client_write(smr.ser, smr.len);
- phree(smr.ser);
+ free(smr.ser);
}
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,
+ msglist = realloc(msglist,
(num_msgs * sizeof(long)));
if (msglist == NULL) {
msglist, 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;
* 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);
lprintf(CTDL_ERR, "Can't store message\n");
retval = 0L;
} else {
+ if (is_bigmsg) {
+ cdb_store(CDB_BIGMSGS, &newmsgid, sizeof(long),
+ holdM, strlen(holdM) );
+ }
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;
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 (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);
- }
-
- /*
- * If no Author, set it to ME ME ME
- */
- if (msg->cm_fields['A'] == NULL) {
- msg->cm_fields['A'] = strdoop(CC->user.fullname);
- }
-
- /*
- * If no Node, set it to the local node
- */
- if (msg->cm_fields['N'] == NULL) {
- msg->cm_fields['N'] = strdoop(config.c_nodename);
+ 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) */
/* 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
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);
}
}
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);
}
/* 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);
}
struct ctdlroom qtemp;
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 to/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)))) {
+ 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;
lprintf(CTDL_DEBUG, "Deleting message <%ld>\n", msgnum);
delnum = msgnum;
cdb_delete(CDB_MSGMAIN, &delnum, sizeof(long));
+ cdb_delete(CDB_BIGMSGS, &delnum, sizeof(long));
/* We have to delete the metadata record too! */
delnum = (0L - msgnum);
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;
else {
msg = CtdlFetchMessage(msgnum);
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);
}
projects / citadel.git / blobdiff