citadel/citadel_ipc.c

   1 /* $Id$ */
   2
   3 #define UDS                     "_UDS_"
   4 #define DEFAULT_HOST            UDS
   5 #define DEFAULT_PORT            "citadel"
   6
   7 #include "sysdep.h"
   8 #if TIME_WITH_SYS_TIME
   9 # include <sys/time.h>
  10 # include <time.h>
  11 #else
  12 # if HAVE_SYS_TIME_H
  13 #  include <sys/time.h>
  14 # else
  15 #  include <time.h>
  16 # endif
  17 #endif
  18 #include <unistd.h>
  19 #include <stdio.h>
  20 #include <sys/types.h>
  21 #include <string.h>
  22 #ifdef HAVE_MALLOC_H
  23 #include <malloc.h>
  24 #endif
  25 #include <stdlib.h>
  26 #include <ctype.h>
  27 #include <sys/socket.h>
  28 #include <arpa/inet.h>
  29 #include <netinet/in.h>
  30 #include <netdb.h>
  31 #include <sys/un.h>
  32 #include <errno.h>
  33 #ifdef THREADED_CLIENT
  34 #include <pthread.h>
  35 #endif
  36 #include "citadel.h"
  37 #include "citadel_ipc.h"
  38 #include "citadel_decls.h"
  39 #include "tools.h"
  40
  41 #ifdef THREADED_CLIENT
  42 pthread_mutex_t rwlock;
  43 #endif
  44
  45 #ifdef HAVE_OPENSSL
  46 static SSL_CTX *ssl_ctx;
  47 char arg_encrypt;
  48 char rc_encrypt;
  49 #ifdef THREADED_CLIENT
  50 pthread_mutex_t **Critters;                     /* Things that need locking */
  51 #endif /* THREADED_CLIENT */
  52
  53 #endif /* HAVE_OPENSSL */
  54
  55 #ifndef INADDR_NONE
  56 #define INADDR_NONE 0xffffffff
  57 #endif
  58
  59 static void (*status_hook)(char *s) = NULL;
  60
  61 void setCryptoStatusHook(void (*hook)(char *s)) {
  62         status_hook = hook;
  63 }
  64
  65 void CtdlIPC_SetNetworkStatusCallback(CtdlIPC *ipc, void (*hook)(int state)) {
  66         ipc->network_status_cb = hook;
  67 }
  68
  69
  70 char express_msgs = 0;
  71
  72
  73 static void serv_read(CtdlIPC *ipc, char *buf, unsigned int bytes);
  74 static void serv_write(CtdlIPC *ipc, const char *buf, unsigned int nbytes);
  75 #ifdef HAVE_OPENSSL
  76 static void serv_read_ssl(CtdlIPC *ipc, char *buf, unsigned int bytes);
  77 static void serv_write_ssl(CtdlIPC *ipc, const char *buf, unsigned int nbytes);
  78 static void ssl_lock(int mode, int n, const char *file, int line);
  79 static void endtls(SSL *ssl);
  80 #ifdef THREADED_CLIENT
  81 static unsigned long id_callback(void);
  82 #endif /* THREADED_CLIENT */
  83 #endif /* HAVE_OPENSSL */
  84
  85
  86 /*
  87  * Does nothing.  The server should always return 200.
  88  */
  89 int CtdlIPCNoop(CtdlIPC *ipc)
  90 {
  91         char aaa[128];
  92
  93         return CtdlIPCGenericCommand(ipc, "NOOP", NULL, 0, NULL, NULL, aaa);
  94 }
  95
  96
  97 /*
  98  * Does nothing interesting.  The server should always return 200
  99  * along with your string.
 100  */
 101 int CtdlIPCEcho(CtdlIPC *ipc, const char *arg, char *cret)
 102 {
 103         register int ret;
 104         char *aaa;
 105
 106         if (!arg) return -2;
 107         if (!cret) return -2;
 108
 109         aaa = (char *)malloc((size_t)(strlen(arg) + 6));
 110         if (!aaa) return -1;
 111
 112         sprintf(aaa, "ECHO %s", arg);
 113         ret = CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
 114         free(aaa);
 115         return ret;
 116 }
 117
 118
 119 /*
 120  * Asks the server to close the connecction.
 121  * Should always return 200.
 122  */
 123 int CtdlIPCQuit(CtdlIPC *ipc)
 124 {
 125         register int ret;
 126         char aaa[128];
 127
 128         CtdlIPC_lock(ipc);
 129         CtdlIPC_putline(ipc, "QUIT");
 130         CtdlIPC_getline(ipc, aaa);
 131         ret = atoi(aaa);
 132         CtdlIPC_unlock(ipc);
 133         return ret;
 134 }
 135
 136
 137 /*
 138  * Asks the server to logout.  Should always return 200, even if no user
 139  * was logged in.  The user will not be logged in after this!
 140  */
 141 int CtdlIPCLogout(CtdlIPC *ipc)
 142 {
 143         register int ret;
 144         char aaa[128];
 145
 146         CtdlIPC_lock(ipc);
 147         CtdlIPC_putline(ipc, "LOUT");
 148         CtdlIPC_getline(ipc, aaa);
 149         ret = atoi(aaa);
 150         CtdlIPC_unlock(ipc);
 151         return ret;
 152 }
 153
 154
 155 /*
 156  * First stage of authentication - pass the username.  Returns 300 if the
 157  * username is able to log in, with the username correctly spelled in cret.
 158  * Returns various 500 error codes if the user doesn't exist, etc.
 159  */
 160 int CtdlIPCTryLogin(CtdlIPC *ipc, const char *username, char *cret)
 161 {
 162         register int ret;
 163         char *aaa;
 164
 165         if (!username) return -2;
 166         if (!cret) return -2;
 167
 168         aaa = (char *)malloc((size_t)(strlen(username) + 6));
 169         if (!aaa) return -1;
 170
 171         sprintf(aaa, "USER %s", username);
 172         ret = CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
 173         free(aaa);
 174         return ret;
 175 }
 176
 177
 178 /*
 179  * Second stage of authentication - provide password.  The server returns
 180  * 200 and several arguments in cret relating to the user's account.
 181  */
 182 int CtdlIPCTryPassword(CtdlIPC *ipc, const char *passwd, char *cret)
 183 {
 184         register int ret;
 185         char *aaa;
 186
 187         if (!passwd) return -2;
 188         if (!cret) return -2;
 189
 190         aaa = (char *)malloc((size_t)(strlen(passwd) + 6));
 191         if (!aaa) return -1;
 192
 193         sprintf(aaa, "PASS %s", passwd);
 194         ret = CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
 195         free(aaa);
 196         return ret;
 197 }
 198
 199
 200 /*
 201  * Second stage of authentication - provide password.  The server returns
 202  * 200 and several arguments in cret relating to the user's account.
 203  */
 204 int CtdlIPCTryApopPassword(CtdlIPC *ipc, const char *response, char *cret)
 205 {
 206         register int ret;
 207         char *aaa;
 208
 209         if (!response) return -2;
 210         if (!cret) return -2;
 211
 212         aaa = (char *)malloc((size_t)(strlen(response) + 6));
 213         if (!aaa) return -1;
 214
 215         sprintf(aaa, "PAS2 %s", response);
 216         ret = CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
 217         free(aaa);
 218         return ret;
 219 }
 220
 221
 222 /*
 223  * Create a new user.  This returns 200 plus the same arguments as TryPassword
 224  * if selfservice is nonzero, unless there was a problem creating the account.
 225  * If selfservice is zero, creates a new user but does not log out the existing
 226  * user - intended for use by system administrators to create accounts on
 227  * behalf of other users.
 228  */
 229 int CtdlIPCCreateUser(CtdlIPC *ipc, const char *username, int selfservice, char *cret)
 230 {
 231         register int ret;
 232         char *aaa;
 233
 234         if (!username) return -2;
 235         if (!cret) return -2;
 236
 237         aaa = (char *)malloc((size_t)(strlen(username) + 6));
 238         if (!aaa) return -1;
 239
 240         sprintf(aaa, "%s %s", selfservice ? "NEWU" : "CREU",  username);
 241         ret = CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
 242         free(aaa);
 243         return ret;
 244 }
 245
 246
 247 /*
 248  * Changes the user's password.  Returns 200 if changed, errors otherwise.
 249  */
 250 int CtdlIPCChangePassword(CtdlIPC *ipc, const char *passwd, char *cret)
 251 {
 252         register int ret;
 253         char *aaa;
 254
 255         if (!passwd) return -2;
 256         if (!cret) return -2;
 257
 258         aaa = (char *)malloc((size_t)(strlen(passwd) + 6));
 259         if (!aaa) return -1;
 260
 261         sprintf(aaa, "SETP %s", passwd);
 262         ret = CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
 263         free(aaa);
 264         return ret;
 265 }
 266
 267
 268 /* LKRN */
 269 /* Caller must free the march list */
 270 /* Room types are defined in enum RoomList; keep these in sync! */
 271 /* floor is -1 for all, or floornum */
 272 int CtdlIPCKnownRooms(CtdlIPC *ipc, enum RoomList which, int floor, struct march **listing, char *cret)
 273 {
 274         register int ret;
 275         struct march *march = NULL;
 276         static char *proto[] =
 277                 {"LKRA", "LKRN", "LKRO", "LZRM", "LRMS", "LPRM" };
 278         char aaa[SIZ];
 279         char *bbb = NULL;
 280         size_t bbbsize;
 281
 282         if (!listing) return -2;
 283         if (*listing) return -2;        /* Free the listing first */
 284         if (!cret) return -2;
 285         /* if (which < 0 || which > 4) return -2; */
 286         if (floor < -1) return -2;      /* Can't validate upper bound, sorry */
 287
 288         sprintf(aaa, "%s %d", proto[which], floor);
 289         ret = CtdlIPCGenericCommand(ipc, aaa, NULL, 0, &bbb, &bbbsize, cret);
 290         if (ret / 100 == 1) {
 291                 struct march *mptr;
 292
 293                 while (bbb && strlen(bbb)) {
 294                         int a;
 295
 296                         extract_token(aaa, bbb, 0, '\n');
 297                         a = strlen(aaa);
 298                         memmove(bbb, bbb + a + 1, strlen(bbb) - a);
 299                         mptr = (struct march *) malloc(sizeof (struct march));
 300                         if (mptr) {
 301                                 mptr->next = NULL;
 302                                 extract(mptr->march_name, aaa, 0);
 303                                 mptr->march_flags = (unsigned int) extract_int(aaa, 1);
 304                                 mptr->march_floor = (char) extract_int(aaa, 2);
 305                                 mptr->march_order = (char) extract_int(aaa, 3);
 306                                 if (march == NULL)
 307                                         march = mptr;
 308                                 else {
 309                                         struct march *mptr2;
 310
 311                                         mptr2 = march;
 312                                         while (mptr2->next != NULL)
 313                                                 mptr2 = mptr2->next;
 314                                         mptr2->next = mptr;
 315                                 }
 316                         }
 317                 }
 318         }
 319         *listing = march;
 320         return ret;
 321 }
 322
 323
 324 /* GETU */
 325 /* Caller must free the struct usersupp; caller may pass an existing one */
 326 int CtdlIPCGetConfig(CtdlIPC *ipc, struct usersupp **uret, char *cret)
 327 {
 328         register int ret;
 329
 330         if (!cret) return -2;
 331         if (!uret) return -2;
 332         if (!*uret) *uret = (struct usersupp *)calloc(1, sizeof (struct usersupp));
 333         if (!*uret) return -1;
 334
 335         ret = CtdlIPCGenericCommand(ipc, "GETU", NULL, 0, NULL, NULL, cret);
 336         if (ret / 100 == 2) {
 337                 uret[0]->USscreenwidth = extract_int(cret, 0);
 338                 uret[0]->USscreenheight = extract_int(cret, 1);
 339                 uret[0]->flags = extract_int(cret, 2);
 340         }
 341         return ret;
 342 }
 343
 344
 345 /* SETU */
 346 int CtdlIPCSetConfig(CtdlIPC *ipc, struct usersupp *uret, char *cret)
 347 {
 348         char aaa[48];
 349
 350         if (!uret) return -2;
 351         if (!cret) return -2;
 352
 353         sprintf(aaa, "SETU %d|%d|%d",
 354                         uret->USscreenwidth, uret->USscreenheight,
 355                         uret->flags);
 356         return CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
 357 }
 358
 359
 360 /* GOTO */
 361 int CtdlIPCGotoRoom(CtdlIPC *ipc, const char *room, const char *passwd,
 362                 struct ctdlipcroom **rret, char *cret)
 363 {
 364         register int ret;
 365         char *aaa;
 366
 367         if (!cret) return -2;
 368         if (!rret) return -2;
 369         if (!*rret) *rret = (struct ctdlipcroom *)calloc(1, sizeof (struct ctdlipcroom));
 370         if (!*rret) return -1;
 371
 372         if (passwd) {
 373                 aaa = (char *)malloc(strlen(room) + strlen(passwd) + 7);
 374                 if (!aaa) {
 375                         free(*rret);
 376                         return -1;
 377                 }
 378                 sprintf(aaa, "GOTO %s|%s", room, passwd);
 379         } else {
 380                 aaa = (char *)malloc(strlen(room) + 6);
 381                 if (!aaa) {
 382                         free(*rret);
 383                         return -1;
 384                 }
 385                 sprintf(aaa, "GOTO %s", room);
 386         }
 387         ret = CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
 388         if (ret / 100 == 2) {
 389                 extract(rret[0]->RRname, cret, 0);
 390                 rret[0]->RRunread = extract_long(cret, 1);
 391                 rret[0]->RRtotal = extract_long(cret, 2);
 392                 rret[0]->RRinfoupdated = extract_int(cret, 3);
 393                 rret[0]->RRflags = extract_int(cret, 4);
 394                 rret[0]->RRhighest = extract_long(cret, 5);
 395                 rret[0]->RRlastread = extract_long(cret, 6);
 396                 rret[0]->RRismailbox = extract_int(cret, 7);
 397                 rret[0]->RRaide = extract_int(cret, 8);
 398                 rret[0]->RRnewmail = extract_long(cret, 9);
 399                 rret[0]->RRfloor = extract_int(cret, 10);
 400         } else {
 401                 free(*rret);
 402         }
 403         return ret;
 404 }
 405
 406
 407 /* MSGS */
 408 /* which is 0 = all, 1 = old, 2 = new, 3 = last, 4 = first, 5 = gt, 6 = lt */
 409 /* whicharg is number of messages, applies to last, first, gt, lt */
 410 int CtdlIPCGetMessages(CtdlIPC *ipc, int which, int whicharg,
 411                 const char *mtemplate, long **mret, char *cret)
 412 {
 413         register int ret;
 414         register unsigned long count = 0;
 415         static char *proto[] =
 416                 { "ALL", "OLD", "NEW", "LAST", "FIRST", "GT", "LT" };
 417         char aaa[33];
 418         char *bbb;
 419         size_t bbbsize;
 420
 421         if (!cret) return -2;
 422         if (!mret) return -2;
 423         if (*mret) return -2;
 424         if (which < 0 || which > 6) return -2;
 425
 426         if (which <= 2)
 427                 sprintf(aaa, "MSGS %s||%d", proto[which],
 428                                 (mtemplate) ? 1 : 0);
 429         else
 430                 sprintf(aaa, "MSGS %s|%d|%d", proto[which], whicharg,
 431                                 (mtemplate) ? 1 : 0);
 432         if (mtemplate) count = strlen(mtemplate);
 433         ret = CtdlIPCGenericCommand(ipc, aaa, mtemplate, count, &bbb, &bbbsize, cret);
 434         count = 0;
 435         while (strlen(bbb)) {
 436                 int a;
 437
 438                 extract_token(aaa, bbb, 0, '\n');
 439                 a = strlen(aaa);
 440                 memmove(aaa, bbb + a + 1, strlen(bbb) - a - 1);
 441                 *mret = (long *)realloc(mret,
 442                                         (size_t)((count + 1) * sizeof (long)));
 443                 if (*mret)
 444                         *mret[count++] = atol(aaa);
 445                 *mret[count] = 0L;
 446         }
 447         return ret;
 448 }
 449
 450
 451 /* MSG0, MSG2 */
 452 int CtdlIPCGetSingleMessage(CtdlIPC *ipc, long msgnum, int headers, int as_mime,
 453                 struct ctdlipcmessage **mret, char *cret)
 454 {
 455         register int ret;
 456         char aaa[SIZ];
 457         char *bbb = NULL;
 458         size_t bbbsize;
 459         int multipart_hunting = 0;
 460         char multipart_prefix[SIZ];
 461
 462         if (!cret) return -1;
 463         if (!mret) return -1;
 464         if (!*mret) *mret = (struct ctdlipcmessage *)calloc(1, sizeof (struct ctdlipcmessage));
 465         if (!*mret) return -1;
 466         if (!msgnum) return -1;
 467
 468         strcpy(mret[0]->content_type, "");
 469         sprintf(aaa, "MSG%d %ld|%d", as_mime, msgnum, headers);
 470         ret = CtdlIPCGenericCommand(ipc, aaa, NULL, 0, &bbb, &bbbsize, cret);
 471         if (ret / 100 == 1) {
 472                 if (as_mime != 2) {
 473                         strcpy(mret[0]->mime_chosen, "1");      /* Default chosen-part is "1" */
 474                         while (strlen(bbb) > 4 && bbb[4] == '=') {
 475                                 extract_token(aaa, bbb, 0, '\n');
 476                                 remove_token(bbb, 0, '\n');
 477
 478                                 if (!strncasecmp(aaa, "nhdr=yes", 8))
 479                                         mret[0]->nhdr = 1;
 480                                 else if (!strncasecmp(aaa, "from=", 5))
 481                                         strcpy(mret[0]->author, &aaa[5]);
 482                                 else if (!strncasecmp(aaa, "type=", 5))
 483                                         mret[0]->type = atoi(&aaa[5]);
 484                                 else if (!strncasecmp(aaa, "msgn=", 5))
 485                                         strcpy(mret[0]->msgid, &aaa[5]);
 486                                 else if (!strncasecmp(aaa, "subj=", 5))
 487                                         strcpy(mret[0]->subject, &aaa[5]);
 488                                 else if (!strncasecmp(aaa, "rfca=", 5))
 489                                         strcpy(mret[0]->email, &aaa[5]);
 490                                 else if (!strncasecmp(aaa, "hnod=", 5))
 491                                         strcpy(mret[0]->hnod, &aaa[5]);
 492                                 else if (!strncasecmp(aaa, "room=", 5))
 493                                         strcpy(mret[0]->room, &aaa[5]);
 494                                 else if (!strncasecmp(aaa, "node=", 5))
 495                                         strcpy(mret[0]->node, &aaa[5]);
 496                                 else if (!strncasecmp(aaa, "rcpt=", 5))
 497                                         strcpy(mret[0]->recipient, &aaa[5]);
 498                                 else if (!strncasecmp(aaa, "time=", 5))
 499                                         mret[0]->time = atol(&aaa[5]);
 500
 501                                 /* Multipart/alternative prefix & suffix strings help
 502                                  * us to determine which part we want to download.
 503                                  */
 504                                 else if (!strncasecmp(aaa, "pref=", 5)) {
 505                                         extract(multipart_prefix, &aaa[5], 1);
 506                                         if (!strcasecmp(multipart_prefix,
 507                                            "multipart/alternative")) {
 508                                                 ++multipart_hunting;
 509                                         }
 510                                 }
 511                                 else if (!strncasecmp(aaa, "suff=", 5)) {
 512                                         extract(multipart_prefix, &aaa[5], 1);
 513                                         if (!strcasecmp(multipart_prefix,
 514                                            "multipart/alternative")) {
 515                                                 ++multipart_hunting;
 516                                         }
 517                                 }
 518
 519                                 else if (!strncasecmp(aaa, "part=", 5)) {
 520                                         struct parts *ptr, *chain;
 521
 522                                         ptr = (struct parts *)calloc(1, sizeof (struct parts));
 523                                         if (ptr) {
 524
 525                                                 /* Fill the buffers for the caller */
 526                                                 extract(ptr->name, &aaa[5], 0);
 527                                                 extract(ptr->filename, &aaa[5], 1);
 528                                                 extract(ptr->number, &aaa[5], 2);
 529                                                 extract(ptr->disposition, &aaa[5], 3);
 530                                                 extract(ptr->mimetype, &aaa[5], 4);
 531                                                 ptr->length = extract_long(&aaa[5], 5);
 532                                                 if (!mret[0]->attachments)
 533                                                         mret[0]->attachments = ptr;
 534                                                 else {
 535                                                         chain = mret[0]->attachments;
 536                                                         while (chain->next)
 537                                                                 chain = chain->next;
 538                                                         chain->next = ptr;
 539                                                 }
 540
 541                                                 /* Now handle multipart/alternative */
 542                                                 if (multipart_hunting > 0) {
 543                                                         if ( (!strcasecmp(ptr->mimetype,
 544                                                              "text/plain"))
 545                                                            || (!strcasecmp(ptr->mimetype,
 546                                                               "text/html")) ) {
 547                                                                 strcpy(mret[0]->mime_chosen,
 548                                                                         ptr->number);
 549                                                         }
 550                                                 }
 551
 552                                         }
 553                                 }
 554                         }
 555                         /* Eliminate "text\n" */
 556                         remove_token(bbb, 0, '\n');
 557
 558                         /* If doing a MIME thing, pull out the extra headers */
 559                         if (as_mime == 4) {
 560                                 do {
 561                                         if (!strncasecmp(bbb, "Content-type: ", 14)) {
 562                                                 extract_token(mret[0]->content_type, bbb, 0, '\n');
 563                                                 strcpy(mret[0]->content_type,
 564                                                         &mret[0]->content_type[14]);
 565                                                 striplt(mret[0]->content_type);
 566                                         }
 567                                         remove_token(bbb, 0, '\n');
 568                                 } while ((bbb[0] != 0) && (bbb[0] != '\n'));
 569                         }
 570
 571
 572                 }
 573                 if (strlen(bbb)) {
 574                         /* Strip trailing whitespace */
 575                         bbb = (char *)realloc(bbb, (size_t)(strlen(bbb) + 1));
 576                 } else {
 577                         bbb = (char *)realloc(bbb, 1);
 578                         *bbb = '\0';
 579                 }
 580                 mret[0]->text = bbb;
 581         }
 582         return ret;
 583 }
 584
 585
 586 /* WHOK */
 587 int CtdlIPCWhoKnowsRoom(CtdlIPC *ipc, char **listing, char *cret)
 588 {
 589         register int ret;
 590         size_t bytes;
 591
 592         if (!cret) return -2;
 593         if (!listing) return -2;
 594         if (*listing) return -2;
 595
 596         ret = CtdlIPCGenericCommand(ipc, "WHOK", NULL, 0, listing, &bytes, cret);
 597         return ret;
 598 }
 599
 600
 601 /* INFO */
 602 int CtdlIPCServerInfo(CtdlIPC *ipc, struct CtdlServInfo *ServInfo, char *cret)
 603 {
 604         register int ret;
 605         size_t bytes;
 606         char *listing = NULL;
 607         char buf[SIZ];
 608
 609         if (!cret) return -2;
 610         if (!ServInfo) return -2;
 611
 612         ret = CtdlIPCGenericCommand(ipc, "INFO", NULL, 0, &listing, &bytes, cret);
 613         if (ret / 100 == 1) {
 614                 int line = 0;
 615
 616                 while (*listing && strlen(listing)) {
 617                         extract_token(buf, listing, 0, '\n');
 618                         remove_token(listing, 0, '\n');
 619                         switch (line++) {
 620                         case 0:         ServInfo->serv_pid = atoi(buf);
 621                                         break;
 622                         case 1:         strcpy(ServInfo->serv_nodename,buf);
 623                                         break;
 624                         case 2:         strcpy(ServInfo->serv_humannode,buf);
 625                                         break;
 626                         case 3:         strcpy(ServInfo->serv_fqdn,buf);
 627                                         break;
 628                         case 4:         strcpy(ServInfo->serv_software,buf);
 629                                         break;
 630                         case 5:         ServInfo->serv_rev_level = atoi(buf);
 631                                         break;
 632                         case 6:         strcpy(ServInfo->serv_bbs_city,buf);
 633                                         break;
 634                         case 7:         strcpy(ServInfo->serv_sysadm,buf);
 635                                         break;
 636                         case 9:         strcpy(ServInfo->serv_moreprompt,buf);
 637                                         break;
 638                         case 10:        ServInfo->serv_ok_floors = atoi(buf);
 639                                         break;
 640                         case 11:        ServInfo->serv_paging_level = atoi(buf);
 641                                         break;
 642                         case 13:        ServInfo->serv_supports_qnop = atoi(buf);
 643                                         break;
 644                         }
 645                 }
 646
 647         }
 648         return ret;
 649 }
 650
 651
 652 /* RDIR */
 653 int CtdlIPCReadDirectory(CtdlIPC *ipc, char **listing, char *cret)
 654 {
 655         register int ret;
 656         size_t bytes;
 657
 658         if (!cret) return -2;
 659         if (!listing) return -2;
 660         if (*listing) return -2;
 661
 662         ret = CtdlIPCGenericCommand(ipc, "RDIR", NULL, 0, listing, &bytes, cret);
 663         return ret;
 664 }
 665
 666
 667 /*
 668  * Set last-read pointer in this room to msgnum, or 0 for HIGHEST.
 669  */
 670 int CtdlIPCSetLastRead(CtdlIPC *ipc, long msgnum, char *cret)
 671 {
 672         register int ret;
 673         char aaa[16];
 674
 675         if (!cret) return -2;
 676
 677         if (msgnum)
 678                 sprintf(aaa, "SLRP %ld", msgnum);
 679         else
 680                 sprintf(aaa, "SLRP HIGHEST");
 681         ret = CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
 682         return ret;
 683 }
 684
 685
 686 /* INVT */
 687 int CtdlIPCInviteUserToRoom(CtdlIPC *ipc, const char *username, char *cret)
 688 {
 689         register int ret;
 690         char *aaa;
 691
 692         if (!cret) return -2;
 693         if (!username) return -2;
 694
 695         aaa = (char *)malloc(strlen(username) + 6);
 696         if (!aaa) return -1;
 697
 698         sprintf(aaa, "INVT %s", username);
 699         ret = CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
 700         free(aaa);
 701         return ret;
 702 }
 703
 704
 705 /* KICK */
 706 int CtdlIPCKickoutUserFromRoom(CtdlIPC *ipc, const char *username, char *cret)
 707 {
 708         register int ret;
 709         char *aaa;
 710
 711         if (!cret) return -1;
 712         if (!username) return -1;
 713
 714         aaa = (char *)malloc(strlen(username) + 6);
 715
 716         sprintf(aaa, "KICK %s", username);
 717         ret = CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
 718         free(aaa);
 719         return ret;
 720 }
 721
 722
 723 /* GETR */
 724 int CtdlIPCGetRoomAttributes(CtdlIPC *ipc, struct quickroom **qret, char *cret)
 725 {
 726         register int ret;
 727
 728         if (!cret) return -2;
 729         if (!qret) return -2;
 730         if (!*qret) *qret = (struct quickroom *)calloc(1, sizeof (struct quickroom));
 731         if (!*qret) return -1;
 732
 733         ret = CtdlIPCGenericCommand(ipc, "GETR", NULL, 0, NULL, NULL, cret);
 734         if (ret / 100 == 2) {
 735                 extract(qret[0]->QRname, cret, 0);
 736                 extract(qret[0]->QRpasswd, cret, 1);
 737                 extract(qret[0]->QRdirname, cret, 2);
 738                 qret[0]->QRflags = extract_int(cret, 3);
 739                 qret[0]->QRfloor = extract_int(cret, 4);
 740                 qret[0]->QRorder = extract_int(cret, 5);
 741                 qret[0]->QRdefaultview = extract_int(cret, 6);
 742                 qret[0]->QRflags2 = extract_int(cret, 7);
 743         }
 744         return ret;
 745 }
 746
 747
 748 /* SETR */
 749 /* set forget to kick all users out of room */
 750 int CtdlIPCSetRoomAttributes(CtdlIPC *ipc, int forget, struct quickroom *qret, char *cret)
 751 {
 752         register int ret;
 753         char *aaa;
 754
 755         if (!cret) return -2;
 756         if (!qret) return -2;
 757
 758         aaa = (char *)malloc(strlen(qret->QRname) + strlen(qret->QRpasswd) +
 759                         strlen(qret->QRdirname) + 52);
 760         if (!aaa) return -1;
 761
 762         sprintf(aaa, "SETR %s|%s|%s|%d|%d|%d|%d",
 763                         qret->QRname, qret->QRpasswd, qret->QRdirname,
 764                         qret->QRflags, forget, qret->QRfloor, qret->QRorder);
 765         ret = CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
 766         free(aaa);
 767         return ret;
 768 }
 769
 770
 771 /* GETA */
 772 int CtdlIPCGetRoomAide(CtdlIPC *ipc, char *cret)
 773 {
 774         if (!cret) return -1;
 775
 776         return CtdlIPCGenericCommand(ipc, "GETA", NULL, 0, NULL, NULL, cret);
 777 }
 778
 779
 780 /* SETA */
 781 int CtdlIPCSetRoomAide(CtdlIPC *ipc, const char *username, char *cret)
 782 {
 783         register int ret;
 784         char *aaa;
 785
 786         if (!cret) return -2;
 787         if (!username) return -2;
 788
 789         aaa = (char *)malloc(strlen(username) + 6);
 790         if (!aaa) return -1;
 791
 792         sprintf(aaa, "SETA %s", username);
 793         ret = CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
 794         free(aaa);
 795         return ret;
 796 }
 797
 798
 799 /* ENT0 */
 800 int CtdlIPCPostMessage(CtdlIPC *ipc, int flag, const struct ctdlipcmessage *mr, char *cret)
 801 {
 802         register int ret;
 803         char *aaa;
 804
 805         if (!cret) return -2;
 806         if (!mr) return -2;
 807
 808         aaa = (char *)malloc(strlen(mr->recipient) + strlen(mr->author) + 40);
 809         if (!aaa) return -1;
 810
 811         sprintf(aaa, "ENT0 %d|%s|%d|%d|%s", flag, mr->recipient, mr->anonymous,
 812                         mr->type, mr->author);
 813         ret = CtdlIPCGenericCommand(ipc, aaa, mr->text, strlen(mr->text), NULL,
 814                         NULL, cret);
 815         free(aaa);
 816         return ret;
 817 }
 818
 819
 820 /* RINF */
 821 int CtdlIPCRoomInfo(CtdlIPC *ipc, char **iret, char *cret)
 822 {
 823         size_t bytes;
 824
 825         if (!cret) return -2;
 826         if (!iret) return -2;
 827         if (*iret) return -2;
 828
 829         return CtdlIPCGenericCommand(ipc, "RINF", NULL, 0, iret, &bytes, cret);
 830 }
 831
 832
 833 /* DELE */
 834 int CtdlIPCDeleteMessage(CtdlIPC *ipc, long msgnum, char *cret)
 835 {
 836         char aaa[16];
 837
 838         if (!cret) return -2;
 839         if (!msgnum) return -2;
 840
 841         sprintf(aaa, "DELE %ld", msgnum);
 842         return CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
 843 }
 844
 845
 846 /* MOVE */
 847 int CtdlIPCMoveMessage(CtdlIPC *ipc, int copy, long msgnum, const char *destroom, char *cret)
 848 {
 849         register int ret;
 850         char *aaa;
 851
 852         if (!cret) return -2;
 853         if (!destroom) return -2;
 854         if (!msgnum) return -2;
 855
 856         aaa = (char *)malloc(strlen(destroom) + 28);
 857         if (!aaa) return -1;
 858
 859         sprintf(aaa, "MOVE %ld|%s|%d", msgnum, destroom, copy);
 860         ret = CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
 861         free(aaa);
 862         return ret;
 863 }
 864
 865
 866 /* KILL */
 867 int CtdlIPCDeleteRoom(CtdlIPC *ipc, int for_real, char *cret)
 868 {
 869         char aaa[16];
 870
 871         if (!cret) return -2;
 872
 873         sprintf(aaa, "KILL %d", for_real);
 874         return CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
 875 }
 876
 877
 878 /* CRE8 */
 879 int CtdlIPCCreateRoom(CtdlIPC *ipc, int for_real, const char *roomname, int type,
 880                 const char *password, int floor, char *cret)
 881 {
 882         register int ret;
 883         char *aaa;
 884
 885         if (!cret) return -2;
 886         if (!roomname) return -2;
 887
 888         if (password) {
 889                 aaa = (char *)malloc(strlen(roomname) + strlen(password) + 40);
 890                 if (!aaa) return -1;
 891                 sprintf(aaa, "CRE8 %d|%s|%d|%s|%d", for_real, roomname, type,
 892                                 password, floor);
 893         } else {
 894                 aaa = (char *)malloc(strlen(roomname) + 40);
 895                 if (!aaa) return -1;
 896                 sprintf(aaa, "CRE8 %d|%s|%d||%d", for_real, roomname, type,
 897                                 floor);
 898         }
 899         ret = CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
 900         free(aaa);
 901         return ret;
 902 }
 903
 904
 905 /* FORG */
 906 int CtdlIPCForgetRoom(CtdlIPC *ipc, char *cret)
 907 {
 908         if (!cret) return -2;
 909
 910         return CtdlIPCGenericCommand(ipc, "FORG", NULL, 0, NULL, NULL, cret);
 911 }
 912
 913
 914 /* MESG */
 915 int CtdlIPCSystemMessage(CtdlIPC *ipc, const char *message, char **mret, char *cret)
 916 {
 917         register int ret;
 918         char *aaa;
 919         size_t bytes;
 920
 921         if (!cret) return -2;
 922         if (!mret) return -2;
 923         if (*mret) return -2;
 924         if (!message) return -2;
 925
 926         aaa = (char *)malloc(strlen(message) + 6);
 927         if (!aaa) return -1;
 928
 929         sprintf(aaa, "MESG %s", message);
 930         ret = CtdlIPCGenericCommand(ipc, aaa, NULL, 0, mret, &bytes, cret);
 931         free(aaa);
 932         return ret;
 933 }
 934
 935
 936 /* GNUR */
 937 int CtdlIPCNextUnvalidatedUser(CtdlIPC *ipc, char *cret)
 938 {
 939         if (!cret) return -2;
 940
 941         return CtdlIPCGenericCommand(ipc, "GNUR", NULL, 0, NULL, NULL, cret);
 942 }
 943
 944
 945 /* GREG */
 946 int CtdlIPCGetUserRegistration(CtdlIPC *ipc, const char *username, char **rret, char *cret)
 947 {
 948         register int ret;
 949         char *aaa;
 950         size_t bytes;
 951
 952         if (!cret) return -2;
 953         if (!rret) return -2;
 954         if (*rret) return -2;
 955
 956         if (username)
 957                 aaa = (char *)malloc(strlen(username) + 6);
 958         else
 959                 aaa = (char *)malloc(12);
 960         if (!aaa) return -1;
 961
 962         if (username)
 963                 sprintf(aaa, "GREG %s", username);
 964         else
 965                 sprintf(aaa, "GREG _SELF_");
 966         ret = CtdlIPCGenericCommand(ipc, aaa, NULL, 0, rret, &bytes, cret);
 967         free(aaa);
 968         return ret;
 969 }
 970
 971
 972 /* VALI */
 973 int CtdlIPCValidateUser(CtdlIPC *ipc, const char *username, int axlevel, char *cret)
 974 {
 975         register int ret;
 976         char *aaa;
 977
 978         if (!cret) return -2;
 979         if (!username) return -2;
 980         if (axlevel < 0 || axlevel > 7) return -2;
 981
 982         aaa = (char *)malloc(strlen(username) + 17);
 983         if (!aaa) return -1;
 984
 985         sprintf(aaa, "VALI %s|%d", username, axlevel);
 986         ret = CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
 987         free(aaa);
 988         return ret;
 989 }
 990
 991
 992 /* EINF */
 993 int CtdlIPCSetRoomInfo(CtdlIPC *ipc, int for_real, const char *info, char *cret)
 994 {
 995         char aaa[16];
 996
 997         if (!cret) return -1;
 998         if (!info) return -1;
 999
1000         sprintf(aaa, "EINF %d", for_real);
1001         return CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
1002 }
1003
1004
1005 /* LIST */
1006 int CtdlIPCUserListing(CtdlIPC *ipc, char **listing, char *cret)
1007 {
1008         size_t bytes;
1009
1010         if (!cret) return -1;
1011         if (!listing) return -1;
1012         if (*listing) return -1;
1013
1014         return CtdlIPCGenericCommand(ipc, "LIST", NULL, 0, listing, &bytes, cret);
1015 }
1016
1017
1018 /* REGI */
1019 int CtdlIPCSetRegistration(CtdlIPC *ipc, const char *info, char *cret)
1020 {
1021         if (!cret) return -1;
1022         if (!info) return -1;
1023
1024         return CtdlIPCGenericCommand(ipc, "REGI", info, strlen(info),
1025                         NULL, NULL, cret);
1026 }
1027
1028
1029 /* CHEK */
1030 int CtdlIPCMiscCheck(CtdlIPC *ipc, struct ctdlipcmisc *chek, char *cret)
1031 {
1032         register int ret;
1033
1034         if (!cret) return -1;
1035         if (!chek) return -1;
1036
1037         ret = CtdlIPCGenericCommand(ipc, "CHEK", NULL, 0, NULL, NULL, cret);
1038         if (ret / 100 == 2) {
1039                 chek->newmail = extract_long(cret, 0);
1040                 chek->needregis = extract_int(cret, 1);
1041                 chek->needvalid = extract_int(cret, 2);
1042         }
1043         return ret;
1044 }
1045
1046
1047 /* DELF */
1048 int CtdlIPCDeleteFile(CtdlIPC *ipc, const char *filename, char *cret)
1049 {
1050         register int ret;
1051         char *aaa;
1052
1053         if (!cret) return -2;
1054         if (!filename) return -2;
1055
1056         aaa = (char *)malloc(strlen(filename) + 6);
1057         if (!aaa) return -1;
1058
1059         sprintf(aaa, "DELF %s", filename);
1060         ret = CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
1061         free(aaa);
1062         return ret;
1063 }
1064
1065
1066 /* MOVF */
1067 int CtdlIPCMoveFile(CtdlIPC *ipc, const char *filename, const char *destroom, char *cret)
1068 {
1069         register int ret;
1070         char *aaa;
1071
1072         if (!cret) return -2;
1073         if (!filename) return -2;
1074         if (!destroom) return -2;
1075
1076         aaa = (char *)malloc(strlen(filename) + strlen(destroom) + 7);
1077         if (!aaa) return -1;
1078
1079         sprintf(aaa, "MOVF %s|%s", filename, destroom);
1080         ret = CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
1081         free(aaa);
1082         return ret;
1083 }
1084
1085
1086 /* NETF */
1087 int CtdlIPCNetSendFile(CtdlIPC *ipc, const char *filename, const char *destnode, char *cret)
1088 {
1089         register int ret;
1090         char *aaa;
1091
1092         if (!cret) return -2;
1093         if (!filename) return -2;
1094         if (!destnode) return -2;
1095
1096         aaa = (char *)malloc(strlen(filename) + strlen(destnode) + 7);
1097         if (!aaa) return -1;
1098
1099         sprintf(aaa, "NETF %s|%s", filename, destnode);
1100         ret = CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
1101         free(aaa);
1102         return ret;
1103 }
1104
1105
1106 /* RWHO */
1107 int CtdlIPCOnlineUsers(CtdlIPC *ipc, char **listing, time_t *stamp, char *cret)
1108 {
1109         register int ret;
1110         size_t bytes;
1111
1112         if (!cret) return -1;
1113         if (!listing) return -1;
1114         if (*listing) return -1;
1115
1116         *stamp = CtdlIPCServerTime(ipc, cret);
1117         if (!*stamp)
1118                 *stamp = time(NULL);
1119         ret = CtdlIPCGenericCommand(ipc, "RWHO", NULL, 0, listing, &bytes, cret);
1120         return ret;
1121 }
1122
1123
1124 /* OPEN */
1125 int CtdlIPCFileDownload(CtdlIPC *ipc, const char *filename, void **buf,
1126                 size_t resume,
1127                 void (*progress_gauge_callback)(unsigned long, unsigned long),
1128                 char *cret)
1129 {
1130         register int ret;
1131         size_t bytes;
1132         time_t last_mod;
1133         char mimetype[SIZ];
1134         char *aaa;
1135
1136         if (!cret) return -2;
1137         if (!filename) return -2;
1138         if (!buf) return -2;
1139         if (*buf) return -2;
1140         if (ipc->downloading) return -2;
1141
1142         aaa = (char *)malloc(strlen(filename) + 6);
1143         if (!aaa) return -1;
1144
1145         sprintf(aaa, "OPEN %s", filename);
1146         ret = CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
1147         free(aaa);
1148         if (ret / 100 == 2) {
1149                 ipc->downloading = 1;
1150                 bytes = extract_long(cret, 0);
1151                 last_mod = extract_int(cret, 1);
1152                 extract(mimetype, cret, 2);
1153                 ret = CtdlIPCReadDownload(ipc, buf, bytes, resume, progress_gauge_callback, cret);
1154 /*              ret = CtdlIPCHighSpeedReadDownload(ipc, buf, bytes, resume, progress_gauge_callback, cret); */
1155                 ret = CtdlIPCEndDownload(ipc, cret);
1156                 if (ret / 100 == 2)
1157                         sprintf(cret, "%d|%ld|%s|%s", (int)bytes, last_mod,
1158                                         filename, mimetype);
1159         }
1160         return ret;
1161 }
1162
1163
1164 /* OPNA */
1165 int CtdlIPCAttachmentDownload(CtdlIPC *ipc, long msgnum, const char *part,
1166                 void **buf,
1167                 void (*progress_gauge_callback)(unsigned long, unsigned long),
1168                 char *cret)
1169 {
1170         register int ret;
1171         size_t bytes;
1172         time_t last_mod;
1173         char filename[SIZ];
1174         char mimetype[SIZ];
1175         char *aaa;
1176
1177         if (!cret) return -2;
1178         if (!buf) return -2;
1179         if (*buf) return -2;
1180         if (!part) return -2;
1181         if (!msgnum) return -2;
1182         if (ipc->downloading) return -2;
1183
1184         aaa = (char *)malloc(strlen(part) + 17);
1185         if (!aaa) return -1;
1186
1187         sprintf(aaa, "OPNA %ld|%s", msgnum, part);
1188         ret = CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
1189         free(aaa);
1190         if (ret / 100 == 2) {
1191                 ipc->downloading = 1;
1192                 bytes = extract_long(cret, 0);
1193                 last_mod = extract_int(cret, 1);
1194                 extract(mimetype, cret, 2);
1195                 ret = CtdlIPCHighSpeedReadDownload(ipc, buf, bytes, 0, progress_gauge_callback, cret);
1196                 ret = CtdlIPCEndDownload(ipc, cret);
1197                 if (ret / 100 == 2)
1198                         sprintf(cret, "%d|%ld|%s|%s", (int)bytes, last_mod,
1199                                         filename, mimetype);
1200         }
1201         return ret;
1202 }
1203
1204
1205 /* OIMG */
1206 int CtdlIPCImageDownload(CtdlIPC *ipc, const char *filename, void **buf,
1207                 void (*progress_gauge_callback)(unsigned long, unsigned long),
1208                 char *cret)
1209 {
1210         register int ret;
1211         size_t bytes;
1212         time_t last_mod;
1213         char mimetype[SIZ];
1214         char *aaa;
1215
1216         if (!cret) return -1;
1217         if (!buf) return -1;
1218         if (*buf) return -1;
1219         if (!filename) return -1;
1220         if (ipc->downloading) return -1;
1221
1222         aaa = (char *)malloc(strlen(filename) + 6);
1223         if (!aaa) return -1;
1224
1225         sprintf(aaa, "OIMG %s", filename);
1226         ret = CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
1227         free(aaa);
1228         if (ret / 100 == 2) {
1229                 ipc->downloading = 1;
1230                 bytes = extract_long(cret, 0);
1231                 last_mod = extract_int(cret, 1);
1232                 extract(mimetype, cret, 2);
1233                 ret = CtdlIPCReadDownload(ipc, buf, bytes, 0, progress_gauge_callback, cret);
1234                 ret = CtdlIPCEndDownload(ipc, cret);
1235                 if (ret / 100 == 2)
1236                         sprintf(cret, "%d|%ld|%s|%s", (int)bytes, last_mod,
1237                                         filename, mimetype);
1238         }
1239         return ret;
1240 }
1241
1242
1243 /* UOPN */
1244 int CtdlIPCFileUpload(CtdlIPC *ipc, const char *save_as, const char *comment,
1245                 const char *path,
1246                 void (*progress_gauge_callback)(unsigned long, unsigned long),
1247                 char *cret)
1248 {
1249         register int ret;
1250         char *aaa;
1251
1252         if (!cret) return -1;
1253         if (!save_as) return -1;
1254         if (!comment) return -1;
1255         if (!path) return -1;
1256         if (!*path) return -1;
1257         if (ipc->uploading) return -1;
1258
1259         aaa = (char *)malloc(strlen(save_as) + strlen(comment) + 7);
1260         if (!aaa) return -1;
1261
1262         sprintf(aaa, "UOPN %s|%s", save_as, comment);
1263         ret = CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
1264         free(aaa);
1265         if (ret / 100 == 2) {
1266                 ipc->uploading = 1;
1267                 ret = CtdlIPCWriteUpload(ipc, path, progress_gauge_callback, cret);
1268                 ret = CtdlIPCEndUpload(ipc, (ret == -2 ? 1 : 0), cret);
1269                 ipc->uploading = 0;
1270         }
1271         return ret;
1272 }
1273
1274
1275 /* UIMG */
1276 int CtdlIPCImageUpload(CtdlIPC *ipc, int for_real, const char *path,
1277                 const char *save_as,
1278                 void (*progress_gauge_callback)(unsigned long, unsigned long),
1279                 char *cret)
1280 {
1281         register int ret;
1282         char *aaa;
1283
1284         if (!cret) return -1;
1285         if (!save_as) return -1;
1286         if (!path && for_real) return -1;
1287         if (!*path && for_real) return -1;
1288         if (ipc->uploading) return -1;
1289
1290         aaa = (char *)malloc(strlen(save_as) + 17);
1291         if (!aaa) return -1;
1292
1293         sprintf(aaa, "UIMG %d|%s", for_real, save_as);
1294         ret = CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
1295         free(aaa);
1296         if (ret / 100 == 2 && for_real) {
1297                 ipc->uploading = 1;
1298                 ret = CtdlIPCWriteUpload(ipc, path, progress_gauge_callback, cret);
1299                 ret = CtdlIPCEndUpload(ipc, (ret == -2 ? 1 : 0), cret);
1300                 ipc->uploading = 0;
1301         }
1302         return ret;
1303 }
1304
1305
1306 /* QUSR */
1307 int CtdlIPCQueryUsername(CtdlIPC *ipc, const char *username, char *cret)
1308 {
1309         register int ret;
1310         char *aaa;
1311
1312         if (!cret) return -2;
1313         if (!username) return -2;
1314
1315         aaa = (char *)malloc(strlen(username) + 6);
1316         if (!aaa) return -1;
1317
1318         sprintf(aaa, "QUSR %s", username);
1319         ret = CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
1320         free(aaa);
1321         return ret;
1322 }
1323
1324
1325 /* LFLR */
1326 int CtdlIPCFloorListing(CtdlIPC *ipc, char **listing, char *cret)
1327 {
1328         size_t bytes;
1329
1330         if (!cret) return -2;
1331         if (!listing) return -2;
1332         if (*listing) return -2;
1333
1334         return CtdlIPCGenericCommand(ipc, "LFLR", NULL, 0, listing, &bytes, cret);
1335 }
1336
1337
1338 /* CFLR */
1339 int CtdlIPCCreateFloor(CtdlIPC *ipc, int for_real, const char *name, char *cret)
1340 {
1341         register int ret;
1342         char *aaa;
1343
1344         if (!cret) return -2;
1345         if (!name) return -2;
1346
1347         aaa = (char *)malloc(strlen(name) + 17);
1348         if (!aaa) return -1;
1349
1350         sprintf(aaa, "CFLR %s|%d", name, for_real);
1351         ret = CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
1352         free(aaa);
1353         return ret;
1354 }
1355
1356
1357 /* KFLR */
1358 int CtdlIPCDeleteFloor(CtdlIPC *ipc, int for_real, int floornum, char *cret)
1359 {
1360         char aaa[27];
1361
1362         if (!cret) return -1;
1363         if (floornum < 0) return -1;
1364
1365         sprintf(aaa, "KFLR %d|%d", floornum, for_real);
1366         return CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
1367 }
1368
1369
1370 /* EFLR */
1371 int CtdlIPCEditFloor(CtdlIPC *ipc, int floornum, const char *floorname, char *cret)
1372 {
1373         register int ret;
1374         char *aaa;
1375
1376         if (!cret) return -2;
1377         if (!floorname) return -2;
1378         if (floornum < 0) return -2;
1379
1380         aaa = (char *)malloc(strlen(floorname) + 17);
1381         if (!aaa) return -1;
1382
1383         sprintf(aaa, "EFLR %d|%s", floornum, floorname);
1384         ret = CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
1385         free(aaa);
1386         return ret;
1387 }
1388
1389
1390 /* IDEN */
1391 int CtdlIPCIdentifySoftware(CtdlIPC *ipc, int developerid, int clientid, int revision,
1392                 const char *software_name, const char *hostname, char *cret)
1393 {
1394         register int ret;
1395         char *aaa;
1396
1397         if (developerid < 0) return -2;
1398         if (clientid < 0) return -2;
1399         if (revision < 0) return -2;
1400         if (!software_name) return -2;
1401         if (!hostname) return -2;
1402
1403         aaa = (char *)malloc(strlen(software_name) + strlen(hostname) + 29);
1404         if (!aaa) return -1;
1405
1406         sprintf(aaa, "IDEN %d|%d|%d|%s|%s", developerid, clientid,
1407                         revision, software_name, hostname);
1408         ret = CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
1409         free(aaa);
1410         return ret;
1411 }
1412
1413
1414 /* SEXP */
1415 int CtdlIPCSendInstantMessage(CtdlIPC *ipc, const char *username, const char *text,
1416                 char *cret)
1417 {
1418         register int ret;
1419         char *aaa;
1420
1421         if (!cret) return -2;
1422         if (!username) return -2;
1423
1424         aaa = (char *)malloc(strlen(username) + 8);
1425         if (!aaa) return -1;
1426
1427         if (text) {
1428                 sprintf(aaa, "SEXP %s|-", username);
1429                 ret = CtdlIPCGenericCommand(ipc, aaa, text, strlen(text),
1430                                 NULL, NULL, cret);
1431         } else {
1432                 sprintf(aaa, "SEXP %s||", username);
1433                 ret = CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
1434         }
1435         free(aaa);
1436         return ret;
1437 }
1438
1439
1440 /* GEXP */
1441 int CtdlIPCGetInstantMessage(CtdlIPC *ipc, char **listing, char *cret)
1442 {
1443         size_t bytes;
1444
1445         if (!cret) return -2;
1446         if (!listing) return -2;
1447         if (*listing) return -2;
1448
1449         return CtdlIPCGenericCommand(ipc, "GEXP", NULL, 0, listing, &bytes, cret);
1450 }
1451
1452
1453 /* DEXP */
1454 /* mode is 0 = enable, 1 = disable, 2 = status */
1455 int CtdlIPCEnableInstantMessageReceipt(CtdlIPC *ipc, int mode, char *cret)
1456 {
1457         char aaa[16];
1458
1459         if (!cret) return -2;
1460
1461         sprintf(aaa, "DEXP %d", mode);
1462         return CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
1463 }
1464
1465
1466 /* EBIO */
1467 int CtdlIPCSetBio(CtdlIPC *ipc, char *bio, char *cret)
1468 {
1469         if (!cret) return -2;
1470         if (!bio) return -2;
1471
1472         return CtdlIPCGenericCommand(ipc, "EBIO", bio, strlen(bio),
1473                         NULL, NULL, cret);
1474 }
1475
1476
1477 /* RBIO */
1478 int CtdlIPCGetBio(CtdlIPC *ipc, const char *username, char **listing, char *cret)
1479 {
1480         register int ret;
1481         size_t bytes;
1482         char *aaa;
1483
1484         if (!cret) return -2;
1485         if (!username) return -2;
1486         if (!listing) return -2;
1487         if (*listing) return -2;
1488
1489         aaa = (char *)malloc(strlen(username) + 6);
1490         if (!aaa) return -1;
1491
1492         sprintf(aaa, "RBIO %s", username);
1493         ret = CtdlIPCGenericCommand(ipc, aaa, NULL, 0, listing, &bytes, cret);
1494         free(aaa);
1495         return ret;
1496 }
1497
1498
1499 /* LBIO */
1500 int CtdlIPCListUsersWithBios(CtdlIPC *ipc, char **listing, char *cret)
1501 {
1502         size_t bytes;
1503
1504         if (!cret) return -2;
1505         if (!listing) return -2;
1506         if (*listing) return -2;
1507
1508         return CtdlIPCGenericCommand(ipc, "LBIO", NULL, 0, listing, &bytes, cret);
1509 }
1510
1511
1512 /* STEL */
1513 int CtdlIPCStealthMode(CtdlIPC *ipc, int mode, char *cret)
1514 {
1515         char aaa[16];
1516
1517         if (!cret) return -1;
1518
1519         sprintf(aaa, "STEL %d", mode ? 1 : 0);
1520         return CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
1521 }
1522
1523
1524 /* TERM */
1525 int CtdlIPCTerminateSession(CtdlIPC *ipc, int sid, char *cret)
1526 {
1527         char aaa[16];
1528
1529         if (!cret) return -1;
1530
1531         sprintf(aaa, "TERM %d", sid);
1532         return CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
1533 }
1534
1535
1536 /* DOWN */
1537 int CtdlIPCTerminateServerNow(CtdlIPC *ipc, char *cret)
1538 {
1539         if (!cret) return -1;
1540
1541         return CtdlIPCGenericCommand(ipc, "DOWN", NULL, 0, NULL, NULL, cret);
1542 }
1543
1544
1545 /* SCDN */
1546 int CtdlIPCTerminateServerScheduled(CtdlIPC *ipc, int mode, char *cret)
1547 {
1548         char aaa[16];
1549
1550         if (!cret) return -1;
1551
1552         sprintf(aaa, "SCDN %d", mode ? 1 : 0);
1553         return CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
1554 }
1555
1556
1557 /* EMSG */
1558 int CtdlIPCEnterSystemMessage(CtdlIPC *ipc, const char *filename, const char *text,
1559                 char *cret)
1560 {
1561         register int ret;
1562         char *aaa;
1563
1564         if (!cret) return -2;
1565         if (!text) return -2;
1566         if (!filename) return -2;
1567
1568         aaa = (char *)malloc(strlen(filename) + 6);
1569         if (!aaa) return -1;
1570
1571         sprintf(aaa, "EMSG %s", filename);
1572         ret = CtdlIPCGenericCommand(ipc, aaa, text, strlen(text), NULL, NULL, cret);
1573         free(aaa);
1574         return ret;
1575 }
1576
1577
1578 /* HCHG */
1579 int CtdlIPCChangeHostname(CtdlIPC *ipc, const char *hostname, char *cret)
1580 {
1581         register int ret;
1582         char *aaa;
1583
1584         if (!cret) return -2;
1585         if (!hostname) return -2;
1586
1587         aaa = (char *)malloc(strlen(hostname) + 6);
1588         if (!aaa) return -1;
1589
1590         sprintf(aaa, "HCHG %s", hostname);
1591         ret = CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
1592         free(aaa);
1593         return ret;
1594 }
1595
1596
1597 /* RCHG */
1598 int CtdlIPCChangeRoomname(CtdlIPC *ipc, const char *roomname, char *cret)
1599 {
1600         register int ret;
1601         char *aaa;
1602
1603         if (!cret) return -2;
1604         if (!roomname) return -2;
1605
1606         aaa = (char *)malloc(strlen(roomname) + 6);
1607         if (!aaa) return -1;
1608
1609         sprintf(aaa, "RCHG %s", roomname);
1610         ret = CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
1611         free(aaa);
1612         return ret;
1613 }
1614
1615
1616 /* UCHG */
1617 int CtdlIPCChangeUsername(CtdlIPC *ipc, const char *username, char *cret)
1618 {
1619         register int ret;
1620         char *aaa;
1621
1622         if (!cret) return -2;
1623         if (!username) return -2;
1624
1625         aaa = (char *)malloc(strlen(username) + 6);
1626         if (!aaa) return -1;
1627
1628         sprintf(aaa, "UCHG %s", username);
1629         ret = CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
1630         free(aaa);
1631         return ret;
1632 }
1633
1634
1635 /* TIME */
1636 /* This function returns the actual server time reported, or 0 if error */
1637 time_t CtdlIPCServerTime(CtdlIPC *ipc, char *cret)
1638 {
1639         register time_t tret;
1640         register int ret;
1641
1642         ret = CtdlIPCGenericCommand(ipc, "TIME", NULL, 0, NULL, NULL, cret);
1643         if (ret / 100 == 2) {
1644                 tret = extract_long(cret, 0);
1645         } else {
1646                 tret = 0L;
1647         }
1648         return tret;
1649 }
1650
1651
1652 /* AGUP */
1653 int CtdlIPCAideGetUserParameters(CtdlIPC *ipc, const char *who,
1654                                  struct usersupp **uret, char *cret)
1655 {
1656         register int ret;
1657         char aaa[SIZ];
1658
1659         if (!cret) return -2;
1660         if (!uret) return -2;
1661         if (!*uret) *uret = (struct usersupp *)calloc(1, sizeof(struct usersupp));
1662         if (!*uret) return -1;
1663
1664         sprintf(aaa, "AGUP %s", who);
1665         ret = CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
1666
1667         if (ret / 100 == 2) {
1668                 extract(uret[0]->fullname, cret, 0);
1669                 extract(uret[0]->password, cret, 1);
1670                 uret[0]->flags = extract_int(cret, 2);
1671                 uret[0]->timescalled = extract_long(cret, 3);
1672                 uret[0]->posted = extract_long(cret, 4);
1673                 uret[0]->axlevel = extract_int(cret, 5);
1674                 uret[0]->usernum = extract_long(cret, 6);
1675                 uret[0]->lastcall = extract_long(cret, 7);
1676                 uret[0]->USuserpurge = extract_int(cret, 8);
1677         }
1678         return ret;
1679 }
1680
1681
1682 /* ASUP */
1683 int CtdlIPCAideSetUserParameters(CtdlIPC *ipc, const struct usersupp *uret, char *cret)
1684 {
1685         register int ret;
1686         char *aaa;
1687
1688         if (!cret) return -2;
1689         if (!uret) return -2;
1690
1691         aaa = (char *)malloc(strlen(uret->fullname) + strlen(uret->password) + 84);
1692         if (!aaa) return -1;
1693
1694         sprintf(aaa, "ASUP %s|%s|%d|%ld|%ld|%d|%ld|%ld|%d",
1695                         uret->fullname, uret->password, uret->flags,
1696                         uret->timescalled, uret->posted, uret->axlevel,
1697                         uret->usernum, uret->lastcall, uret->USuserpurge);
1698         ret = CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
1699         free(aaa);
1700         return ret;
1701 }
1702
1703
1704 /* GPEX */
1705 /* which is 0 = room, 1 = floor, 2 = site */
1706 /* caller must free the struct ExpirePolicy */
1707 int CtdlIPCGetMessageExpirationPolicy(CtdlIPC *ipc, int which,
1708                 struct ExpirePolicy **policy, char *cret)
1709 {
1710         static char *proto[] = {"room", "floor", "site"};
1711         char aaa[11];
1712         register int ret;
1713
1714         if (!cret) return -2;
1715         if (!policy) return -2;
1716         if (!*policy) *policy = (struct ExpirePolicy *)calloc(1, sizeof(struct ExpirePolicy));
1717         if (!*policy) return -1;
1718         if (which < 0 || which > 2) return -2;
1719
1720         sprintf(aaa, "GPEX %s", proto[which]);
1721         ret = CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
1722         if (ret / 100 == 2) {
1723                 policy[0]->expire_mode = extract_int(cret, 0);
1724                 policy[0]->expire_value = extract_int(cret, 1);
1725         }
1726         return ret;
1727
1728 }
1729
1730
1731 /* SPEX */
1732 /* which is 0 = room, 1 = floor, 2 = site */
1733 /* policy is 0 = inherit, 1 = no purge, 2 = by count, 3 = by age (days) */
1734 int CtdlIPCSetMessageExpirationPolicy(CtdlIPC *ipc, int which,
1735                 struct ExpirePolicy *policy, char *cret)
1736 {
1737         char aaa[38];
1738
1739         if (!cret) return -2;
1740         if (which < 0 || which > 2) return -2;
1741         if (!policy) return -2;
1742         if (policy->expire_mode < 0 || policy->expire_mode > 3) return -2;
1743         if (policy->expire_mode >= 2 && policy->expire_value < 1) return -2;
1744
1745         sprintf(aaa, "SPEX %d|%d|%d", which,
1746                         policy->expire_mode, policy->expire_value);
1747         return CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
1748 }
1749
1750
1751 /* CONF GET */
1752 int CtdlGetSystemConfig(CtdlIPC *ipc, char **listing, char *cret)
1753 {
1754         size_t bytes;
1755
1756         if (!cret) return -2;
1757         if (!listing) return -2;
1758         if (*listing) return -2;
1759
1760         return CtdlIPCGenericCommand(ipc, "CONF GET", NULL, 0,
1761                         listing, &bytes, cret);
1762 }
1763
1764
1765 /* CONF SET */
1766 int CtdlSetSystemConfig(CtdlIPC *ipc, const char *listing, char *cret)
1767 {
1768         if (!cret) return -2;
1769         if (!listing) return -2;
1770
1771         return CtdlIPCGenericCommand(ipc, "CONF SET", listing, strlen(listing),
1772                         NULL, NULL, cret);
1773 }
1774
1775
1776 /* CONF GETSYS */
1777 int CtdlGetSystemConfigByType(CtdlIPC *ipc, const char *mimetype,
1778                 char **listing, char *cret)
1779 {
1780         char *aaa;
1781         size_t bytes;
1782
1783         if (!cret) return -2;
1784         if (!mimetype) return -2;
1785         if (!listing) return -2;
1786         if (*listing) return -2;
1787
1788         aaa = malloc(strlen(mimetype) + 13);
1789         if (!aaa) return -1;
1790         sprintf(aaa, "CONF GETSYS|%s", mimetype);
1791         return CtdlIPCGenericCommand(ipc, aaa, NULL, 0,
1792                         listing, &bytes, cret);
1793 }
1794
1795
1796 /* CONF PUTSYS */
1797 int CtdlSetSystemConfigByType(CtdlIPC *ipc, const char *mimetype,
1798                const char *listing, char *cret)
1799 {
1800         char *aaa;
1801
1802         if (!cret) return -2;
1803         if (!mimetype) return -2;
1804         if (!listing) return -2;
1805
1806         aaa = malloc(strlen(mimetype) + 13);
1807         if (!aaa) return -1;
1808         sprintf(aaa, "CONF PUTSYS|%s", mimetype);
1809         return CtdlIPCGenericCommand(ipc, aaa, listing, strlen(listing),
1810                         NULL, NULL, cret);
1811 }
1812
1813 /* MMOD */
1814 int CtdlIPCModerateMessage(CtdlIPC *ipc, long msgnum, int level, char *cret)
1815 {
1816         char aaa[27];
1817
1818         if (!cret) return -2;
1819         if (!msgnum) return -2;
1820
1821         sprintf(aaa, "MMOD %ld|%d", msgnum, level);
1822         return CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
1823 }
1824
1825
1826 /* REQT */
1827 int CtdlIPCRequestClientLogout(CtdlIPC *ipc, int session, char *cret)
1828 {
1829         char aaa[16];
1830
1831         if (!cret) return -2;
1832         if (session < 0) return -2;
1833
1834         sprintf(aaa, "REQT %d", session);
1835         return CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
1836 }
1837
1838
1839 /* SEEN */
1840 int CtdlIPCSetMessageSeen(CtdlIPC *ipc, long msgnum, int seen, char *cret)
1841 {
1842         char aaa[27];
1843
1844         if (!cret) return -2;
1845         if (msgnum < 0) return -2;
1846
1847         sprintf(aaa, "SEEN %ld|%d", msgnum, seen ? 1 : 0);
1848         return CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
1849 }
1850
1851
1852 /* STLS */
1853 int CtdlIPCStartEncryption(CtdlIPC *ipc, char *cret)
1854 {
1855         int a;
1856         int r;
1857         char buf[SIZ];
1858
1859 #ifdef HAVE_OPENSSL
1860         SSL *temp_ssl;
1861
1862         /* New SSL object */
1863         temp_ssl = SSL_new(ssl_ctx);
1864         if (!temp_ssl) {
1865                 error_printf("SSL_new failed: %s\n",
1866                                 ERR_reason_error_string(ERR_get_error()));
1867                 return -2;
1868         }
1869         /* Pointless flag waving */
1870 #if SSLEAY_VERSION_NUMBER >= 0x0922
1871         SSL_set_session_id_context(temp_ssl, "Citadel/UX SID", 14);
1872 #endif
1873
1874         if (!access("/var/run/egd-pool", F_OK))
1875                 RAND_egd("/var/run/egd-pool");
1876
1877         if (!RAND_status()) {
1878                 error_printf("PRNG not properly seeded\n");
1879                 return -2;
1880         }
1881
1882         /* Associate network connection with SSL object */
1883         if (SSL_set_fd(temp_ssl, ipc->sock) < 1) {
1884                 error_printf("SSL_set_fd failed: %s\n",
1885                                 ERR_reason_error_string(ERR_get_error()));
1886                 return -2;
1887         }
1888
1889         if (status_hook != NULL)
1890                 status_hook("Requesting encryption...\r");
1891
1892         /* Ready to start SSL/TLS */
1893         /* Old code
1894         CtdlIPC_putline(ipc, "STLS");
1895         CtdlIPC_getline(ipc, buf);
1896         if (buf[0] != '2') {
1897                 error_printf("Server can't start TLS: %s\n", buf);
1898                 return 0;
1899         }
1900         */
1901         r = CtdlIPCGenericCommand(ipc,
1902                                   "STLS", NULL, 0, NULL, NULL, cret);
1903         if (r / 100 != 2) {
1904                 error_printf("Server can't start TLS: %s\n", buf);
1905                 endtls(temp_ssl);
1906                 return r;
1907         }
1908
1909         /* Do SSL/TLS handshake */
1910         if ((a = SSL_connect(temp_ssl)) < 1) {
1911                 error_printf("SSL_connect failed: %s\n",
1912                                 ERR_reason_error_string(ERR_get_error()));
1913                 endtls(temp_ssl);
1914                 return -2;
1915         }
1916         ipc->ssl = temp_ssl;
1917
1918         BIO_set_close(ipc->ssl->rbio, BIO_NOCLOSE);
1919         {
1920                 int bits, alg_bits;
1921
1922                 bits = SSL_CIPHER_get_bits(SSL_get_current_cipher(ipc->ssl), &alg_bits);
1923                 error_printf("Encrypting with %s cipher %s (%d of %d bits)\n",
1924                                 SSL_CIPHER_get_version(SSL_get_current_cipher(ipc->ssl)),
1925                                 SSL_CIPHER_get_name(SSL_get_current_cipher(ipc->ssl)),
1926                                 bits, alg_bits);
1927         }
1928         return r;
1929 #else
1930         return 0;
1931 #endif /* HAVE_OPENSSL */
1932 }
1933
1934
1935 #ifdef HAVE_OPENSSL
1936 static void endtls(SSL *ssl)
1937 {
1938         if (ssl) {
1939                 SSL_shutdown(ssl);
1940                 SSL_free(ssl);
1941         }
1942 }
1943 #endif
1944
1945
1946 /* QDIR */
1947 int CtdlIPCDirectoryLookup(CtdlIPC *ipc, const char *address, char *cret)
1948 {
1949         char *aaa;
1950
1951         if (!address) return -2;
1952         if (!cret) return -2;
1953
1954         aaa = (char *)malloc(strlen(address) + 6);
1955         if (!aaa) return -1;
1956
1957         sprintf(aaa, "QDIR %s", address);
1958         return CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
1959 }
1960
1961
1962 /* IPGM */
1963 int CtdlIPCInternalProgram(CtdlIPC *ipc, int secret, char *cret)
1964 {
1965         char aaa[30];
1966
1967         if (!cret) return -2;
1968         sprintf(aaa, "IPGM %d", secret);
1969         return CtdlIPCGenericCommand(ipc, aaa, NULL, 0, NULL, NULL, cret);
1970 }
1971
1972
1973 /*
1974  * Not implemented:
1975  *
1976  * CHAT
1977  * ETLS
1978  * EXPI
1979  * GTLS
1980  * IGAB
1981  * MSG3
1982  * MSG4
1983  * NDOP
1984  * NETP
1985  * NUOP
1986  * SMTP
1987  */
1988
1989
1990 /* ************************************************************************** */
1991 /*             Stuff below this line is not for public consumption            */
1992 /* ************************************************************************** */
1993
1994
1995 inline void CtdlIPC_lock(CtdlIPC *ipc)
1996 {
1997         if (ipc->network_status_cb) ipc->network_status_cb(1);
1998 #ifdef THREADED_CLIENT
1999         pthread_mutex_lock(&(ipc->mutex));
2000 #endif
2001 }
2002
2003
2004 inline void CtdlIPC_unlock(CtdlIPC *ipc)
2005 {
2006 #ifdef THREADED_CLIENT
2007         pthread_mutex_unlock(&(ipc->mutex));
2008 #endif
2009         if (ipc->network_status_cb) ipc->network_status_cb(0);
2010 }
2011
2012
2013 /* Read a listing from the server up to 000.  Append to dest if it exists */
2014 char *CtdlIPCReadListing(CtdlIPC *ipc, char *dest)
2015 {
2016         size_t length = 0;
2017         size_t linelength;
2018         char *ret;
2019         char aaa[SIZ];
2020
2021         ret = dest;
2022         if (ret != NULL) {
2023                 length = strlen(ret);
2024         }
2025         else {
2026                 ret = strdup("");
2027                 length = 0;
2028         }
2029
2030         while (CtdlIPC_getline(ipc, aaa), strcmp(aaa, "000")) {
2031                 linelength = strlen(aaa);
2032                 ret = (char *)realloc(ret, (size_t)(length + linelength + 2));
2033                 if (ret) {
2034                         strcpy(&ret[length], aaa);
2035                         length += linelength;
2036                         strcpy(&ret[length++], "\n");
2037                 }
2038         }
2039
2040         return(ret);
2041 }
2042
2043
2044 /* Send a listing to the server; generate the ending 000. */
2045 int CtdlIPCSendListing(CtdlIPC *ipc, const char *listing)
2046 {
2047         char *text;
2048
2049         text = (char *)malloc(strlen(listing) + 6);
2050         if (text) {
2051                 strcpy(text, listing);
2052                 while (text[strlen(text) - 1] == '\n')
2053                         text[strlen(text) - 1] = '\0';
2054                 strcat(text, "\n000");
2055                 CtdlIPC_putline(ipc, text);
2056                 free(text);
2057                 text = NULL;
2058         } else {
2059                 /* Malloc failed but we are committed to send */
2060                 /* This may result in extra blanks at the bottom */
2061                 CtdlIPC_putline(ipc, text);
2062                 CtdlIPC_putline(ipc, "000");
2063         }
2064         return 0;
2065 }
2066
2067
2068 /* Partial read of file from server */
2069 size_t CtdlIPCPartialRead(CtdlIPC *ipc, void **buf, size_t offset, size_t bytes, char *cret)
2070 {
2071         register size_t len = 0;
2072         char aaa[SIZ];
2073
2074         if (!buf) return 0;
2075         if (!cret) return 0;
2076         if (bytes < 1) return 0;
2077         if (offset < 0) return 0;
2078
2079         CtdlIPC_lock(ipc);
2080         sprintf(aaa, "READ %d|%d", (int)offset, (int)bytes);
2081         CtdlIPC_putline(ipc, aaa);
2082         CtdlIPC_getline(ipc, aaa);
2083         if (aaa[0] != '6')
2084                 strcpy(cret, &aaa[4]);
2085         else {
2086                 len = extract_long(&aaa[4], 0);
2087                 *buf = (void *)realloc(*buf, (size_t)(offset + len));
2088                 if (*buf) {
2089                         /* I know what I'm doing */
2090                         serv_read(ipc, (*buf + offset), len);
2091                 } else {
2092                         /* We have to read regardless */
2093                         serv_read(ipc, aaa, len);
2094                         len = 0;
2095                 }
2096         }
2097         CtdlIPC_unlock(ipc);
2098         return len;
2099 }
2100
2101
2102 /* CLOS */
2103 int CtdlIPCEndDownload(CtdlIPC *ipc, char *cret)
2104 {
2105         register int ret;
2106
2107         if (!cret) return -2;
2108         if (!ipc->downloading) return -2;
2109
2110         ret = CtdlIPCGenericCommand(ipc, "CLOS", NULL, 0, NULL, NULL, cret);
2111         if (ret / 100 == 2)
2112                 ipc->downloading = 0;
2113         return ret;
2114 }
2115
2116
2117 /* MSGP */
2118 int CtdlIPCSpecifyPreferredFormats(CtdlIPC *ipc, char *cret, char *formats) {
2119         register int ret;
2120         char cmd[SIZ];
2121
2122         snprintf(cmd, sizeof cmd, "MSGP %s", formats);
2123         ret = CtdlIPCGenericCommand(ipc, cmd, NULL, 0, NULL, NULL, cret);
2124         return ret;
2125 }
2126
2127
2128
2129 /* READ */
2130 int CtdlIPCReadDownload(CtdlIPC *ipc, void **buf, size_t bytes, size_t resume,
2131                void (*progress_gauge_callback)(unsigned long, unsigned long),
2132                char *cret)
2133 {
2134         register size_t len;
2135
2136         if (!cret) return -1;
2137         if (!buf) return -1;
2138         if (*buf) return -1;
2139         if (!ipc->downloading) return -1;
2140
2141         len = resume;
2142         if (progress_gauge_callback)
2143                 progress_gauge_callback(len, bytes);
2144         while (len < bytes) {
2145                 register size_t block;
2146
2147                 block = CtdlIPCPartialRead(ipc, buf, len, 4096, cret);
2148                 if (block == 0) {
2149                         free(*buf);
2150                         return 0;
2151                 }
2152                 len += block;
2153                 if (progress_gauge_callback)
2154                         progress_gauge_callback(len, bytes);
2155         }
2156         return len;
2157 }
2158
2159
2160 /* READ - pipelined */
2161 int CtdlIPCHighSpeedReadDownload(CtdlIPC *ipc, void **buf, size_t bytes,
2162                size_t resume,
2163                void (*progress_gauge_callback)(unsigned long, unsigned long),
2164                char *cret)
2165 {
2166         register size_t len;
2167         register int calls;     /* How many calls in the pipeline */
2168         register int i;         /* iterator */
2169         char aaa[4096];
2170
2171         if (!cret) return -1;
2172         if (!buf) return -1;
2173         if (*buf) return -1;
2174         if (!ipc->downloading) return -1;
2175
2176         *buf = (void *)realloc(*buf, bytes - resume);
2177         if (!*buf) return -1;
2178
2179         len = 0;
2180         CtdlIPC_lock(ipc);
2181         if (progress_gauge_callback)
2182                 progress_gauge_callback(len, bytes);
2183
2184         /* How many calls will be in the pipeline? */
2185         calls = (bytes - resume) / 4096;
2186         if ((bytes - resume) % 4096) calls++;
2187
2188         /* Send all requests at once */
2189         for (i = 0; i < calls; i++) {
2190                 sprintf(aaa, "READ %d|4096", (int)(i * 4096 + resume) );
2191                 CtdlIPC_putline(ipc, aaa);
2192         }
2193
2194         /* Receive all responses at once */
2195         for (i = 0; i < calls; i++) {
2196                 CtdlIPC_getline(ipc, aaa);
2197                 if (aaa[0] != '6')
2198                         strcpy(cret, &aaa[4]);
2199                 else {
2200                         len = extract_long(&aaa[4], 0);
2201                         /* I know what I'm doing */
2202                         serv_read(ipc, ((*buf) + (i * 4096)), len);
2203                 }
2204                 if (progress_gauge_callback)
2205                         progress_gauge_callback(i * 4096 + len, bytes);
2206         }
2207         CtdlIPC_unlock(ipc);
2208         return len;
2209 }
2210
2211
2212 /* UCLS */
2213 int CtdlIPCEndUpload(CtdlIPC *ipc, int discard, char *cret)
2214 {
2215         register int ret;
2216         char cmd[8];
2217
2218         if (!cret) return -1;
2219         if (!ipc->uploading) return -1;
2220
2221         sprintf(cmd, "UCLS %d", discard ? 0 : 1);
2222         ret = CtdlIPCGenericCommand(ipc, cmd, NULL, 0, NULL, NULL, cret);
2223         ipc->uploading = 0;
2224         return ret;
2225 }
2226
2227
2228 /* WRIT */
2229 int CtdlIPCWriteUpload(CtdlIPC *ipc, const char *path,
2230                 void (*progress_gauge_callback)(unsigned long, unsigned long),
2231                 char *cret)
2232 {
2233         register int ret = -1;
2234         register size_t offset = 0;
2235         size_t bytes;
2236         char aaa[SIZ];
2237         char buf[4096];
2238         FILE *fd;
2239
2240         if (!cret) return -1;
2241         if (!path) return -1;
2242         if (!*path) return -1;
2243
2244         fd = fopen(path, "r");
2245         if (!fd) return -2;
2246
2247         fseek(fd, 0L, SEEK_END);
2248         bytes = ftell(fd);
2249         rewind(fd);
2250
2251         if (progress_gauge_callback)
2252                 progress_gauge_callback(0, bytes);
2253
2254         while (offset < bytes) {
2255                 register size_t to_write;
2256
2257                 /* Read some data in */
2258                 to_write = fread(buf, 1, 4096, fd);
2259                 if (!to_write) {
2260                         if (feof(fd) || ferror(fd)) break;
2261                 }
2262                 sprintf(aaa, "WRIT %d", (int)to_write);
2263                 CtdlIPC_putline(ipc, aaa);
2264                 CtdlIPC_getline(ipc, aaa);
2265                 strcpy(cret, &aaa[4]);
2266                 ret = atoi(aaa);
2267                 if (aaa[0] == '7') {
2268                         to_write = extract_long(&aaa[4], 0);
2269
2270                         serv_write(ipc, buf, to_write);
2271                         offset += to_write;
2272                         if (progress_gauge_callback)
2273                                 progress_gauge_callback(offset, bytes);
2274                         /* Detect short reads and back up if needed */
2275                         /* offset will never be negative anyway */
2276                         fseek(fd, (signed)offset, SEEK_SET);
2277                 } else {
2278                         break;
2279                 }
2280         }
2281         if (progress_gauge_callback)
2282                 progress_gauge_callback(1, 1);
2283         return (!ferror(fd) ? ret : -2);
2284 }
2285
2286
2287 /*
2288  * Generic command method.  This method should handle any server command
2289  * except for CHAT.  It takes the following arguments:
2290  *
2291  * ipc                  The server to speak with
2292  * command              Preformatted command to send to server
2293  * to_send              A text or binary file to send to server
2294  *                      (only sent if server requests it)
2295  * bytes_to_send        The number of bytes in to_send (required if
2296  *                      sending binary, optional if sending listing)
2297  * to_receive           Pointer to a NULL pointer, if the server
2298  *                      sends text or binary we will allocate memory
2299  *                      for the file and stuff it here
2300  * bytes_to_receive     If a file is received, we will store its
2301  *                      byte count here
2302  * proto_response       The protocol response.  Caller must provide
2303  *                      this buffer and ensure that it is at least
2304  *                      128 bytes in length.
2305  *
2306  * This function returns a number equal to the protocol response number,
2307  * -1 if an internal error occurred, -2 if caller provided bad values,
2308  * or 0 - the protocol response number if bad values were found during
2309  * the protocol exchange.
2310  * It stores the protocol response string (minus the number) in
2311  * protocol_response as described above.  Some commands send additional
2312  * data in this string.
2313  */
2314 int CtdlIPCGenericCommand(CtdlIPC *ipc,
2315                 const char *command, const char *to_send,
2316                 size_t bytes_to_send, char **to_receive,
2317                 size_t *bytes_to_receive, char *proto_response)
2318 {
2319         char buf[SIZ];
2320         register int ret;
2321         int watch_ssl = 0;
2322
2323         if (!command) return -2;
2324         if (!proto_response) return -2;
2325
2326 #ifdef HAVE_OPENSSL
2327         if (ipc->ssl) watch_ssl = 1;
2328 #endif
2329
2330         CtdlIPC_lock(ipc);
2331         CtdlIPC_putline(ipc, command);
2332         while (1) {
2333                 CtdlIPC_getline(ipc, proto_response);
2334                 if (proto_response[3] == '*')
2335                         express_msgs = 1;
2336                 ret = atoi(proto_response);
2337                 strcpy(proto_response, &proto_response[4]);
2338                 switch (ret / 100) {
2339                 default:                        /* Unknown, punt */
2340                 case 2:                         /* OK */
2341                 case 3:                         /* MORE_DATA */
2342                 case 5:                         /* ERROR */
2343                         /* Don't need to do anything */
2344                         break;
2345                 case 1:                         /* LISTING_FOLLOWS */
2346                         if (to_receive && !*to_receive && bytes_to_receive) {
2347                                 *to_receive = CtdlIPCReadListing(ipc, NULL);
2348                         } else { /* Drain */
2349                                 while (CtdlIPC_getline(ipc, buf), strcmp(buf, "000")) ;
2350                                 ret = -ret;
2351                         }
2352                         break;
2353                 case 4:                         /* SEND_LISTING */
2354                         if (to_send) {
2355                                 CtdlIPCSendListing(ipc, to_send);
2356                         } else {
2357                                 /* No listing given, fake it */
2358                                 CtdlIPC_putline(ipc, "000");
2359                                 ret = -ret;
2360                         }
2361                         break;
2362                 case 6:                         /* BINARY_FOLLOWS */
2363                         if (to_receive && !*to_receive && bytes_to_receive) {
2364                                 *bytes_to_receive =
2365                                         extract_long(proto_response, 0);
2366                                 *to_receive = (char *)
2367                                         malloc((size_t)*bytes_to_receive);
2368                                 if (!*to_receive) {
2369                                         ret = -1;
2370                                 } else {
2371                                         serv_read(ipc, *to_receive,
2372                                                         *bytes_to_receive);
2373                                 }
2374                         } else {
2375                                 /* Drain */
2376                                 size_t drain;
2377
2378                                 drain = extract_long(proto_response, 0);
2379                                 while (drain > SIZ) {
2380                                         serv_read(ipc, buf, SIZ);
2381                                         drain -= SIZ;
2382                                 }
2383                                 serv_read(ipc, buf, drain);
2384                                 ret = -ret;
2385                         }
2386                         break;
2387                 case 7:                         /* SEND_BINARY */
2388                         if (to_send && bytes_to_send) {
2389                                 serv_write(ipc, to_send, bytes_to_send);
2390                         } else if (bytes_to_send) {
2391                                 /* Fake it, send nulls */
2392                                 size_t fake;
2393
2394                                 fake = bytes_to_send;
2395                                 memset(buf, '\0', SIZ);
2396                                 while (fake > SIZ) {
2397                                         serv_write(ipc, buf, SIZ);
2398                                         fake -= SIZ;
2399                                 }
2400                                 serv_write(ipc, buf, fake);
2401                                 ret = -ret;
2402                         } /* else who knows?  DANGER WILL ROBINSON */
2403                         break;
2404                 case 8:                         /* START_CHAT_MODE */
2405                         if (!strncasecmp(command, "CHAT", 4)) {
2406                                 /* Don't call chatmode with generic! */
2407                                 CtdlIPC_putline(ipc, "/quit");
2408                                 ret = -ret;
2409                         } else {
2410                                 /* In this mode we send then receive listing */
2411                                 if (to_send) {
2412                                         CtdlIPCSendListing(ipc, to_send);
2413                                 } else {
2414                                         /* No listing given, fake it */
2415                                         CtdlIPC_putline(ipc, "000");
2416                                         ret = -ret;
2417                                 }
2418                                 if (to_receive && !*to_receive
2419                                                 && bytes_to_receive) {
2420                                         *to_receive = CtdlIPCReadListing(ipc, NULL);
2421                                 } else { /* Drain */
2422                                         while (CtdlIPC_getline(ipc, buf),
2423                                                         strcmp(buf, "000")) ;
2424                                         ret = -ret;
2425                                 }
2426                         }
2427                         break;
2428                 case 9:                         /* ASYNC_MSG */
2429                         /* CtdlIPCDoAsync(ret, proto_response); */
2430                         free(CtdlIPCReadListing(ipc, NULL));    /* STUB FIXME */
2431                         break;
2432                 }
2433                 if (ret / 100 != 9)
2434                         break;
2435         }
2436         CtdlIPC_unlock(ipc);
2437         return ret;
2438 }
2439
2440
2441 static int connectsock(char *host, char *service, char *protocol, int defaultPort)
2442 {
2443         struct hostent *phe;
2444         struct servent *pse;
2445         struct protoent *ppe;
2446         struct sockaddr_in sin;
2447         int s, type;
2448
2449         memset(&sin, 0, sizeof(sin));
2450         sin.sin_family = AF_INET;
2451
2452         pse = getservbyname(service, protocol);
2453         if (pse != NULL) {
2454                 sin.sin_port = pse->s_port;
2455         }
2456         else if (atoi(service) > 0) {
2457                 sin.sin_port = htons(atoi(service));
2458         }
2459         else {
2460                 sin.sin_port = htons(defaultPort);
2461         }
2462         phe = gethostbyname(host);
2463         if (phe) {
2464                 memcpy(&sin.sin_addr, phe->h_addr, phe->h_length);
2465         } else if ((sin.sin_addr.s_addr = inet_addr(host)) == INADDR_NONE) {
2466                 return -1;
2467         }
2468         if ((ppe = getprotobyname(protocol)) == 0) {
2469                 return -1;
2470         }
2471         if (!strcmp(protocol, "udp")) {
2472                 type = SOCK_DGRAM;
2473         } else {
2474                 type = SOCK_STREAM;
2475         }
2476
2477         s = socket(PF_INET, type, ppe->p_proto);
2478         if (s < 0) {
2479                 return -1;
2480         }
2481
2482         if (connect(s, (struct sockaddr *) &sin, sizeof(sin)) < 0) {
2483                 return -1;
2484         }
2485
2486         return (s);
2487 }
2488
2489 static int uds_connectsock(int *isLocal, char *sockpath)
2490 {
2491         struct sockaddr_un addr;
2492         int s;
2493
2494         memset(&addr, 0, sizeof(addr));
2495         addr.sun_family = AF_UNIX;
2496         safestrncpy(addr.sun_path, sockpath, sizeof addr.sun_path);
2497
2498         s = socket(AF_UNIX, SOCK_STREAM, 0);
2499         if (s < 0) {
2500                 return -1;
2501         }
2502
2503         if (connect(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
2504                 return -1;
2505         }
2506
2507         *isLocal = 1;
2508         return s;
2509 }
2510
2511
2512 /*
2513  * input binary data from socket
2514  */
2515 static void serv_read(CtdlIPC *ipc, char *buf, unsigned int bytes)
2516 {
2517         unsigned int len, rlen;
2518
2519 #if defined(HAVE_OPENSSL)
2520         if (ipc->ssl) {
2521                 serv_read_ssl(ipc, buf, bytes);
2522                 return;
2523         }
2524 #endif
2525         len = 0;
2526         while (len < bytes) {
2527                 rlen = read(ipc->sock, &buf[len], bytes - len);
2528                 if (rlen < 1) {
2529                         connection_died(ipc);
2530                         return;
2531                 }
2532                 len += rlen;
2533         }
2534 }
2535
2536
2537 /*
2538  * send binary to server
2539  */
2540 static void serv_write(CtdlIPC *ipc, const char *buf, unsigned int nbytes)
2541 {
2542         unsigned int bytes_written = 0;
2543         int retval;
2544
2545 #if defined(HAVE_OPENSSL)
2546         if (ipc->ssl) {
2547                 serv_write_ssl(ipc, buf, nbytes);
2548                 return;
2549         }
2550 #endif
2551         while (bytes_written < nbytes) {
2552                 retval = write(ipc->sock, &buf[bytes_written],
2553                                nbytes - bytes_written);
2554                 if (retval < 1) {
2555                         connection_died(ipc);
2556                         return;
2557                 }
2558                 bytes_written += retval;
2559         }
2560 }
2561
2562
2563 #ifdef HAVE_OPENSSL
2564 /*
2565  * input binary data from encrypted connection
2566  */
2567 static void serv_read_ssl(CtdlIPC* ipc, char *buf, unsigned int bytes)
2568 {
2569         int len, rlen;
2570         char junk[1];
2571
2572         len = 0;
2573         while (len < bytes) {
2574                 if (SSL_want_read(ipc->ssl)) {
2575                         if ((SSL_write(ipc->ssl, junk, 0)) < 1) {
2576                                 error_printf("SSL_write in serv_read:\n");
2577                                 ERR_print_errors_fp(stderr);
2578                         }
2579                 }
2580                 rlen = SSL_read(ipc->ssl, &buf[len], bytes - len);
2581                 if (rlen < 1) {
2582                         long errval;
2583
2584                         errval = SSL_get_error(ipc->ssl, rlen);
2585                         if (errval == SSL_ERROR_WANT_READ ||
2586                                         errval == SSL_ERROR_WANT_WRITE) {
2587                                 sleep(1);
2588                                 continue;
2589                         }
2590                         if (errval == SSL_ERROR_ZERO_RETURN ||
2591                                         errval == SSL_ERROR_SSL) {
2592                                 serv_read(ipc, &buf[len], bytes - len);
2593                                 return;
2594                         }
2595                         error_printf("SSL_read in serv_read:\n");
2596                         ERR_print_errors_fp(stderr);
2597                         connection_died(NULL);
2598                         return;
2599                 }
2600                 len += rlen;
2601         }
2602 }
2603
2604
2605 /*
2606  * send binary to server encrypted
2607  */
2608 static void serv_write_ssl(CtdlIPC *ipc, const char *buf, unsigned int nbytes)
2609 {
2610         unsigned int bytes_written = 0;
2611         int retval;
2612         char junk[1];
2613
2614         while (bytes_written < nbytes) {
2615                 if (SSL_want_write(ipc->ssl)) {
2616                         if ((SSL_read(ipc->ssl, junk, 0)) < 1) {
2617                                 error_printf("SSL_read in serv_write:\n");
2618                                 ERR_print_errors_fp(stderr);
2619                         }
2620                 }
2621                 retval = SSL_write(ipc->ssl, &buf[bytes_written],
2622                                 nbytes - bytes_written);
2623                 if (retval < 1) {
2624                         long errval;
2625
2626                         errval = SSL_get_error(ipc->ssl, retval);
2627                         if (errval == SSL_ERROR_WANT_READ ||
2628                                         errval == SSL_ERROR_WANT_WRITE) {
2629                                 sleep(1);
2630                                 continue;
2631                         }
2632                         if (errval == SSL_ERROR_ZERO_RETURN ||
2633                                         errval == SSL_ERROR_SSL) {
2634                                 serv_write(ipc, &buf[bytes_written],
2635                                                 nbytes - bytes_written);
2636                                 return;
2637                         }
2638                         error_printf("SSL_write in serv_write:\n");
2639                         ERR_print_errors_fp(stderr);
2640                         connection_died(NULL);
2641                         return;
2642                 }
2643                 bytes_written += retval;
2644         }
2645 }
2646
2647
2648 static void CtdlIPC_init_OpenSSL(void)
2649 {
2650         int a;
2651         SSL_METHOD *ssl_method;
2652         DH *dh;
2653
2654         /* already done init */
2655         if (ssl_ctx) {
2656                 return;
2657         }
2658
2659         /* Get started */
2660         ssl_ctx = NULL;
2661         dh = NULL;
2662         SSL_load_error_strings();
2663         SSLeay_add_ssl_algorithms();
2664
2665         /* Set up the SSL context in which we will oeprate */
2666         ssl_method = SSLv23_client_method();
2667         ssl_ctx = SSL_CTX_new(ssl_method);
2668         if (!ssl_ctx) {
2669                 error_printf("SSL_CTX_new failed: %s\n",
2670                                 ERR_reason_error_string(ERR_get_error()));
2671                 return;
2672         }
2673         /* Any reasonable cipher we can get */
2674         if (!(SSL_CTX_set_cipher_list(ssl_ctx, CIT_CIPHERS))) {
2675                 error_printf("No ciphers available for encryption\n");
2676                 return;
2677         }
2678         SSL_CTX_set_session_cache_mode(ssl_ctx, SSL_SESS_CACHE_BOTH);
2679
2680         /* Load DH parameters into the context */
2681         dh = DH_new();
2682         if (!dh) {
2683                 error_printf("Can't allocate a DH object: %s\n",
2684                                 ERR_reason_error_string(ERR_get_error()));
2685                 return;
2686         }
2687         if (!(BN_hex2bn(&(dh->p), DH_P))) {
2688                 error_printf("Can't assign DH_P: %s\n",
2689                                 ERR_reason_error_string(ERR_get_error()));
2690                 DH_free(dh);
2691                 return;
2692         }
2693         if (!(BN_hex2bn(&(dh->g), DH_G))) {
2694                 error_printf("Can't assign DH_G: %s\n",
2695                                 ERR_reason_error_string(ERR_get_error()));
2696                 DH_free(dh);
2697                 return;
2698         }
2699         dh->length = DH_L;
2700         SSL_CTX_set_tmp_dh(ssl_ctx, dh);
2701         DH_free(dh);
2702
2703 #ifdef THREADED_CLIENT
2704         /* OpenSSL requires callbacks for threaded clients */
2705         CRYPTO_set_locking_callback(ssl_lock);
2706         CRYPTO_set_id_callback(id_callback);
2707
2708         /* OpenSSL requires us to do semaphores for threaded clients */
2709         Critters = malloc(CRYPTO_num_locks() * sizeof (pthread_mutex_t *));
2710         if (!Critters) {
2711                 perror("malloc failed");
2712                 exit(1);
2713         } else {
2714                 for (a = 0; a < CRYPTO_num_locks(); a++) {
2715                         Critters[a] = malloc(sizeof (pthread_mutex_t));
2716                         if (!Critters[a]) {
2717                                 perror("malloc failed");
2718                                 exit(1);
2719                         }
2720                         pthread_mutex_init(Critters[a], NULL);
2721                 }
2722         }
2723 #endif /* THREADED_CLIENT */
2724 }
2725
2726
2727 static void ssl_lock(int mode, int n, const char *file, int line)
2728 {
2729 #ifdef THREADED_CLIENT
2730         if (mode & CRYPTO_LOCK)
2731                 pthread_mutex_lock(Critters[n]);
2732         else
2733                 pthread_mutex_unlock(Critters[n]);
2734 #endif /* THREADED_CLIENT */
2735 }
2736
2737 #ifdef THREADED_CLIENT
2738 static unsigned long id_callback(void) {
2739         return (unsigned long)pthread_self();
2740 }
2741 #endif /* THREADED_CLIENT */
2742 #endif /* HAVE_OPENSSL */
2743
2744
2745 /*
2746  * input string from socket - implemented in terms of serv_read()
2747  */
2748 void CtdlIPC_getline(CtdlIPC* ipc, char *buf)
2749 {
2750         int i;
2751
2752         /* Read one character at a time. */
2753         for (i = 0;; i++) {
2754                 serv_read(ipc, &buf[i], 1);
2755                 if (buf[i] == '\n' || i == (SIZ-1))
2756                         break;
2757         }
2758
2759         /* If we got a long line, discard characters until the newline. */
2760         if (i == (SIZ-1))
2761                 while (buf[i] != '\n')
2762                         serv_read(ipc, &buf[i], 1);
2763
2764         /* Strip the trailing newline.
2765          */
2766         buf[i] = 0;
2767 }
2768
2769
2770 /*
2771  * send line to server - implemented in terms of serv_write()
2772  */
2773 void CtdlIPC_putline(CtdlIPC *ipc, const char *buf)
2774 {
2775         /* error_printf("< %s\n", buf); */
2776         serv_write(ipc, buf, strlen(buf));
2777         serv_write(ipc, "\n", 1);
2778
2779         ipc->last_command_sent = time(NULL);
2780 }
2781
2782
2783 /*
2784  * attach to server
2785  */
2786 CtdlIPC* CtdlIPC_new(int argc, char **argv, char *hostbuf, char *portbuf)
2787 {
2788         int a;
2789         char cithost[SIZ];
2790         char citport[SIZ];
2791         char sockpath[SIZ];
2792
2793         CtdlIPC *ipc = ialloc(CtdlIPC);
2794         if (!ipc) {
2795                 return 0;
2796         }
2797 #if defined(HAVE_OPENSSL)
2798         ipc->ssl = NULL;
2799         CtdlIPC_init_OpenSSL();
2800 #endif
2801 #if defined(HAVE_PTHREAD_H)
2802         pthread_mutex_init(&(ipc->mutex), NULL); /* Default fast mutex */
2803 #endif
2804         ipc->sock = -1;                 /* Not connected */
2805         ipc->isLocal = 0;               /* Not local, of course! */
2806         ipc->downloading = 0;
2807         ipc->uploading = 0;
2808         ipc->last_command_sent = 0L;
2809         ipc->network_status_cb = NULL;
2810
2811         strcpy(cithost, DEFAULT_HOST);  /* default host */
2812         strcpy(citport, DEFAULT_PORT);  /* default port */
2813
2814         for (a = 0; a < argc; ++a) {
2815                 if (a == 0) {
2816                         /* do nothing */
2817                 } else if (a == 1) {
2818                         strcpy(cithost, argv[a]);
2819                 } else if (a == 2) {
2820                         strcpy(citport, argv[a]);
2821                 } else {
2822                         error_printf("%s: usage: ",argv[0]);
2823                         error_printf("%s [host] [port] ",argv[0]);
2824                         ifree(ipc);
2825                         errno = EINVAL;
2826                         return 0;
2827                 }
2828         }
2829
2830         if ((!strcmp(cithost, "localhost"))
2831            || (!strcmp(cithost, "127.0.0.1"))) {
2832                 ipc->isLocal = 1;
2833         }
2834
2835         /* If we're using a unix domain socket we can do a bunch of stuff */
2836         if (!strcmp(cithost, UDS)) {
2837                 snprintf(sockpath, sizeof sockpath, BBSDIR "/citadel.socket");
2838                 ipc->sock = uds_connectsock(&(ipc->isLocal), sockpath);
2839                 if (ipc->sock == -1) {
2840                         ifree(ipc);
2841                         return 0;
2842                 }
2843                 if (hostbuf != NULL) strcpy(hostbuf, cithost);
2844                 if (portbuf != NULL) strcpy(portbuf, sockpath);
2845                 return ipc;
2846         }
2847
2848         ipc->sock = connectsock(cithost, citport, "tcp", 504);
2849         if (ipc->sock == -1) {
2850                 ifree(ipc);
2851                 return 0;
2852         }
2853         if (hostbuf != NULL) strcpy(hostbuf, cithost);
2854         if (portbuf != NULL) strcpy(portbuf, citport);
2855         return ipc;
2856 }
2857
2858 /*
2859  * return the file descriptor of the server socket so we can select() on it.
2860  *
2861  * FIXME: This is only used in chat mode; eliminate it when chat mode gets
2862  * rewritten...
2863  */
2864 int CtdlIPC_getsockfd(CtdlIPC* ipc)
2865 {
2866         return ipc->sock;
2867 }
2868
2869
2870 /*
2871  * return one character
2872  *
2873  * FIXME: This is only used in chat mode; eliminate it when chat mode gets
2874  * rewritten...
2875  */
2876 char CtdlIPC_get(CtdlIPC* ipc)
2877 {
2878         char buf[2];
2879         char ch;
2880
2881         serv_read(ipc, buf, 1);
2882         ch = (int) buf[0];
2883
2884         return (ch);
2885 }