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