// Copyright (c) 1987-2022 by the citadel.org team
//
-// This program is open source software. Use, duplication, and/or
-// disclosure are subject to the GNU General Purpose 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.
+// This program is open source software. Use, duplication, or disclosure is subject to the GNU General Public License version 3.
#include "textclient.h"
#define INADDR_NONE 0xffffffff
#endif
-static void (*status_hook) (char *s) = NULL;
+static void (*status_hook)(char *s) = NULL;
char ctdl_autoetc_dir[PATH_MAX] = "";
char file_citadel_rc[PATH_MAX] = "";
char ctdl_run_dir[PATH_MAX] = "";
DBG_PRINT(file_citadel_rc);
}
-void setCryptoStatusHook(void (*hook) (char *s)) {
+void setCryptoStatusHook(void (*hook)(char *s)) {
status_hook = hook;
}
-void CtdlIPC_SetNetworkStatusCallback(CtdlIPC * ipc, void (*hook) (int state)) {
+void CtdlIPC_SetNetworkStatusCallback(CtdlIPC * ipc, void (*hook)(int state)) {
ipc->network_status_cb = hook;
}
/* LKRN */
+
/* Caller must free the march list */
+
/* Room types are defined in enum RoomList; keep these in sync! */
+
/* floor is -1 for all, or floornum */
int CtdlIPCKnownRooms(CtdlIPC * ipc, enum RoomList which, int floor, struct march **listing, char *cret) {
int ret;
/* GETU */
+
/* Caller must free the struct ctdluser; caller may pass an existing one */
int CtdlIPCGetConfig(CtdlIPC * ipc, struct ctdluser **uret, char *cret) {
int ret;
return -1;
}
sprintf(aaa, "GOTO %s|%s", room, passwd);
- } else {
+ }
+ else {
aaa = (char *) malloc(strlen(room) + 6);
if (!aaa) {
free(*rret);
rret[0]->RRlastread = extract_long(cret, 6);
rret[0]->RRismailbox = extract_int(cret, 7);
rret[0]->RRaide = extract_int(cret, 8);
- rret[0]->RRnewmail = extract_long(cret, 9);
+ // position 9 is no longer used
rret[0]->RRfloor = extract_int(cret, 10);
rret[0]->RRcurrentview = extract_int(cret, 11);
rret[0]->RRdefaultview = extract_int(cret, 12);
- /* position 13 is a trash folder flag ... irrelevant in this client */
+ // position 13 is a trash folder flag ... irrelevant in this client
rret[0]->RRflags2 = extract_int(cret, 14);
- } else {
+ }
+ else {
free(*rret);
*rret = NULL;
}
/* MSGS */
+
/* which is 0 = all, 1 = old, 2 = new, 3 = last, 4 = first, 5 = gt, 6 = lt */
+
/* whicharg is number of messages, applies to last, first, gt, lt */
-int CtdlIPCGetMessages(CtdlIPC * ipc, enum MessageList which, int whicharg, const char *mtemplate, unsigned long **mret, char *cret)
-{
+int CtdlIPCGetMessages(CtdlIPC * ipc, enum MessageList which, int whicharg, const char *mtemplate, unsigned long **mret, char *cret) {
int ret;
unsigned long count = 0;
static char *proto[] = { "ALL", "OLD", "NEW", "LAST", "FIRST", "GT", "LT" };
if (*mret) {
(*mret)[count++] = atol(aaa);
(*mret)[count] = 0L;
- } else {
+ }
+ else {
break;
}
}
/* MSG0, MSG2 */
-int CtdlIPCGetSingleMessage(CtdlIPC * ipc, long msgnum, int headers, int as_mime, struct ctdlipcmessage **mret, char *cret)
-{
+int CtdlIPCGetSingleMessage(CtdlIPC * ipc, long msgnum, int headers, int as_mime, struct ctdlipcmessage **mret, char *cret) {
int ret;
char aaa[SIZ];
char *bbb = NULL;
if (!strcasecmp(multipart_prefix, "multipart/alternative")) {
++multipart_hunting;
}
- } else if (!strncasecmp(aaa, "suff=", 5)) {
+ }
+ else if (!strncasecmp(aaa, "suff=", 5)) {
extract_token(multipart_prefix, &aaa[5], 1, '|', sizeof multipart_prefix);
if (!strcasecmp(multipart_prefix, "multipart/alternative")) {
++multipart_hunting;
if (!strncasecmp(bbb, "Content-type:", 13)) {
extract_token(mret[0]->content_type, bbb, 0, '\n', sizeof mret[0]->content_type);
strcpy(mret[0]->content_type, &mret[0]->content_type[13]);
- striplt(mret[0]->content_type);
+ string_trim(mret[0]->content_type);
/* strip out ";charset=" portion. FIXME do something with
* the charset (like... convert it) instead of just throwing
if (!strncasecmp(bbb, "X-Citadel-MSG4-Partnum:", 23)) {
extract_token(mret[0]->mime_chosen, bbb, 0, '\n', sizeof mret[0]->mime_chosen);
strcpy(mret[0]->mime_chosen, &mret[0]->mime_chosen[23]);
- striplt(mret[0]->mime_chosen);
+ string_trim(mret[0]->mime_chosen);
}
if (!strncasecmp(bbb, "Content-transfer-encoding:", 26)) {
extract_token(encoding, bbb, 0, '\n', sizeof encoding);
strcpy(encoding, &encoding[26]);
- striplt(encoding);
+ string_trim(encoding);
}
remove_token(bbb, 0, '\n');
} while ((bbb[0] != 0) && (bbb[0] != '\n'));
ccc = malloc(strlen(bbb) + 32768);
if (!strcasecmp(encoding, "base64")) {
bytes_decoded = CtdlDecodeBase64(ccc, bbb, strlen(bbb));
- } else if (!strcasecmp(encoding, "quoted-printable")) {
+ }
+ else if (!strcasecmp(encoding, "quoted-printable")) {
bytes_decoded = CtdlDecodeQuotedPrintable(ccc, bbb, strlen(bbb));
}
ccc[bytes_decoded] = 0;
/* FIXME: Strip trailing whitespace */
bbb = (char *) realloc(bbb, (size_t) (strlen(bbb) + 1));
- } else {
+ }
+ else {
bbb = (char *) realloc(bbb, 1);
*bbb = '\0';
}
/* WHOK */
-int CtdlIPCWhoKnowsRoom(CtdlIPC * ipc, char **listing, char *cret)
-{
+int CtdlIPCWhoKnowsRoom(CtdlIPC * ipc, char **listing, char *cret) {
int ret;
size_t bytes;
/* INFO */
-int CtdlIPCServerInfo(CtdlIPC * ipc, char *cret)
-{
+int CtdlIPCServerInfo(CtdlIPC * ipc, char *cret) {
int ret;
size_t bytes;
char *listing = NULL;
/* RDIR */
-int CtdlIPCReadDirectory(CtdlIPC * ipc, char **listing, char *cret)
-{
+int CtdlIPCReadDirectory(CtdlIPC * ipc, char **listing, char *cret) {
int ret;
size_t bytes;
/*
* Set last-read pointer in this room to msgnum, or 0 for HIGHEST.
*/
-int CtdlIPCSetLastRead(CtdlIPC * ipc, long msgnum, char *cret)
-{
+int CtdlIPCSetLastRead(CtdlIPC * ipc, long msgnum, char *cret) {
int ret;
char aaa[64];
if (msgnum) {
sprintf(aaa, "SLRP %ld", msgnum);
- } else {
+ }
+ else {
sprintf(aaa, "SLRP HIGHEST");
}
ret = CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
/* INVT */
-int CtdlIPCInviteUserToRoom(CtdlIPC * ipc, const char *username, char *cret)
-{
+int CtdlIPCInviteUserToRoom(CtdlIPC * ipc, const char *username, char *cret) {
int ret;
char *aaa;
/* KICK */
-int CtdlIPCKickoutUserFromRoom(CtdlIPC * ipc, const char *username, char *cret)
-{
+int CtdlIPCKickoutUserFromRoom(CtdlIPC * ipc, const char *username, char *cret) {
int ret;
char *aaa;
/* GETR */
-int CtdlIPCGetRoomAttributes(CtdlIPC * ipc, struct ctdlroom **qret, char *cret)
-{
+int CtdlIPCGetRoomAttributes(CtdlIPC * ipc, struct ctdlroom **qret, char *cret) {
int ret;
if (!cret)
/* SETR */
-int CtdlIPCSetRoomAttributes(CtdlIPC *ipc,
- int forget, // if nonzero, kick all users out of the room
- struct ctdlroom *qret,
- char *cret
-) {
+int CtdlIPCSetRoomAttributes(CtdlIPC * ipc, int forget, // if nonzero, kick all users out of the room
+ struct ctdlroom *qret, char *cret) {
int ret;
char *cmd;
/* GETA */
-int CtdlIPCGetRoomAide(CtdlIPC *ipc, char *cret)
-{
+int CtdlIPCGetRoomAide(CtdlIPC * ipc, char *cret) {
if (!cret)
return -1;
/* SETA */
-int CtdlIPCSetRoomAide(CtdlIPC *ipc, const char *username, char *cret) {
+int CtdlIPCSetRoomAide(CtdlIPC * ipc, const char *username, char *cret) {
int ret;
char *aaa;
/* ENT0 */
-int CtdlIPCPostMessage(CtdlIPC * ipc, int flag, int *subject_required, struct ctdlipcmessage *mr, char *cret)
-{
+int CtdlIPCPostMessage(CtdlIPC * ipc, int flag, int *subject_required, struct ctdlipcmessage *mr, char *cret) {
int ret;
char cmd[SIZ];
char *ptr;
/* CRE8 */
-int CtdlIPCCreateRoom(CtdlIPC * ipc, int for_real, const char *roomname, int type, const char *password, int floor, char *cret)
-{
+int CtdlIPCCreateRoom(CtdlIPC * ipc, int for_real, const char *roomname, int type, const char *password, int floor, char *cret) {
int ret;
char *aaa;
/* GNUR */
-int CtdlIPCNextUnvalidatedUser(CtdlIPC *ipc, char *cret) {
+int CtdlIPCNextUnvalidatedUser(CtdlIPC * ipc, char *cret) {
if (!cret)
return -2;
/* EINF */
-int CtdlIPCSetRoomInfo(CtdlIPC * ipc, int for_real, const char *info, char *cret)
-{
+int CtdlIPCSetRoomInfo(CtdlIPC * ipc, int for_real, const char *info, char *cret) {
char aaa[64];
if (!cret)
/* LIST */
-int CtdlIPCUserListing(CtdlIPC * ipc, char *searchstring, char **listing, char *cret)
-{
+int CtdlIPCUserListing(CtdlIPC * ipc, char *searchstring, char **listing, char *cret) {
size_t bytes;
char *cmd;
int ret;
/* REGI */
-int CtdlIPCSetRegistration(CtdlIPC * ipc, const char *info, char *cret)
-{
+int CtdlIPCSetRegistration(CtdlIPC * ipc, const char *info, char *cret) {
if (!cret)
return -1;
if (!info)
/* CHEK */
-int CtdlIPCMiscCheck(CtdlIPC * ipc, struct ctdlipcmisc *chek, char *cret)
-{
+int CtdlIPCMiscCheck(CtdlIPC * ipc, struct ctdlipcmisc *chek, char *cret) {
int ret;
if (!cret)
/* DELF */
-int CtdlIPCDeleteFile(CtdlIPC * ipc, const char *filename, char *cret)
-{
+int CtdlIPCDeleteFile(CtdlIPC * ipc, const char *filename, char *cret) {
int ret;
char *aaa;
/* MOVF */
-int CtdlIPCMoveFile(CtdlIPC * ipc, const char *filename, const char *destroom, char *cret)
-{
+int CtdlIPCMoveFile(CtdlIPC * ipc, const char *filename, const char *destroom, char *cret) {
int ret;
char *aaa;
/* RWHO */
-int CtdlIPCOnlineUsers(CtdlIPC * ipc, char **listing, time_t * stamp, char *cret)
-{
+int CtdlIPCOnlineUsers(CtdlIPC * ipc, char **listing, time_t * stamp, char *cret) {
int ret;
size_t bytes;
/* OPEN */
int CtdlIPCFileDownload(CtdlIPC * ipc, const char *filename, void **buf, size_t resume, void (*progress_gauge_callback)
- (CtdlIPC *, unsigned long, unsigned long), char *cret)
-{
+ (CtdlIPC *, unsigned long, unsigned long), char *cret) {
int ret;
size_t bytes;
time_t last_mod;
/* OPNA */
int CtdlIPCAttachmentDownload(CtdlIPC * ipc, long msgnum, const char *part, void **buf, void (*progress_gauge_callback)
- (CtdlIPC *, unsigned long, unsigned long), char *cret)
-{
+ (CtdlIPC *, unsigned long, unsigned long), char *cret) {
int ret;
size_t bytes;
time_t last_mod;
/* OIMG */
int CtdlIPCImageDownload(CtdlIPC * ipc, const char *filename, void **buf, void (*progress_gauge_callback)
- (CtdlIPC *, unsigned long, unsigned long), char *cret)
-{
+ (CtdlIPC *, unsigned long, unsigned long), char *cret) {
int ret;
size_t bytes;
time_t last_mod;
bytes = extract_long(cret, 0);
last_mod = extract_int(cret, 1);
extract_token(mimetype, cret, 2, '|', sizeof mimetype);
+
/* ret = CtdlIPCReadDownload(ipc, buf, bytes, 0, progress_gauge_callback, cret); */
ret = CtdlIPCHighSpeedReadDownload(ipc, buf, bytes, 0, progress_gauge_callback, cret);
ret = CtdlIPCEndDownload(ipc, cret);
/* UOPN */
int CtdlIPCFileUpload(CtdlIPC * ipc, const char *save_as, const char *comment, const char *path, void (*progress_gauge_callback)
- (CtdlIPC *, unsigned long, unsigned long), char *cret)
-{
+ (CtdlIPC *, unsigned long, unsigned long), char *cret) {
int ret;
char *aaa;
FILE *uploadFP;
/* UIMG */
int CtdlIPCImageUpload(CtdlIPC * ipc, int for_real, const char *path, const char *save_as, void (*progress_gauge_callback)
- (CtdlIPC *, unsigned long, unsigned long), char *cret)
-{
+ (CtdlIPC *, unsigned long, unsigned long), char *cret) {
int ret;
FILE *uploadFP;
char *aaa;
/* QUSR */
-int CtdlIPCQueryUsername(CtdlIPC * ipc, const char *username, char *cret)
-{
+int CtdlIPCQueryUsername(CtdlIPC * ipc, const char *username, char *cret) {
int ret;
char *aaa;
/* LFLR */
-int CtdlIPCFloorListing(CtdlIPC * ipc, char **listing, char *cret)
-{
+int CtdlIPCFloorListing(CtdlIPC * ipc, char **listing, char *cret) {
size_t bytes;
if (!cret)
/* CFLR */
-int CtdlIPCCreateFloor(CtdlIPC * ipc, int for_real, const char *name, char *cret)
-{
+int CtdlIPCCreateFloor(CtdlIPC * ipc, int for_real, const char *name, char *cret) {
int ret;
char aaa[SIZ];
/* KFLR */
-int CtdlIPCDeleteFloor(CtdlIPC * ipc, int for_real, int floornum, char *cret)
-{
+int CtdlIPCDeleteFloor(CtdlIPC * ipc, int for_real, int floornum, char *cret) {
char aaa[SIZ];
if (!cret)
/* EFLR */
-int CtdlIPCEditFloor(CtdlIPC * ipc, int floornum, const char *floorname, char *cret)
-{
+int CtdlIPCEditFloor(CtdlIPC * ipc, int floornum, const char *floorname, char *cret) {
int ret;
char aaa[SIZ];
* other fields are not set properly.
*/
int CtdlIPCIdentifySoftware(CtdlIPC * ipc, int developerid, int clientid,
- int revision, const char *software_name, const char *hostname, char *cret)
-{
+ int revision, const char *software_name, const char *hostname, char *cret) {
int ret;
char *aaa;
developerid = 8;
clientid = 0;
revision = CLIENT_VERSION - 600;
- software_name = "Citadel (libcitadel)";
+ software_name = "Citadel text client";
}
if (!hostname)
return -2;
/* SEXP */
-int CtdlIPCSendInstantMessage(CtdlIPC * ipc, const char *username, const char *text, char *cret)
-{
+int CtdlIPCSendInstantMessage(CtdlIPC * ipc, const char *username, const char *text, char *cret) {
int ret;
char *aaa;
if (text) {
sprintf(aaa, "SEXP %s|-", username);
ret = CtdlIPCGenericCommand(ipc, aaa, text, strlen(text), NULL, NULL, cret);
- } else {
+ }
+ else {
sprintf(aaa, "SEXP %s||", username);
ret = CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
}
/* GEXP */
-int CtdlIPCGetInstantMessage(CtdlIPC * ipc, char **listing, char *cret)
-{
+int CtdlIPCGetInstantMessage(CtdlIPC * ipc, char **listing, char *cret) {
size_t bytes;
if (!cret)
/* DEXP */
+
/* mode is 0 = enable, 1 = disable, 2 = status */
-int CtdlIPCEnableInstantMessageReceipt(CtdlIPC * ipc, int mode, char *cret)
-{
+int CtdlIPCEnableInstantMessageReceipt(CtdlIPC * ipc, int mode, char *cret) {
char aaa[64];
if (!cret)
/* EBIO */
-int CtdlIPCSetBio(CtdlIPC * ipc, char *bio, char *cret)
-{
+int CtdlIPCSetBio(CtdlIPC * ipc, char *bio, char *cret) {
if (!cret)
return -2;
if (!bio)
/* RBIO */
-int CtdlIPCGetBio(CtdlIPC * ipc, const char *username, char **listing, char *cret)
-{
+int CtdlIPCGetBio(CtdlIPC * ipc, const char *username, char **listing, char *cret) {
int ret;
size_t bytes;
char *aaa;
/* LBIO */
-int CtdlIPCListUsersWithBios(CtdlIPC * ipc, char **listing, char *cret)
-{
+int CtdlIPCListUsersWithBios(CtdlIPC * ipc, char **listing, char *cret) {
size_t bytes;
if (!cret)
/* STEL */
-int CtdlIPCStealthMode(CtdlIPC * ipc, int mode, char *cret)
-{
+int CtdlIPCStealthMode(CtdlIPC * ipc, int mode, char *cret) {
char aaa[64];
if (!cret)
/* TERM */
-int CtdlIPCTerminateSession(CtdlIPC * ipc, int sid, char *cret)
-{
+int CtdlIPCTerminateSession(CtdlIPC * ipc, int sid, char *cret) {
char aaa[64];
if (!cret)
/* DOWN */
-int CtdlIPCTerminateServerNow(CtdlIPC * ipc, char *cret)
-{
+int CtdlIPCTerminateServerNow(CtdlIPC * ipc, char *cret) {
if (!cret)
return -1;
/* SCDN */
-int CtdlIPCTerminateServerScheduled(CtdlIPC * ipc, int mode, char *cret)
-{
+int CtdlIPCTerminateServerScheduled(CtdlIPC * ipc, int mode, char *cret) {
char aaa[16];
if (!cret)
/* EMSG */
-int CtdlIPCEnterSystemMessage(CtdlIPC * ipc, const char *filename, const char *text, char *cret)
-{
+int CtdlIPCEnterSystemMessage(CtdlIPC * ipc, const char *filename, const char *text, char *cret) {
int ret;
char *aaa;
/* TIME */
+
/* This function returns the actual server time reported, or 0 if error */
-time_t CtdlIPCServerTime(CtdlIPC * ipc, char *cret)
-{
+time_t CtdlIPCServerTime(CtdlIPC * ipc, char *cret) {
time_t tret;
int ret;
ret = CtdlIPCGenericCommand(ipc, "TIME", NULL, 0, NULL, NULL, cret);
if (ret / 100 == 2) {
tret = extract_long(cret, 0);
- } else {
+ }
+ else {
tret = 0L;
}
return tret;
/* AGUP */
-int CtdlIPCAideGetUserParameters(CtdlIPC * ipc, const char *who, struct ctdluser **uret, char *cret)
-{
+int CtdlIPCAideGetUserParameters(CtdlIPC * ipc, const char *who, struct ctdluser **uret, char *cret) {
int ret;
char aaa[SIZ];
extract_token(uret[0]->fullname, cret, 0, '|', sizeof uret[0]->fullname);
extract_token(uret[0]->password, cret, 1, '|', sizeof uret[0]->password);
uret[0]->flags = extract_int(cret, 2);
- uret[0]->timescalled = extract_long(cret, 3);
- uret[0]->posted = extract_long(cret, 4);
uret[0]->axlevel = extract_int(cret, 5);
uret[0]->usernum = extract_long(cret, 6);
uret[0]->lastcall = extract_long(cret, 7);
/* ASUP */
-int CtdlIPCAideSetUserParameters(CtdlIPC * ipc, const struct ctdluser *uret, char *cret)
-{
+int CtdlIPCAideSetUserParameters(CtdlIPC * ipc, const struct ctdluser *uret, char *cret) {
int ret;
char *aaa;
if (!aaa)
return -1;
- sprintf(aaa, "ASUP %s|%s|%d|%ld|%ld|%d|%ld|%ld|%d",
- uret->fullname, uret->password, uret->flags, uret->timescalled,
- uret->posted, uret->axlevel, uret->usernum, uret->lastcall, uret->USuserpurge);
+ sprintf(aaa, "ASUP %s|%s|%d|0|0|%d|%ld|%ld|%d",
+ uret->fullname, uret->password, uret->flags, uret->axlevel, uret->usernum, uret->lastcall, uret->USuserpurge);
ret = CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
free(aaa);
return ret;
/* AGEA */
-int CtdlIPCAideGetEmailAddresses(CtdlIPC * ipc, const char *who, char *target_buf, char *cret)
-{
+int CtdlIPCAideGetEmailAddresses(CtdlIPC * ipc, const char *who, char *target_buf, char *cret) {
int ret;
char aaa[SIZ];
char *emailaddrs = NULL;
/* ASEA */
-int CtdlIPCAideSetEmailAddresses(CtdlIPC * ipc, const char *who, char *emailaddrs, char *cret)
-{
+int CtdlIPCAideSetEmailAddresses(CtdlIPC * ipc, const char *who, char *emailaddrs, char *cret) {
char aaa[SIZ];
int ret;
/* GPEX */
+
/* which is 0 = room, 1 = floor, 2 = site, 3 = default for mailboxes */
+
/* caller must free the struct ExpirePolicy */
-int CtdlIPCGetMessageExpirationPolicy(CtdlIPC * ipc, GPEXWhichPolicy which, struct ExpirePolicy **policy, char *cret)
-{
+int CtdlIPCGetMessageExpirationPolicy(CtdlIPC * ipc, GPEXWhichPolicy which, struct ExpirePolicy **policy, char *cret) {
static char *proto[] = {
strof(roompolicy),
strof(floorpolicy),
/* SPEX */
+
/* which is 0 = room, 1 = floor, 2 = site, 3 = default for mailboxes */
+
/* policy is 0 = inherit, 1 = no purge, 2 = by count, 3 = by age (days) */
-int CtdlIPCSetMessageExpirationPolicy(CtdlIPC * ipc, int which, struct ExpirePolicy *policy, char *cret)
-{
+int CtdlIPCSetMessageExpirationPolicy(CtdlIPC * ipc, int which, struct ExpirePolicy *policy, char *cret) {
char aaa[38];
char *whichvals[] = { "room", "floor", "site", "mailboxes" };
/* CONF GET */
-int CtdlIPCGetSystemConfig(CtdlIPC * ipc, char **listing, char *cret)
-{
+int CtdlIPCGetSystemConfig(CtdlIPC * ipc, char **listing, char *cret) {
size_t bytes;
if (!cret)
/* CONF SET */
-int CtdlIPCSetSystemConfig(CtdlIPC * ipc, const char *listing, char *cret)
-{
+int CtdlIPCSetSystemConfig(CtdlIPC * ipc, const char *listing, char *cret) {
if (!cret)
return -2;
if (!listing)
/* CONF GETSYS */
-int CtdlIPCGetSystemConfigByType(CtdlIPC * ipc, const char *mimetype, char **listing, char *cret)
-{
+int CtdlIPCGetSystemConfigByType(CtdlIPC * ipc, const char *mimetype, char **listing, char *cret) {
int ret;
char *aaa;
size_t bytes;
/* CONF PUTSYS */
-int CtdlIPCSetSystemConfigByType(CtdlIPC * ipc, const char *mimetype, const char *listing, char *cret)
-{
+int CtdlIPCSetSystemConfigByType(CtdlIPC * ipc, const char *mimetype, const char *listing, char *cret) {
int ret;
char *aaa;
/* GNET */
-int CtdlIPCGetRoomNetworkConfig(CtdlIPC * ipc, char **listing, char *cret)
-{
+int CtdlIPCGetRoomNetworkConfig(CtdlIPC * ipc, char **listing, char *cret) {
size_t bytes;
if (!cret)
/* SNET */
-int CtdlIPCSetRoomNetworkConfig(CtdlIPC * ipc, const char *listing, char *cret)
-{
+int CtdlIPCSetRoomNetworkConfig(CtdlIPC * ipc, const char *listing, char *cret) {
if (!cret)
return -2;
if (!listing)
/* REQT */
-int CtdlIPCRequestClientLogout(CtdlIPC * ipc, int session, char *cret)
-{
+int CtdlIPCRequestClientLogout(CtdlIPC * ipc, int session, char *cret) {
char aaa[64];
if (!cret)
/* SEEN */
-int CtdlIPCSetMessageSeen(CtdlIPC * ipc, long msgnum, int seen, char *cret)
-{
+int CtdlIPCSetMessageSeen(CtdlIPC * ipc, long msgnum, int seen, char *cret) {
char aaa[27];
if (!cret)
/* STLS */
-int CtdlIPCStartEncryption(CtdlIPC * ipc, char *cret)
-{
+int CtdlIPCStartEncryption(CtdlIPC * ipc, char *cret) {
int a;
int r;
char buf[SIZ];
#ifdef HAVE_OPENSSL
-static void endtls(SSL * ssl)
-{
+static void endtls(SSL * ssl) {
if (ssl) {
SSL_shutdown(ssl);
SSL_free(ssl);
/* QDIR */
-int CtdlIPCDirectoryLookup(CtdlIPC * ipc, const char *address, char *cret)
-{
+int CtdlIPCDirectoryLookup(CtdlIPC * ipc, const char *address, char *cret) {
int ret;
char *aaa;
/* IPGM */
-int CtdlIPCInternalProgram(CtdlIPC * ipc, int secret, char *cret)
-{
+int CtdlIPCInternalProgram(CtdlIPC * ipc, int secret, char *cret) {
char aaa[30];
if (!cret)
/* ************************************************************************** */
+
/* Stuff below this line is not for public consumption */
+
/* ************************************************************************** */
/* Read a listing from the server up to 000. Append to dest if it exists */
-char *CtdlIPCReadListing(CtdlIPC * ipc, char *dest)
-{
+char *CtdlIPCReadListing(CtdlIPC * ipc, char *dest) {
size_t length = 0;
size_t linelength;
char *ret = NULL;
ret = dest;
if (ret != NULL) {
length = strlen(ret);
- } else {
+ }
+ else {
length = 0;
}
/* Send a listing to the server; generate the ending 000. */
-int CtdlIPCSendListing(CtdlIPC * ipc, const char *listing)
-{
+int CtdlIPCSendListing(CtdlIPC * ipc, const char *listing) {
char *text;
text = (char *) malloc(strlen(listing) + 6);
CtdlIPC_putline(ipc, text);
free(text);
text = NULL;
- } else {
+ }
+ else {
/* Malloc failed but we are committed to send */
/* This may result in extra blanks at the bottom */
CtdlIPC_putline(ipc, text);
/* Partial read of file from server */
-size_t CtdlIPCPartialRead(CtdlIPC * ipc, void **buf, size_t offset, size_t bytes, char *cret)
-{
+size_t CtdlIPCPartialRead(CtdlIPC * ipc, void **buf, size_t offset, size_t bytes, char *cret) {
size_t len = 0;
char aaa[SIZ];
if (*buf) {
/* I know what I'm doing */
serv_read(ipc, ((char *) (*buf) + offset), len);
- } else {
+ }
+ else {
/* We have to read regardless */
serv_read(ipc, aaa, len);
len = 0;
/* CLOS */
-int CtdlIPCEndDownload(CtdlIPC * ipc, char *cret)
-{
+int CtdlIPCEndDownload(CtdlIPC * ipc, char *cret) {
int ret;
if (!cret)
/* MSGP */
-int CtdlIPCSpecifyPreferredFormats(CtdlIPC * ipc, char *cret, char *formats)
-{
+int CtdlIPCSpecifyPreferredFormats(CtdlIPC * ipc, char *cret, char *formats) {
int ret;
char cmd[SIZ];
/* READ */
int CtdlIPCReadDownload(CtdlIPC * ipc, void **buf, size_t bytes, size_t resume, void (*progress_gauge_callback)
- (CtdlIPC *, unsigned long, unsigned long), char *cret)
-{
+ (CtdlIPC *, unsigned long, unsigned long), char *cret) {
size_t len;
if (!cret)
/* READ - pipelined */
int CtdlIPCHighSpeedReadDownload(CtdlIPC * ipc, void **buf, size_t bytes, size_t resume, void (*progress_gauge_callback)
- (CtdlIPC *, unsigned long, unsigned long), char *cret)
-{
+ (CtdlIPC *, unsigned long, unsigned long), char *cret) {
size_t len;
int calls; /* How many calls in the pipeline */
int i; /* iterator */
/* UCLS */
-int CtdlIPCEndUpload(CtdlIPC * ipc, int discard, char *cret)
-{
+int CtdlIPCEndUpload(CtdlIPC * ipc, int discard, char *cret) {
int ret;
char cmd[8];
/* WRIT */
int CtdlIPCWriteUpload(CtdlIPC * ipc, FILE * uploadFP, void (*progress_gauge_callback)
- (CtdlIPC *, unsigned long, unsigned long), char *cret)
-{
+ (CtdlIPC *, unsigned long, unsigned long), char *cret) {
int ret = -1;
size_t offset = 0;
size_t bytes;
/* Detect short reads and back up if needed */
/* offset will never be negative anyway */
fseek(fd, (signed) offset, SEEK_SET);
- } else {
+ }
+ else {
break;
}
}
* protocol_response as described above. Some commands send additional
* data in this string.
*/
-int CtdlIPCGenericCommand(CtdlIPC *ipc,
- const char *command,
- const char *to_send,
- size_t bytes_to_send,
- char **to_receive,
- size_t *bytes_to_receive,
- char *proto_response
-) {
+int CtdlIPCGenericCommand(CtdlIPC * ipc,
+ const char *command,
+ const char *to_send,
+ size_t bytes_to_send, char **to_receive, size_t *bytes_to_receive, char *proto_response) {
char buf[SIZ];
int ret;
case 1: /* LISTING_FOLLOWS */
if (to_receive && !*to_receive && bytes_to_receive) {
*to_receive = CtdlIPCReadListing(ipc, NULL);
- } else { /* Drain */
+ }
+ else { /* Drain */
while (CtdlIPC_getline(ipc, buf), strcmp(buf, "000"));
ret = -ret;
}
case 4: /* SEND_LISTING */
if (to_send) {
CtdlIPCSendListing(ipc, to_send);
- } else {
+ }
+ else {
/* No listing given, fake it */
CtdlIPC_putline(ipc, "000");
ret = -ret;
if (to_receive && !*to_receive && bytes_to_receive) {
*bytes_to_receive = extract_long(proto_response, 0);
*to_receive = (char *)
- malloc((size_t) * bytes_to_receive);
+ malloc((size_t) *bytes_to_receive);
if (!*to_receive) {
ret = -1;
- } else {
+ }
+ else {
serv_read(ipc, *to_receive, *bytes_to_receive);
}
- } else {
+ }
+ else {
/* Drain */
size_t drain;
case 7: /* SEND_BINARY */
if (to_send && bytes_to_send) {
serv_write(ipc, to_send, bytes_to_send);
- } else if (bytes_to_send) {
+ }
+ else if (bytes_to_send) {
/* Fake it, send nulls */
size_t fake;
ret = -ret;
} /* else who knows? DANGER WILL ROBINSON */
break;
- case 8: /* START_CHAT_MODE */
+ case 8: /* SEND_THEN_RECV */
if (!strncasecmp(command, "CHAT", 4)) {
/* Don't call chatmode with generic! */
CtdlIPC_putline(ipc, "/quit");
#ifdef HAVE_OPENSSL
+
/*
* input binary data from encrypted connection
*/
buf[i--] = 0;
if (i >= 0 && buf[i] == 13)
buf[i--] = 0;
- } else
+ }
+ else
#endif
{
if (ipc->Buf == NULL) {
/* is there more in the buffer we need to read later? */
if (ipc->Buf + ipc->BufUsed > aptr) {
ipc->BufPtr = aptr;
- } else {
+ }
+ else {
ipc->BufUsed = 0;
ipc->BufPtr = ipc->Buf;
}
/*
* Disconnect and delete the IPC class (destructor)
*/
-void CtdlIPC_delete(CtdlIPC *ipc) {
+void CtdlIPC_delete(CtdlIPC * ipc) {
#ifdef HAVE_OPENSSL
if (ipc->ssl) {
SSL_shutdown(ipc->ssl);
* Disconnect and delete the IPC class (destructor)
* Also NULLs out the pointer
*/
-void CtdlIPC_delete_ptr(CtdlIPC **pipc) {
+void CtdlIPC_delete_ptr(CtdlIPC ** pipc) {
CtdlIPC_delete(*pipc);
*pipc = NULL;
}
projects / citadel.git / blobdiff