1 #line 982 "../../src/builtin/snarf.m4"
2 /* -*- buffer-read-only: t -*- vi: set ro:
3 THIS FILE IS GENERATED AUTOMATICALLY. PLEASE DO NOT EDIT.
4 */
5 #line 982
6 #ifdef HAVE_CONFIG_H
7 #line 982
8 # include <config.h>
9 #line 982
10 #endif
11 #line 982
12 #include <sys/types.h>
13 #line 982
14
15 #line 982
16 #include "mailfromd.h"
17 #line 982
18 #include "prog.h"
19 #line 982
20 #include "builtin.h"
21 #line 982
22
23 #line 982
24
25 #line 1022 "../../src/builtin/snarf.m4"
26
27 /* End of snarf.m4 */
28 #line 1 "msg.bi"
29 /* This file is part of Mailfromd. -*- c -*-
30 Copyright (C) 2008-2021 Sergey Poznyakoff
31
32 This program is free software; you can redistribute it and/or modify
33 it under the terms of the GNU General Public License as published by
34 the Free Software Foundation; either version 3, or (at your option)
35 any later version.
36
37 This program is distributed in the hope that it will be useful,
38 but WITHOUT ANY WARRANTY; without even the implied warranty of
39 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
40 GNU General Public License for more details.
41
42 You should have received a copy of the GNU General Public License
43 along with this program. If not, see <http://www.gnu.org/licenses/>. */
44
45
46
47 #include "msg.h"
48 #include "global.h"
49
50 static size_t nmsgs = MAX_MSGS;
51
52 static struct mu_cfg_param msg_cfg_param[] = {
53 { "max-open-messages", mu_c_size, &nmsgs, 0, NULL,
54 N_("Maximum number of messages to open simultaneously.") },
55 { NULL }
56 };
57
58 static void *
alloc_msgs()59 alloc_msgs()
60 {
61 return mu_calloc(nmsgs, sizeof(struct mf_message));
62 }
63
64 static void
destroy_msgs(void * data)65 destroy_msgs(void *data)
66 {
67 struct mf_message *mtab = data;
68 struct mf_message *p;
69 for (p = mtab; p < mtab + nmsgs; p++) {
70 bi_close_message(p);
71 }
72 free(mtab);
73 }
74
75 void
drop_current_message(void * data)76 drop_current_message(void *data)
77 {
78 int i;
79 struct mf_message *tab = data;
80 for (i = 0; i < nmsgs; i++)
81 if (tab[i].msg && tab[i].type == MF_MSG_CURRENT) {
82 bi_close_message(&tab[i]);
83 break;
84 }
85 }
86
87
88 #line 59
89
90 #line 59
91 static int MSGTAB_id;
92 #line 59 "msg.bi"
93
94
95 static int
find_slot(struct mf_message * tab)96 find_slot(struct mf_message *tab)
97 {
98 int i;
99 for (i = 0; i < nmsgs; i++)
100 if (tab[i].msg == NULL)
101 return i;
102 return -1;
103 }
104
105 static int
do_msg_close(void * item,void * data)106 do_msg_close(void *item, void *data)
107 {
108 bi_close_message(item);
109 return 0;
110 }
111
112 void
bi_close_message(struct mf_message * mp)113 bi_close_message(struct mf_message *mp)
114 {
115 if (mp->msg) {
116 mu_stream_destroy(&mp->mstr);
117 mu_stream_destroy(&mp->bstr);
118 if (mp->type == MF_MSG_STANDALONE)
119 mu_message_destroy(&mp->msg,
120 mu_message_get_owner(mp->msg));
121 mu_list_foreach(mp->msglist, do_msg_close, NULL);
122 mu_list_destroy(&mp->msglist);
123 free(mp->buf);
124 memset(mp, 0, sizeof *mp);
125 }
126 }
127
128 int
bi_message_register(eval_environ_t env,mu_list_t msglist,mu_message_t msg,int type)129 bi_message_register(eval_environ_t env,
130 mu_list_t msglist, mu_message_t msg, int type)
131 {
132 struct mf_message *msgtab = env_get_builtin_priv(env,MSGTAB_id);
133 int idx = find_slot(msgtab);
134 if (idx >= 0) {
135 struct mf_message *mp = msgtab + idx;
136 mp->msg = msg;
137 mp->type = type;
138 mu_list_create(&mp->msglist);
139 if (msglist)
140 mu_list_append(msglist, mp);
141 }
142 return idx;
143 }
144
145 int
bi_get_current_message(eval_environ_t env,mu_message_t * ret_msg)146 bi_get_current_message(eval_environ_t env, mu_message_t *ret_msg)
147 {
148 int i;
149 struct mf_message *tab = env_get_builtin_priv(env,MSGTAB_id);
150 mu_stream_t mstr;
151 mu_message_t msg;
152 int rc;
153
154 for (i = 0; i < nmsgs; i++)
155 if (tab[i].msg && tab[i].type == MF_MSG_CURRENT)
156 break;
157 if (i == nmsgs) {
158 rc = env_get_stream(env,&mstr);
159 if (!(rc >= 0))
160 #line 125
161 (
162 #line 125
163 env_throw_bi(env, mfe_failure, NULL, _("cannot obtain capture stream reference: %s"),mu_strerror(rc))
164 #line 125
165 )
166 #line 128
167 ;
168 msg = _builtin_mu_stream_to_message(mstr, env, NULL);
169 i = bi_message_register(env, NULL, msg, MF_MSG_CURRENT);
170 if (!(i >= 0))
171 #line 131
172 (
173 #line 131
174 env_throw_bi(env, mfe_failure, NULL, _("no more message slots available"))
175 #line 131
176 )
177 #line 133
178 ;
179 }
180 if (ret_msg)
181 *ret_msg = tab[i].msg;
182 return i;
183 }
184
185
186 #line 152
187
188
189 #line 163
190
191
192 #line 174
193
194
195 #line 192
196
197
198 mu_message_t
bi_message_from_descr(eval_environ_t env,int nmsg)199 bi_message_from_descr(eval_environ_t env, int nmsg)
200 {
201
202 #line 197
203 struct mf_message *mtab = env_get_builtin_priv(env,MSGTAB_id);
204 #line 197
205 struct mf_message *mp;
206 #line 197
207
208 #line 197
209 if (!(nmsg >= 0 && nmsg < nmsgs))
210 #line 197
211 (
212 #line 197
213 env_throw_bi(env, mfe_range, NULL, _("invalid message descriptor"))
214 #line 197
215 )
216 #line 197
217 ;
218 #line 197
219 mp = mtab + nmsg;
220 #line 197
221 if (!(mp->msg))
222 #line 197
223 (
224 #line 197
225 env_throw_bi(env, mfe_failure, NULL, _("message not open"))
226 #line 197
227 )
228 #line 197
229
230 #line 197
231 ;
232 return mp->msg;
233 }
234
235 /* void message_close(number msg) */
236 void
237 #line 202
bi_message_close(eval_environ_t env)238 bi_message_close(eval_environ_t env)
239 #line 202
240
241 #line 202
242
243 #line 202 "msg.bi"
244 {
245 #line 202
246
247 #line 202
248
249 #line 202
250
251 #line 202
252 long nmsg;
253 #line 202
254
255 #line 202
256 get_numeric_arg(env, 0, &nmsg);
257 #line 202
258
259 #line 202
260
261 #line 202
262 adjust_stack(env, 1);
263 #line 202
264
265 #line 202
266
267 #line 202
268 if (builtin_module_trace(BUILTIN_IDX_msg))
269 #line 202
270 prog_trace(env, "message_close %lu",nmsg);;
271 #line 202
272
273 {
274
275 #line 204
276 struct mf_message *mtab = env_get_builtin_priv(env,MSGTAB_id);
277 #line 204
278 struct mf_message *mp;
279 #line 204
280
281 #line 204
282 if (!(nmsg >= 0 && nmsg < nmsgs))
283 #line 204
284 (
285 #line 204
286 env_throw_bi(env, mfe_range, "message_close", _("invalid message descriptor"))
287 #line 204
288 )
289 #line 204
290 ;
291 #line 204
292 mp = mtab + nmsg;
293 #line 204
294 if (!(mp->msg))
295 #line 204
296 (
297 #line 204
298 env_throw_bi(env, mfe_failure, "message_close", _("message not open"))
299 #line 204
300 )
301 #line 204
302
303 #line 204
304 ;
305 bi_close_message(mp);
306 }
307
308 #line 207
309 env_function_cleanup_flush(env, NULL);
310 #line 207
311 return;
312 #line 207
313 }
314
315 /* number message_size(number nmsg) */
316 void
317 #line 210
bi_message_size(eval_environ_t env)318 bi_message_size(eval_environ_t env)
319 #line 210
320
321 #line 210
322
323 #line 210 "msg.bi"
324 {
325 #line 210
326
327 #line 210
328
329 #line 210
330
331 #line 210
332 long nmsg;
333 #line 210
334
335 #line 210
336 get_numeric_arg(env, 0, &nmsg);
337 #line 210
338
339 #line 210
340
341 #line 210
342 adjust_stack(env, 1);
343 #line 210
344
345 #line 210
346
347 #line 210
348 if (builtin_module_trace(BUILTIN_IDX_msg))
349 #line 210
350 prog_trace(env, "message_size %lu",nmsg);;
351 #line 210
352
353 {
354 int rc;
355 size_t size;
356
357 #line 214
358 struct mf_message *mtab = env_get_builtin_priv(env,MSGTAB_id);
359 #line 214
360 struct mf_message *mp;
361 #line 214
362
363 #line 214
364 if (!(nmsg >= 0 && nmsg < nmsgs))
365 #line 214
366 (
367 #line 214
368 env_throw_bi(env, mfe_range, "message_size", _("invalid message descriptor"))
369 #line 214
370 )
371 #line 214
372 ;
373 #line 214
374 mp = mtab + nmsg;
375 #line 214
376 if (!(mp->msg))
377 #line 214
378 (
379 #line 214
380 env_throw_bi(env, mfe_failure, "message_size", _("message not open"))
381 #line 214
382 )
383 #line 214
384
385 #line 214
386 ;
387
388 rc = mu_message_size(mp->msg, &size);
389 if (!(rc == 0))
390 #line 217
391 (
392 #line 217
393 env_throw_bi(env, mfe_failure, "message_size", "%s",mu_strerror(rc))
394 #line 217
395 )
396 #line 219
397 ;
398 if (!(size < LONG_MAX))
399 #line 220
400 (
401 #line 220
402 env_throw_bi(env, mfe_range, "message_size", _("message size out of representable range"))
403 #line 220
404 )
405 #line 222
406 ;
407
408 #line 223
409 do {
410 #line 223
411 push(env, (STKVAL)(mft_number)((long)size));
412 #line 223
413 goto endlab;
414 #line 223
415 } while (0);
416 }
417 endlab:
418 #line 225
419 env_function_cleanup_flush(env, NULL);
420 #line 225
421 return;
422 #line 225
423 }
424
425 /* number message_lines(number nmsg) */
426 void
427 #line 228
bi_message_lines(eval_environ_t env)428 bi_message_lines(eval_environ_t env)
429 #line 228
430
431 #line 228
432
433 #line 228 "msg.bi"
434 {
435 #line 228
436
437 #line 228
438
439 #line 228
440
441 #line 228
442 long nmsg;
443 #line 228
444
445 #line 228
446 get_numeric_arg(env, 0, &nmsg);
447 #line 228
448
449 #line 228
450
451 #line 228
452 adjust_stack(env, 1);
453 #line 228
454
455 #line 228
456
457 #line 228
458 if (builtin_module_trace(BUILTIN_IDX_msg))
459 #line 228
460 prog_trace(env, "message_lines %lu",nmsg);;
461 #line 228
462
463 {
464 int rc;
465 size_t lines;
466
467 #line 232
468 struct mf_message *mtab = env_get_builtin_priv(env,MSGTAB_id);
469 #line 232
470 struct mf_message *mp;
471 #line 232
472
473 #line 232
474 if (!(nmsg >= 0 && nmsg < nmsgs))
475 #line 232
476 (
477 #line 232
478 env_throw_bi(env, mfe_range, "message_lines", _("invalid message descriptor"))
479 #line 232
480 )
481 #line 232
482 ;
483 #line 232
484 mp = mtab + nmsg;
485 #line 232
486 if (!(mp->msg))
487 #line 232
488 (
489 #line 232
490 env_throw_bi(env, mfe_failure, "message_lines", _("message not open"))
491 #line 232
492 )
493 #line 232
494
495 #line 232
496 ;
497
498 rc = mu_message_lines(mp->msg, &lines);
499 if (!(rc == 0))
500 #line 235
501 (
502 #line 235
503 env_throw_bi(env, mfe_failure, "message_lines", "%s",mu_strerror(rc))
504 #line 235
505 )
506 #line 238
507 ;
508
509 #line 239
510 do {
511 #line 239
512 push(env, (STKVAL)(mft_number)(lines));
513 #line 239
514 goto endlab;
515 #line 239
516 } while (0);
517 }
518 endlab:
519 #line 241
520 env_function_cleanup_flush(env, NULL);
521 #line 241
522 return;
523 #line 241
524 }
525
526 /* number message_body_size(number nmsg) */
527 void
528 #line 244
bi_message_body_size(eval_environ_t env)529 bi_message_body_size(eval_environ_t env)
530 #line 244
531
532 #line 244
533
534 #line 244 "msg.bi"
535 {
536 #line 244
537
538 #line 244
539
540 #line 244
541
542 #line 244
543 long nmsg;
544 #line 244
545
546 #line 244
547 get_numeric_arg(env, 0, &nmsg);
548 #line 244
549
550 #line 244
551
552 #line 244
553 adjust_stack(env, 1);
554 #line 244
555
556 #line 244
557
558 #line 244
559 if (builtin_module_trace(BUILTIN_IDX_msg))
560 #line 244
561 prog_trace(env, "message_body_size %lu",nmsg);;
562 #line 244
563
564 {
565 int rc;
566 size_t size;
567
568 #line 248
569
570 #line 248
571 struct mf_message *mtab = env_get_builtin_priv(env,MSGTAB_id);
572 #line 248
573 struct mf_message *mp;
574 #line 248
575
576 #line 248
577 if (!(nmsg >= 0 && nmsg < nmsgs))
578 #line 248
579 (
580 #line 248
581 env_throw_bi(env, mfe_range, "message_body_size", _("invalid message descriptor"))
582 #line 248
583 )
584 #line 248
585 ;
586 #line 248
587 mp = mtab + nmsg;
588 #line 248
589 if (!(mp->msg))
590 #line 248
591 (
592 #line 248
593 env_throw_bi(env, mfe_failure, "message_body_size", _("message not open"))
594 #line 248
595 )
596 #line 248
597
598 #line 248
599 ;
600 #line 248
601 if (!mp->body) {
602 #line 248
603 int rc = mu_message_get_body(mp->msg, &mp->body);
604 #line 248
605 if (!(rc == 0))
606 #line 248
607 (
608 #line 248
609 env_throw_bi(env, mfe_failure, "message_body_size", "mu_message_get_body: %s",mu_strerror(rc))
610 #line 248
611 )
612 #line 248
613 ;
614 #line 248
615 }
616 #line 248
617 ;
618
619 rc = mu_body_size(mp->body, &size);
620 if (!(rc == 0))
621 #line 251
622 (
623 #line 251
624 env_throw_bi(env, mfe_failure, "message_body_size", "%s",mu_strerror(rc))
625 #line 251
626 )
627 #line 253
628 ;
629 if (!(size < LONG_MAX))
630 #line 254
631 (
632 #line 254
633 env_throw_bi(env, mfe_range, "message_body_size", _("body size out of representable range"))
634 #line 254
635 )
636 #line 256
637 ;
638
639 #line 257
640 do {
641 #line 257
642 push(env, (STKVAL)(mft_number)((long)size));
643 #line 257
644 goto endlab;
645 #line 257
646 } while (0);
647 }
648 endlab:
649 #line 259
650 env_function_cleanup_flush(env, NULL);
651 #line 259
652 return;
653 #line 259
654 }
655
656 /* boolean message_body_is_empty(number nmsg) */
657 void
658 #line 262
bi_message_body_is_empty(eval_environ_t env)659 bi_message_body_is_empty(eval_environ_t env)
660 #line 262
661
662 #line 262
663
664 #line 262 "msg.bi"
665 {
666 #line 262
667
668 #line 262
669
670 #line 262
671
672 #line 262
673 long nmsg;
674 #line 262
675
676 #line 262
677 get_numeric_arg(env, 0, &nmsg);
678 #line 262
679
680 #line 262
681
682 #line 262
683 adjust_stack(env, 1);
684 #line 262
685
686 #line 262
687
688 #line 262
689 if (builtin_module_trace(BUILTIN_IDX_msg))
690 #line 262
691 prog_trace(env, "message_body_is_empty %lu",nmsg);;
692 #line 262
693
694 {
695 int rc, res;
696 char c;
697 size_t n;
698 mu_stream_t input, fstr;
699 char *encoding = NULL;
700
701
702 #line 270
703
704 #line 270
705 struct mf_message *mtab = env_get_builtin_priv(env,MSGTAB_id);
706 #line 270
707 struct mf_message *mp;
708 #line 270
709
710 #line 270
711 if (!(nmsg >= 0 && nmsg < nmsgs))
712 #line 270
713 (
714 #line 270
715 env_throw_bi(env, mfe_range, "message_body_is_empty", _("invalid message descriptor"))
716 #line 270
717 )
718 #line 270
719 ;
720 #line 270
721 mp = mtab + nmsg;
722 #line 270
723 if (!(mp->msg))
724 #line 270
725 (
726 #line 270
727 env_throw_bi(env, mfe_failure, "message_body_is_empty", _("message not open"))
728 #line 270
729 )
730 #line 270
731
732 #line 270
733 ;
734 #line 270
735 if (!mp->body) {
736 #line 270
737 int rc = mu_message_get_body(mp->msg, &mp->body);
738 #line 270
739 if (!(rc == 0))
740 #line 270
741 (
742 #line 270
743 env_throw_bi(env, mfe_failure, "message_body_is_empty", "mu_message_get_body: %s",mu_strerror(rc))
744 #line 270
745 )
746 #line 270
747 ;
748 #line 270
749 }
750 #line 270
751 if (!mp->hdr) {
752 #line 270
753 int rc = mu_message_get_header(mp->msg, &mp->hdr);
754 #line 270
755 if (!(rc == 0))
756 #line 270
757 (
758 #line 270
759 env_throw_bi(env, mfe_failure, "message_body_is_empty", "mu_message_get_header: %s",mu_strerror(rc))
760 #line 270
761 )
762 #line 270
763 ;
764 #line 270
765 }
766 #line 270
767 ;
768 rc = mu_body_size(mp->body, &n);
769 if (!(rc == 0))
770 #line 272
771 (
772 #line 272
773 env_throw_bi(env, mfe_failure, "message_body_is_empty", "mu_body_size: %s",mu_strerror(rc))
774 #line 272
775 )
776 #line 274
777 ;
778 if (n == 0)
779
780 #line 276
781 do {
782 #line 276
783 push(env, (STKVAL)(mft_number)(1));
784 #line 276
785 goto endlab;
786 #line 276
787 } while (0);
788
789 rc = mu_body_get_streamref(mp->body, &input);
790 if (!(rc == 0))
791 #line 279
792 (
793 #line 279
794 env_throw_bi(env, mfe_failure, "message_body_is_empty", "mu_body_get_streamref: %s",mu_strerror(rc))
795 #line 279
796 )
797 #line 281
798 ;
799
800 mu_header_aget_value_unfold(mp->hdr,
801 MU_HEADER_CONTENT_TRANSFER_ENCODING,
802 &encoding);
803 if (encoding) {
804 rc = mu_filter_create(&fstr, input, encoding,
805 MU_FILTER_DECODE,
806 MU_STREAM_READ);
807 if (rc) {
808 mu_error(_("can't create filter for encoding %s: %s"),
809 encoding, mu_strerror(rc));
810 fstr = input;
811 } else
812 mu_stream_unref(input);
813 free(encoding);
814 } else
815 fstr = input;
816
817 res = 1;
818 while (mu_stream_read(fstr, &c, 1, &n) == 0 && n > 0) {
819 if (!mu_isspace(c)) {
820 res = 0;
821 break;
822 }
823 }
824 mu_stream_unref(fstr);
825
826 #line 308
827 do {
828 #line 308
829 push(env, (STKVAL)(mft_number)(res));
830 #line 308
831 goto endlab;
832 #line 308
833 } while (0);
834 }
835 endlab:
836 #line 310
837 env_function_cleanup_flush(env, NULL);
838 #line 310
839 return;
840 #line 310
841 }
842
843 /* number message_body_lines(number nmsg) */
844 void
845 #line 313
bi_message_body_lines(eval_environ_t env)846 bi_message_body_lines(eval_environ_t env)
847 #line 313
848
849 #line 313
850
851 #line 313 "msg.bi"
852 {
853 #line 313
854
855 #line 313
856
857 #line 313
858
859 #line 313
860 long nmsg;
861 #line 313
862
863 #line 313
864 get_numeric_arg(env, 0, &nmsg);
865 #line 313
866
867 #line 313
868
869 #line 313
870 adjust_stack(env, 1);
871 #line 313
872
873 #line 313
874
875 #line 313
876 if (builtin_module_trace(BUILTIN_IDX_msg))
877 #line 313
878 prog_trace(env, "message_body_lines %lu",nmsg);;
879 #line 313
880
881 {
882 int rc;
883 size_t lines;
884
885 #line 317
886
887 #line 317
888 struct mf_message *mtab = env_get_builtin_priv(env,MSGTAB_id);
889 #line 317
890 struct mf_message *mp;
891 #line 317
892
893 #line 317
894 if (!(nmsg >= 0 && nmsg < nmsgs))
895 #line 317
896 (
897 #line 317
898 env_throw_bi(env, mfe_range, "message_body_lines", _("invalid message descriptor"))
899 #line 317
900 )
901 #line 317
902 ;
903 #line 317
904 mp = mtab + nmsg;
905 #line 317
906 if (!(mp->msg))
907 #line 317
908 (
909 #line 317
910 env_throw_bi(env, mfe_failure, "message_body_lines", _("message not open"))
911 #line 317
912 )
913 #line 317
914
915 #line 317
916 ;
917 #line 317
918 if (!mp->body) {
919 #line 317
920 int rc = mu_message_get_body(mp->msg, &mp->body);
921 #line 317
922 if (!(rc == 0))
923 #line 317
924 (
925 #line 317
926 env_throw_bi(env, mfe_failure, "message_body_lines", "mu_message_get_body: %s",mu_strerror(rc))
927 #line 317
928 )
929 #line 317
930 ;
931 #line 317
932 }
933 #line 317
934 ;
935
936 rc = mu_body_lines(mp->body, &lines);
937 if (!(rc == 0))
938 #line 320
939 (
940 #line 320
941 env_throw_bi(env, mfe_failure, "message_body_lines", "%s",mu_strerror(rc))
942 #line 320
943 )
944 #line 323
945 ;
946
947 #line 324
948 do {
949 #line 324
950 push(env, (STKVAL)(mft_number)(lines));
951 #line 324
952 goto endlab;
953 #line 324
954 } while (0);
955 }
956 endlab:
957 #line 326
958 env_function_cleanup_flush(env, NULL);
959 #line 326
960 return;
961 #line 326
962 }
963
964
965 /* Headers */
966
967 /* number message_header_size(number nmsg) */
968 void
969 #line 332
bi_message_header_size(eval_environ_t env)970 bi_message_header_size(eval_environ_t env)
971 #line 332
972
973 #line 332
974
975 #line 332 "msg.bi"
976 {
977 #line 332
978
979 #line 332
980
981 #line 332
982
983 #line 332
984 long nmsg;
985 #line 332
986
987 #line 332
988 get_numeric_arg(env, 0, &nmsg);
989 #line 332
990
991 #line 332
992
993 #line 332
994 adjust_stack(env, 1);
995 #line 332
996
997 #line 332
998
999 #line 332
1000 if (builtin_module_trace(BUILTIN_IDX_msg))
1001 #line 332
1002 prog_trace(env, "message_header_size %lu",nmsg);;
1003 #line 332
1004
1005 {
1006 int rc;
1007 size_t size;
1008
1009 #line 336
1010
1011 #line 336
1012 struct mf_message *mtab = env_get_builtin_priv(env,MSGTAB_id);
1013 #line 336
1014 struct mf_message *mp;
1015 #line 336
1016
1017 #line 336
1018 if (!(nmsg >= 0 && nmsg < nmsgs))
1019 #line 336
1020 (
1021 #line 336
1022 env_throw_bi(env, mfe_range, "message_header_size", _("invalid message descriptor"))
1023 #line 336
1024 )
1025 #line 336
1026 ;
1027 #line 336
1028 mp = mtab + nmsg;
1029 #line 336
1030 if (!(mp->msg))
1031 #line 336
1032 (
1033 #line 336
1034 env_throw_bi(env, mfe_failure, "message_header_size", _("message not open"))
1035 #line 336
1036 )
1037 #line 336
1038
1039 #line 336
1040 ;
1041 #line 336
1042 if (!mp->hdr) {
1043 #line 336
1044 int rc = mu_message_get_header(mp->msg, &mp->hdr);
1045 #line 336
1046 if (!(rc == 0))
1047 #line 336
1048 (
1049 #line 336
1050 env_throw_bi(env, mfe_failure, "message_header_size", "mu_message_get_header: %s",mu_strerror(rc))
1051 #line 336
1052 )
1053 #line 336
1054 ;
1055 #line 336
1056 }
1057 #line 336
1058 ;
1059
1060 rc = mu_header_size(mp->hdr, &size);
1061 if (!(rc == 0))
1062 #line 339
1063 (
1064 #line 339
1065 env_throw_bi(env, mfe_failure, "message_header_size", "%s",mu_strerror(rc))
1066 #line 339
1067 )
1068 #line 341
1069 ;
1070 if (!(size < LONG_MAX))
1071 #line 342
1072 (
1073 #line 342
1074 env_throw_bi(env, mfe_range, "message_header_size", _("header size out of representable range"))
1075 #line 342
1076 )
1077 #line 344
1078 ;
1079
1080 #line 345
1081 do {
1082 #line 345
1083 push(env, (STKVAL)(mft_number)((long)size));
1084 #line 345
1085 goto endlab;
1086 #line 345
1087 } while (0);
1088 }
1089 endlab:
1090 #line 347
1091 env_function_cleanup_flush(env, NULL);
1092 #line 347
1093 return;
1094 #line 347
1095 }
1096
1097 /* number message_header_lines(number nmsg) */
1098 void
1099 #line 350
bi_message_header_lines(eval_environ_t env)1100 bi_message_header_lines(eval_environ_t env)
1101 #line 350
1102
1103 #line 350
1104
1105 #line 350 "msg.bi"
1106 {
1107 #line 350
1108
1109 #line 350
1110
1111 #line 350
1112
1113 #line 350
1114 long nmsg;
1115 #line 350
1116
1117 #line 350
1118 get_numeric_arg(env, 0, &nmsg);
1119 #line 350
1120
1121 #line 350
1122
1123 #line 350
1124 adjust_stack(env, 1);
1125 #line 350
1126
1127 #line 350
1128
1129 #line 350
1130 if (builtin_module_trace(BUILTIN_IDX_msg))
1131 #line 350
1132 prog_trace(env, "message_header_lines %lu",nmsg);;
1133 #line 350
1134
1135 {
1136 int rc;
1137 size_t lines;
1138
1139 #line 354
1140
1141 #line 354
1142 struct mf_message *mtab = env_get_builtin_priv(env,MSGTAB_id);
1143 #line 354
1144 struct mf_message *mp;
1145 #line 354
1146
1147 #line 354
1148 if (!(nmsg >= 0 && nmsg < nmsgs))
1149 #line 354
1150 (
1151 #line 354
1152 env_throw_bi(env, mfe_range, "message_header_lines", _("invalid message descriptor"))
1153 #line 354
1154 )
1155 #line 354
1156 ;
1157 #line 354
1158 mp = mtab + nmsg;
1159 #line 354
1160 if (!(mp->msg))
1161 #line 354
1162 (
1163 #line 354
1164 env_throw_bi(env, mfe_failure, "message_header_lines", _("message not open"))
1165 #line 354
1166 )
1167 #line 354
1168
1169 #line 354
1170 ;
1171 #line 354
1172 if (!mp->hdr) {
1173 #line 354
1174 int rc = mu_message_get_header(mp->msg, &mp->hdr);
1175 #line 354
1176 if (!(rc == 0))
1177 #line 354
1178 (
1179 #line 354
1180 env_throw_bi(env, mfe_failure, "message_header_lines", "mu_message_get_header: %s",mu_strerror(rc))
1181 #line 354
1182 )
1183 #line 354
1184 ;
1185 #line 354
1186 }
1187 #line 354
1188 ;
1189
1190 rc = mu_header_lines(mp->hdr, &lines);
1191 if (!(rc == 0))
1192 #line 357
1193 (
1194 #line 357
1195 env_throw_bi(env, mfe_failure, "message_header_lines", "%s",mu_strerror(rc))
1196 #line 357
1197 )
1198 #line 360
1199 ;
1200
1201 #line 361
1202 do {
1203 #line 361
1204 push(env, (STKVAL)(mft_number)(lines));
1205 #line 361
1206 goto endlab;
1207 #line 361
1208 } while (0);
1209 }
1210 endlab:
1211 #line 363
1212 env_function_cleanup_flush(env, NULL);
1213 #line 363
1214 return;
1215 #line 363
1216 }
1217
1218 /* number message_header_count(number nmsg[; string name]) */
1219 void
1220 #line 366
bi_message_header_count(eval_environ_t env)1221 bi_message_header_count(eval_environ_t env)
1222 #line 366
1223
1224 #line 366
1225
1226 #line 366 "msg.bi"
1227 {
1228 #line 366
1229
1230 #line 366
1231
1232 #line 366
1233 long __bi_argcnt;
1234 #line 366
1235 long nmsg;
1236 #line 366
1237 char * name;
1238 #line 366
1239
1240 #line 366
1241 get_numeric_arg(env, 1, &nmsg);
1242 #line 366
1243 get_string_arg(env, 2, &name);
1244 #line 366
1245
1246 #line 366
1247 get_numeric_arg(env, 0, &__bi_argcnt);
1248 #line 366
1249 adjust_stack(env, __bi_argcnt + 1);
1250 #line 366
1251
1252 #line 366
1253
1254 #line 366
1255 if (builtin_module_trace(BUILTIN_IDX_msg))
1256 #line 366
1257 prog_trace(env, "message_header_count %lu %s",nmsg, ((__bi_argcnt > 1) ? name : ""));;
1258
1259 {
1260 int rc;
1261 size_t count;
1262
1263 #line 371
1264
1265 #line 371
1266 struct mf_message *mtab = env_get_builtin_priv(env,MSGTAB_id);
1267 #line 371
1268 struct mf_message *mp;
1269 #line 371
1270
1271 #line 371
1272 if (!(nmsg >= 0 && nmsg < nmsgs))
1273 #line 371
1274 (
1275 #line 371
1276 env_throw_bi(env, mfe_range, "message_header_count", _("invalid message descriptor"))
1277 #line 371
1278 )
1279 #line 371
1280 ;
1281 #line 371
1282 mp = mtab + nmsg;
1283 #line 371
1284 if (!(mp->msg))
1285 #line 371
1286 (
1287 #line 371
1288 env_throw_bi(env, mfe_failure, "message_header_count", _("message not open"))
1289 #line 371
1290 )
1291 #line 371
1292
1293 #line 371
1294 ;
1295 #line 371
1296 if (!mp->hdr) {
1297 #line 371
1298 int rc = mu_message_get_header(mp->msg, &mp->hdr);
1299 #line 371
1300 if (!(rc == 0))
1301 #line 371
1302 (
1303 #line 371
1304 env_throw_bi(env, mfe_failure, "message_header_count", "mu_message_get_header: %s",mu_strerror(rc))
1305 #line 371
1306 )
1307 #line 371
1308 ;
1309 #line 371
1310 }
1311 #line 371
1312 ;
1313
1314 rc = mu_header_get_field_count(mp->hdr, &count);
1315 if (!(rc == 0))
1316 #line 374
1317 (
1318 #line 374
1319 env_throw_bi(env, mfe_failure, "message_header_count", "%s",mu_strerror(rc))
1320 #line 374
1321 )
1322 #line 377
1323 ;
1324
1325 if ((__bi_argcnt > 1)) {
1326 size_t n;
1327
1328 for (n = 1; n <= count; n++) {
1329 const char *val;
1330 rc = mu_header_sget_value_n(mp->hdr, name, n, &val);
1331 if (rc == MU_ERR_NOENT)
1332 break;
1333 else if (rc)
1334 (
1335 #line 388
1336 env_throw_bi(env, mfe_failure, "message_header_count", "%s",mu_strerror(rc))
1337 #line 388
1338 );
1339 }
1340 count = n - 1;
1341 }
1342
1343 #line 392
1344 do {
1345 #line 392
1346 push(env, (STKVAL)(mft_number)(count));
1347 #line 392
1348 goto endlab;
1349 #line 392
1350 } while (0);
1351 }
1352 endlab:
1353 #line 394
1354 env_function_cleanup_flush(env, NULL);
1355 #line 394
1356 return;
1357 #line 394
1358 }
1359
1360 /* bool message_has_header(number msg, string header[, number idx]) */
1361 void
1362 #line 397
bi_message_has_header(eval_environ_t env)1363 bi_message_has_header(eval_environ_t env)
1364 #line 397
1365
1366 #line 397
1367
1368 #line 397 "msg.bi"
1369 {
1370 #line 397
1371
1372 #line 397
1373
1374 #line 397
1375 long __bi_argcnt;
1376 #line 397
1377 long nmsg;
1378 #line 397
1379 char * header;
1380 #line 397
1381 long idx;
1382 #line 397
1383
1384 #line 397
1385 get_numeric_arg(env, 1, &nmsg);
1386 #line 397
1387 get_string_arg(env, 2, &header);
1388 #line 397
1389 get_numeric_arg(env, 3, &idx);
1390 #line 397
1391
1392 #line 397
1393 get_numeric_arg(env, 0, &__bi_argcnt);
1394 #line 397
1395 adjust_stack(env, __bi_argcnt + 1);
1396 #line 397
1397
1398 #line 397
1399
1400 #line 397
1401 if (builtin_module_trace(BUILTIN_IDX_msg))
1402 #line 397
1403 prog_trace(env, "message_has_header %lu %s %lu",nmsg, header, ((__bi_argcnt > 2) ? idx : 0));;
1404
1405 {
1406 int rc;
1407 const char *val;
1408
1409 #line 402
1410
1411 #line 402
1412 struct mf_message *mtab = env_get_builtin_priv(env,MSGTAB_id);
1413 #line 402
1414 struct mf_message *mp;
1415 #line 402
1416
1417 #line 402
1418 if (!(nmsg >= 0 && nmsg < nmsgs))
1419 #line 402
1420 (
1421 #line 402
1422 env_throw_bi(env, mfe_range, "message_has_header", _("invalid message descriptor"))
1423 #line 402
1424 )
1425 #line 402
1426 ;
1427 #line 402
1428 mp = mtab + nmsg;
1429 #line 402
1430 if (!(mp->msg))
1431 #line 402
1432 (
1433 #line 402
1434 env_throw_bi(env, mfe_failure, "message_has_header", _("message not open"))
1435 #line 402
1436 )
1437 #line 402
1438
1439 #line 402
1440 ;
1441 #line 402
1442 if (!mp->hdr) {
1443 #line 402
1444 int rc = mu_message_get_header(mp->msg, &mp->hdr);
1445 #line 402
1446 if (!(rc == 0))
1447 #line 402
1448 (
1449 #line 402
1450 env_throw_bi(env, mfe_failure, "message_has_header", "mu_message_get_header: %s",mu_strerror(rc))
1451 #line 402
1452 )
1453 #line 402
1454 ;
1455 #line 402
1456 }
1457 #line 402
1458 ;
1459
1460 rc = mu_header_sget_value_n(mp->hdr, header, ((__bi_argcnt > 2) ? idx : 1), &val);
1461
1462 #line 405
1463 do {
1464 #line 405
1465 push(env, (STKVAL)(mft_number)(rc == 0));
1466 #line 405
1467 goto endlab;
1468 #line 405
1469 } while (0);
1470 }
1471 endlab:
1472 #line 407
1473 env_function_cleanup_flush(env, NULL);
1474 #line 407
1475 return;
1476 #line 407
1477 }
1478
1479 /* string message_find_header(number msg, string header[, number idx]) */
1480 void
1481 #line 410
bi_message_find_header(eval_environ_t env)1482 bi_message_find_header(eval_environ_t env)
1483 #line 410
1484
1485 #line 410
1486
1487 #line 410 "msg.bi"
1488 {
1489 #line 410
1490
1491 #line 410
1492
1493 #line 410
1494 long __bi_argcnt;
1495 #line 410
1496 long nmsg;
1497 #line 410
1498 char * MFL_DATASEG header;
1499 #line 410
1500 long idx;
1501 #line 410
1502
1503 #line 410
1504 get_numeric_arg(env, 1, &nmsg);
1505 #line 410
1506 get_string_arg(env, 2, &header);
1507 #line 410
1508 get_numeric_arg(env, 3, &idx);
1509 #line 410
1510
1511 #line 410
1512 get_numeric_arg(env, 0, &__bi_argcnt);
1513 #line 410
1514 adjust_stack(env, __bi_argcnt + 1);
1515 #line 410
1516
1517 #line 410
1518
1519 #line 410
1520 if (builtin_module_trace(BUILTIN_IDX_msg))
1521 #line 410
1522 prog_trace(env, "message_find_header %lu %s %lu",nmsg, header, ((__bi_argcnt > 2) ? idx : 0));;
1523
1524 {
1525 int rc;
1526 const char *val;
1527
1528 #line 415
1529
1530 #line 415
1531 struct mf_message *mtab = env_get_builtin_priv(env,MSGTAB_id);
1532 #line 415
1533 struct mf_message *mp;
1534 #line 415
1535
1536 #line 415
1537 if (!(nmsg >= 0 && nmsg < nmsgs))
1538 #line 415
1539 (
1540 #line 415
1541 env_throw_bi(env, mfe_range, "message_find_header", _("invalid message descriptor"))
1542 #line 415
1543 )
1544 #line 415
1545 ;
1546 #line 415
1547 mp = mtab + nmsg;
1548 #line 415
1549 if (!(mp->msg))
1550 #line 415
1551 (
1552 #line 415
1553 env_throw_bi(env, mfe_failure, "message_find_header", _("message not open"))
1554 #line 415
1555 )
1556 #line 415
1557
1558 #line 415
1559 ;
1560 #line 415
1561 if (!mp->hdr) {
1562 #line 415
1563 int rc = mu_message_get_header(mp->msg, &mp->hdr);
1564 #line 415
1565 if (!(rc == 0))
1566 #line 415
1567 (
1568 #line 415
1569 env_throw_bi(env, mfe_failure, "message_find_header", "mu_message_get_header: %s",mu_strerror(rc))
1570 #line 415
1571 )
1572 #line 415
1573 ;
1574 #line 415
1575 }
1576 #line 415
1577 ;
1578
1579 rc = mu_header_sget_value_n(mp->hdr, header, ((__bi_argcnt > 2) ? idx : 1), &val);
1580 if (rc == MU_ERR_NOENT)
1581 (
1582 #line 419
1583 env_throw_bi(env, mfe_not_found, "message_find_header", _("header not found"))
1584 #line 419
1585 );
1586 else if (rc)
1587 (
1588 #line 421
1589 env_throw_bi(env, mfe_failure, "message_find_header", "%s",mu_strerror(rc))
1590 #line 421
1591 );
1592
1593 #line 422
1594 do {
1595 #line 422
1596 pushs(env, val);
1597 #line 422
1598 goto endlab;
1599 #line 422
1600 } while (0);
1601 }
1602 endlab:
1603 #line 424
1604 env_function_cleanup_flush(env, NULL);
1605 #line 424
1606 return;
1607 #line 424
1608 }
1609
1610 /* string message_nth_header_name(number msg, number n) */
1611 void
1612 #line 427
bi_message_nth_header_name(eval_environ_t env)1613 bi_message_nth_header_name(eval_environ_t env)
1614 #line 427
1615
1616 #line 427
1617
1618 #line 427 "msg.bi"
1619 {
1620 #line 427
1621
1622 #line 427
1623
1624 #line 427
1625
1626 #line 427
1627 long nmsg;
1628 #line 427
1629 long idx;
1630 #line 427
1631
1632 #line 427
1633 get_numeric_arg(env, 0, &nmsg);
1634 #line 427
1635 get_numeric_arg(env, 1, &idx);
1636 #line 427
1637
1638 #line 427
1639
1640 #line 427
1641 adjust_stack(env, 2);
1642 #line 427
1643
1644 #line 427
1645
1646 #line 427
1647 if (builtin_module_trace(BUILTIN_IDX_msg))
1648 #line 427
1649 prog_trace(env, "message_nth_header_name %lu %lu",nmsg, idx);;
1650 #line 427
1651
1652 {
1653 int rc;
1654 const char *val;
1655
1656 #line 431
1657
1658 #line 431
1659 struct mf_message *mtab = env_get_builtin_priv(env,MSGTAB_id);
1660 #line 431
1661 struct mf_message *mp;
1662 #line 431
1663
1664 #line 431
1665 if (!(nmsg >= 0 && nmsg < nmsgs))
1666 #line 431
1667 (
1668 #line 431
1669 env_throw_bi(env, mfe_range, "message_nth_header_name", _("invalid message descriptor"))
1670 #line 431
1671 )
1672 #line 431
1673 ;
1674 #line 431
1675 mp = mtab + nmsg;
1676 #line 431
1677 if (!(mp->msg))
1678 #line 431
1679 (
1680 #line 431
1681 env_throw_bi(env, mfe_failure, "message_nth_header_name", _("message not open"))
1682 #line 431
1683 )
1684 #line 431
1685
1686 #line 431
1687 ;
1688 #line 431
1689 if (!mp->hdr) {
1690 #line 431
1691 int rc = mu_message_get_header(mp->msg, &mp->hdr);
1692 #line 431
1693 if (!(rc == 0))
1694 #line 431
1695 (
1696 #line 431
1697 env_throw_bi(env, mfe_failure, "message_nth_header_name", "mu_message_get_header: %s",mu_strerror(rc))
1698 #line 431
1699 )
1700 #line 431
1701 ;
1702 #line 431
1703 }
1704 #line 431
1705 ;
1706
1707 rc = mu_header_sget_field_name(mp->hdr, idx, &val);
1708 if (rc == MU_ERR_NOENT)
1709 (
1710 #line 435
1711 env_throw_bi(env, mfe_range, "message_nth_header_name", "header index out of range")
1712 #line 435
1713 );
1714 else if (rc)
1715 (
1716 #line 437
1717 env_throw_bi(env, mfe_failure, "message_nth_header_name", "%s",mu_strerror(rc))
1718 #line 437
1719 );
1720
1721 #line 438
1722 do {
1723 #line 438
1724 pushs(env, val);
1725 #line 438
1726 goto endlab;
1727 #line 438
1728 } while (0);
1729 }
1730 endlab:
1731 #line 440
1732 env_function_cleanup_flush(env, NULL);
1733 #line 440
1734 return;
1735 #line 440
1736 }
1737
1738 /* string message_nth_header_value(number msg, number n) */
1739 void
1740 #line 443
bi_message_nth_header_value(eval_environ_t env)1741 bi_message_nth_header_value(eval_environ_t env)
1742 #line 443
1743
1744 #line 443
1745
1746 #line 443 "msg.bi"
1747 {
1748 #line 443
1749
1750 #line 443
1751
1752 #line 443
1753
1754 #line 443
1755 long nmsg;
1756 #line 443
1757 long idx;
1758 #line 443
1759
1760 #line 443
1761 get_numeric_arg(env, 0, &nmsg);
1762 #line 443
1763 get_numeric_arg(env, 1, &idx);
1764 #line 443
1765
1766 #line 443
1767
1768 #line 443
1769 adjust_stack(env, 2);
1770 #line 443
1771
1772 #line 443
1773
1774 #line 443
1775 if (builtin_module_trace(BUILTIN_IDX_msg))
1776 #line 443
1777 prog_trace(env, "message_nth_header_value %lu %lu",nmsg, idx);;
1778 #line 443
1779
1780 {
1781 int rc;
1782 const char *val;
1783
1784 #line 447
1785
1786 #line 447
1787 struct mf_message *mtab = env_get_builtin_priv(env,MSGTAB_id);
1788 #line 447
1789 struct mf_message *mp;
1790 #line 447
1791
1792 #line 447
1793 if (!(nmsg >= 0 && nmsg < nmsgs))
1794 #line 447
1795 (
1796 #line 447
1797 env_throw_bi(env, mfe_range, "message_nth_header_value", _("invalid message descriptor"))
1798 #line 447
1799 )
1800 #line 447
1801 ;
1802 #line 447
1803 mp = mtab + nmsg;
1804 #line 447
1805 if (!(mp->msg))
1806 #line 447
1807 (
1808 #line 447
1809 env_throw_bi(env, mfe_failure, "message_nth_header_value", _("message not open"))
1810 #line 447
1811 )
1812 #line 447
1813
1814 #line 447
1815 ;
1816 #line 447
1817 if (!mp->hdr) {
1818 #line 447
1819 int rc = mu_message_get_header(mp->msg, &mp->hdr);
1820 #line 447
1821 if (!(rc == 0))
1822 #line 447
1823 (
1824 #line 447
1825 env_throw_bi(env, mfe_failure, "message_nth_header_value", "mu_message_get_header: %s",mu_strerror(rc))
1826 #line 447
1827 )
1828 #line 447
1829 ;
1830 #line 447
1831 }
1832 #line 447
1833 ;
1834
1835 rc = mu_header_sget_field_value(mp->hdr, idx, &val);
1836 if (rc == MU_ERR_NOENT)
1837 (
1838 #line 451
1839 env_throw_bi(env, mfe_range, "message_nth_header_value", "header index out of range")
1840 #line 451
1841 );
1842 else if (rc)
1843 (
1844 #line 453
1845 env_throw_bi(env, mfe_failure, "message_nth_header_value", "%s",mu_strerror(rc))
1846 #line 453
1847 );
1848
1849 #line 454
1850 do {
1851 #line 454
1852 pushs(env, val);
1853 #line 454
1854 goto endlab;
1855 #line 454
1856 } while (0);
1857 }
1858 endlab:
1859 #line 456
1860 env_function_cleanup_flush(env, NULL);
1861 #line 456
1862 return;
1863 #line 456
1864 }
1865
1866
1867 /* Multipart messages */
1868
1869 /* bool message_is_multipart(number msg) */
1870 void
1871 #line 462
bi_message_is_multipart(eval_environ_t env)1872 bi_message_is_multipart(eval_environ_t env)
1873 #line 462
1874
1875 #line 462
1876
1877 #line 462 "msg.bi"
1878 {
1879 #line 462
1880
1881 #line 462
1882
1883 #line 462
1884
1885 #line 462
1886 long nmsg;
1887 #line 462
1888
1889 #line 462
1890 get_numeric_arg(env, 0, &nmsg);
1891 #line 462
1892
1893 #line 462
1894
1895 #line 462
1896 adjust_stack(env, 1);
1897 #line 462
1898
1899 #line 462
1900
1901 #line 462
1902 if (builtin_module_trace(BUILTIN_IDX_msg))
1903 #line 462
1904 prog_trace(env, "message_is_multipart %lu",nmsg);;
1905 #line 462
1906
1907 {
1908 int rc, res;
1909
1910 #line 465
1911 struct mf_message *mtab = env_get_builtin_priv(env,MSGTAB_id);
1912 #line 465
1913 struct mf_message *mp;
1914 #line 465
1915
1916 #line 465
1917 if (!(nmsg >= 0 && nmsg < nmsgs))
1918 #line 465
1919 (
1920 #line 465
1921 env_throw_bi(env, mfe_range, "message_is_multipart", _("invalid message descriptor"))
1922 #line 465
1923 )
1924 #line 465
1925 ;
1926 #line 465
1927 mp = mtab + nmsg;
1928 #line 465
1929 if (!(mp->msg))
1930 #line 465
1931 (
1932 #line 465
1933 env_throw_bi(env, mfe_failure, "message_is_multipart", _("message not open"))
1934 #line 465
1935 )
1936 #line 465
1937
1938 #line 465
1939 ;
1940
1941 rc = mu_message_is_multipart(mp->msg, &res);
1942 if (!(rc == 0))
1943 #line 468
1944 (
1945 #line 468
1946 env_throw_bi(env, mfe_failure, "message_is_multipart", "%s",mu_strerror(rc))
1947 #line 468
1948 )
1949 #line 471
1950 ;
1951
1952 #line 472
1953 do {
1954 #line 472
1955 push(env, (STKVAL)(mft_number)(res));
1956 #line 472
1957 goto endlab;
1958 #line 472
1959 } while (0);
1960 }
1961 endlab:
1962 #line 474
1963 env_function_cleanup_flush(env, NULL);
1964 #line 474
1965 return;
1966 #line 474
1967 }
1968
1969 /* number message_count_parts(number msg) */
1970 void
1971 #line 477
bi_message_count_parts(eval_environ_t env)1972 bi_message_count_parts(eval_environ_t env)
1973 #line 477
1974
1975 #line 477
1976
1977 #line 477 "msg.bi"
1978 {
1979 #line 477
1980
1981 #line 477
1982
1983 #line 477
1984
1985 #line 477
1986 long nmsg;
1987 #line 477
1988
1989 #line 477
1990 get_numeric_arg(env, 0, &nmsg);
1991 #line 477
1992
1993 #line 477
1994
1995 #line 477
1996 adjust_stack(env, 1);
1997 #line 477
1998
1999 #line 477
2000
2001 #line 477
2002 if (builtin_module_trace(BUILTIN_IDX_msg))
2003 #line 477
2004 prog_trace(env, "message_count_parts %lu",nmsg);;
2005 #line 477
2006
2007 {
2008 int rc;
2009 size_t count;
2010
2011 #line 481
2012 struct mf_message *mtab = env_get_builtin_priv(env,MSGTAB_id);
2013 #line 481
2014 struct mf_message *mp;
2015 #line 481
2016
2017 #line 481
2018 if (!(nmsg >= 0 && nmsg < nmsgs))
2019 #line 481
2020 (
2021 #line 481
2022 env_throw_bi(env, mfe_range, "message_count_parts", _("invalid message descriptor"))
2023 #line 481
2024 )
2025 #line 481
2026 ;
2027 #line 481
2028 mp = mtab + nmsg;
2029 #line 481
2030 if (!(mp->msg))
2031 #line 481
2032 (
2033 #line 481
2034 env_throw_bi(env, mfe_failure, "message_count_parts", _("message not open"))
2035 #line 481
2036 )
2037 #line 481
2038
2039 #line 481
2040 ;
2041 rc = mu_message_get_num_parts(mp->msg, &count);
2042 if (!(rc == 0))
2043 #line 483
2044 (
2045 #line 483
2046 env_throw_bi(env, mfe_failure, "message_count_parts", "%s",mu_strerror(rc))
2047 #line 483
2048 )
2049 #line 486
2050 ;
2051
2052 #line 487
2053 do {
2054 #line 487
2055 push(env, (STKVAL)(mft_number)(count));
2056 #line 487
2057 goto endlab;
2058 #line 487
2059 } while (0);
2060 }
2061 endlab:
2062 #line 489
2063 env_function_cleanup_flush(env, NULL);
2064 #line 489
2065 return;
2066 #line 489
2067 }
2068
2069 /* number message_get_part(number msg, number idx) */
2070 void
2071 #line 492
bi_message_get_part(eval_environ_t env)2072 bi_message_get_part(eval_environ_t env)
2073 #line 492
2074
2075 #line 492
2076
2077 #line 492 "msg.bi"
2078 {
2079 #line 492
2080
2081 #line 492
2082
2083 #line 492
2084
2085 #line 492
2086 long nmsg;
2087 #line 492
2088 long idx;
2089 #line 492
2090
2091 #line 492
2092 get_numeric_arg(env, 0, &nmsg);
2093 #line 492
2094 get_numeric_arg(env, 1, &idx);
2095 #line 492
2096
2097 #line 492
2098
2099 #line 492
2100 adjust_stack(env, 2);
2101 #line 492
2102
2103 #line 492
2104
2105 #line 492
2106 if (builtin_module_trace(BUILTIN_IDX_msg))
2107 #line 492
2108 prog_trace(env, "message_get_part %lu %lu",nmsg, idx);;
2109 #line 492
2110
2111 {
2112 int rc;
2113 mu_message_t msg;
2114
2115 #line 496
2116 struct mf_message *mtab = env_get_builtin_priv(env,MSGTAB_id);
2117 #line 496
2118 struct mf_message *mp;
2119 #line 496
2120
2121 #line 496
2122 if (!(nmsg >= 0 && nmsg < nmsgs))
2123 #line 496
2124 (
2125 #line 496
2126 env_throw_bi(env, mfe_range, "message_get_part", _("invalid message descriptor"))
2127 #line 496
2128 )
2129 #line 496
2130 ;
2131 #line 496
2132 mp = mtab + nmsg;
2133 #line 496
2134 if (!(mp->msg))
2135 #line 496
2136 (
2137 #line 496
2138 env_throw_bi(env, mfe_failure, "message_get_part", _("message not open"))
2139 #line 496
2140 )
2141 #line 496
2142
2143 #line 496
2144 ;
2145
2146 rc = mu_message_get_part(mp->msg, idx, &msg);
2147 if (!(rc == 0))
2148 #line 499
2149 (
2150 #line 499
2151 env_throw_bi(env, mfe_failure, "message_get_part", "%s",mu_strerror(rc))
2152 #line 499
2153 )
2154 #line 502
2155 ;
2156 rc = bi_message_register(env, mp->msglist, msg, MF_MSG_MAILBOX);
2157 if (!(rc >= 0))
2158 #line 504
2159 (
2160 #line 504
2161 env_throw_bi(env, mfe_failure, "message_get_part", _("no more message slots available"))
2162 #line 504
2163 )
2164 #line 506
2165 ;
2166
2167 #line 507
2168 do {
2169 #line 507
2170 push(env, (STKVAL)(mft_number)(rc));
2171 #line 507
2172 goto endlab;
2173 #line 507
2174 } while (0);
2175 }
2176 endlab:
2177 #line 509
2178 env_function_cleanup_flush(env, NULL);
2179 #line 509
2180 return;
2181 #line 509
2182 }
2183
2184
2185 /* Reading */
2186
2187 /* string message_rewind(number nmsg) */
2188 void
2189 #line 515
bi_message_rewind(eval_environ_t env)2190 bi_message_rewind(eval_environ_t env)
2191 #line 515
2192
2193 #line 515
2194
2195 #line 515 "msg.bi"
2196 {
2197 #line 515
2198
2199 #line 515
2200
2201 #line 515
2202
2203 #line 515
2204 long nmsg;
2205 #line 515
2206
2207 #line 515
2208 get_numeric_arg(env, 0, &nmsg);
2209 #line 515
2210
2211 #line 515
2212
2213 #line 515
2214 adjust_stack(env, 1);
2215 #line 515
2216
2217 #line 515
2218
2219 #line 515
2220 if (builtin_module_trace(BUILTIN_IDX_msg))
2221 #line 515
2222 prog_trace(env, "message_rewind %lu",nmsg);;
2223 #line 515
2224
2225 {
2226
2227 #line 517
2228 struct mf_message *mtab = env_get_builtin_priv(env,MSGTAB_id);
2229 #line 517
2230 struct mf_message *mp;
2231 #line 517
2232
2233 #line 517
2234 if (!(nmsg >= 0 && nmsg < nmsgs))
2235 #line 517
2236 (
2237 #line 517
2238 env_throw_bi(env, mfe_range, "message_rewind", _("invalid message descriptor"))
2239 #line 517
2240 )
2241 #line 517
2242 ;
2243 #line 517
2244 mp = mtab + nmsg;
2245 #line 517
2246 if (!(mp->msg))
2247 #line 517
2248 (
2249 #line 517
2250 env_throw_bi(env, mfe_failure, "message_rewind", _("message not open"))
2251 #line 517
2252 )
2253 #line 517
2254
2255 #line 517
2256 ;
2257 mu_stream_destroy(&mp->mstr);
2258 }
2259
2260 #line 520
2261 env_function_cleanup_flush(env, NULL);
2262 #line 520
2263 return;
2264 #line 520
2265 }
2266
2267 /* string message_read_line(number nmsg) */
2268 void
2269 #line 523
bi_message_read_line(eval_environ_t env)2270 bi_message_read_line(eval_environ_t env)
2271 #line 523
2272
2273 #line 523
2274
2275 #line 523 "msg.bi"
2276 {
2277 #line 523
2278
2279 #line 523
2280
2281 #line 523
2282
2283 #line 523
2284 long nmsg;
2285 #line 523
2286
2287 #line 523
2288 get_numeric_arg(env, 0, &nmsg);
2289 #line 523
2290
2291 #line 523
2292
2293 #line 523
2294 adjust_stack(env, 1);
2295 #line 523
2296
2297 #line 523
2298
2299 #line 523
2300 if (builtin_module_trace(BUILTIN_IDX_msg))
2301 #line 523
2302 prog_trace(env, "message_read_line %lu",nmsg);;
2303 #line 523
2304
2305 {
2306 int rc;
2307 size_t size;
2308
2309 #line 527
2310 struct mf_message *mtab = env_get_builtin_priv(env,MSGTAB_id);
2311 #line 527
2312 struct mf_message *mp;
2313 #line 527
2314
2315 #line 527
2316 if (!(nmsg >= 0 && nmsg < nmsgs))
2317 #line 527
2318 (
2319 #line 527
2320 env_throw_bi(env, mfe_range, "message_read_line", _("invalid message descriptor"))
2321 #line 527
2322 )
2323 #line 527
2324 ;
2325 #line 527
2326 mp = mtab + nmsg;
2327 #line 527
2328 if (!(mp->msg))
2329 #line 527
2330 (
2331 #line 527
2332 env_throw_bi(env, mfe_failure, "message_read_line", _("message not open"))
2333 #line 527
2334 )
2335 #line 527
2336
2337 #line 527
2338 ;
2339
2340 if (!mp->mstr) {
2341 rc = mu_message_get_streamref(mp->msg, &mp->mstr);
2342 if (!(rc == 0))
2343 #line 531
2344 (
2345 #line 531
2346 env_throw_bi(env, mfe_failure, "message_read_line", "mu_message_get_stream: %s",mu_strerror(rc))
2347 #line 531
2348 )
2349 #line 534
2350 ;
2351 }
2352 rc = mu_stream_getline(mp->mstr, &mp->buf, &mp->bufsize, &size);
2353 if (!(rc == 0))
2354 #line 537
2355 (
2356 #line 537
2357 env_throw_bi(env, mfe_io, "message_read_line", "mu_stream_getline: %s",mu_strerror(rc))
2358 #line 537
2359 )
2360 #line 540
2361 ;
2362 if (!(size > 0))
2363 #line 541
2364 (
2365 #line 541
2366 env_throw_bi(env, mfe_eof, "message_read_line", "mu_stream_getline: %s",_("end of input"))
2367 #line 541
2368 )
2369 #line 544
2370 ;
2371
2372 #line 545
2373 do {
2374 #line 545
2375 pushs(env, mp->buf);
2376 #line 545
2377 goto endlab;
2378 #line 545
2379 } while (0);
2380 }
2381 endlab:
2382 #line 547
2383 env_function_cleanup_flush(env, NULL);
2384 #line 547
2385 return;
2386 #line 547
2387 }
2388
2389 /* string message_body_rewind(number nmsg) */
2390 void
2391 #line 550
bi_message_body_rewind(eval_environ_t env)2392 bi_message_body_rewind(eval_environ_t env)
2393 #line 550
2394
2395 #line 550
2396
2397 #line 550 "msg.bi"
2398 {
2399 #line 550
2400
2401 #line 550
2402
2403 #line 550
2404
2405 #line 550
2406 long nmsg;
2407 #line 550
2408
2409 #line 550
2410 get_numeric_arg(env, 0, &nmsg);
2411 #line 550
2412
2413 #line 550
2414
2415 #line 550
2416 adjust_stack(env, 1);
2417 #line 550
2418
2419 #line 550
2420
2421 #line 550
2422 if (builtin_module_trace(BUILTIN_IDX_msg))
2423 #line 550
2424 prog_trace(env, "message_body_rewind %lu",nmsg);;
2425 #line 550
2426
2427 {
2428
2429 #line 552
2430
2431 #line 552
2432 struct mf_message *mtab = env_get_builtin_priv(env,MSGTAB_id);
2433 #line 552
2434 struct mf_message *mp;
2435 #line 552
2436
2437 #line 552
2438 if (!(nmsg >= 0 && nmsg < nmsgs))
2439 #line 552
2440 (
2441 #line 552
2442 env_throw_bi(env, mfe_range, "message_body_rewind", _("invalid message descriptor"))
2443 #line 552
2444 )
2445 #line 552
2446 ;
2447 #line 552
2448 mp = mtab + nmsg;
2449 #line 552
2450 if (!(mp->msg))
2451 #line 552
2452 (
2453 #line 552
2454 env_throw_bi(env, mfe_failure, "message_body_rewind", _("message not open"))
2455 #line 552
2456 )
2457 #line 552
2458
2459 #line 552
2460 ;
2461 #line 552
2462 if (!mp->body) {
2463 #line 552
2464 int rc = mu_message_get_body(mp->msg, &mp->body);
2465 #line 552
2466 if (!(rc == 0))
2467 #line 552
2468 (
2469 #line 552
2470 env_throw_bi(env, mfe_failure, "message_body_rewind", "mu_message_get_body: %s",mu_strerror(rc))
2471 #line 552
2472 )
2473 #line 552
2474 ;
2475 #line 552
2476 }
2477 #line 552
2478 ;
2479 mu_stream_destroy(&mp->bstr);
2480 }
2481
2482 #line 555
2483 env_function_cleanup_flush(env, NULL);
2484 #line 555
2485 return;
2486 #line 555
2487 }
2488
2489 /* string message_read_body_line(number msg) */
2490 void
2491 #line 558
bi_message_read_body_line(eval_environ_t env)2492 bi_message_read_body_line(eval_environ_t env)
2493 #line 558
2494
2495 #line 558
2496
2497 #line 558 "msg.bi"
2498 {
2499 #line 558
2500
2501 #line 558
2502
2503 #line 558
2504
2505 #line 558
2506 long nmsg;
2507 #line 558
2508
2509 #line 558
2510 get_numeric_arg(env, 0, &nmsg);
2511 #line 558
2512
2513 #line 558
2514
2515 #line 558
2516 adjust_stack(env, 1);
2517 #line 558
2518
2519 #line 558
2520
2521 #line 558
2522 if (builtin_module_trace(BUILTIN_IDX_msg))
2523 #line 558
2524 prog_trace(env, "message_read_body_line %lu",nmsg);;
2525 #line 558
2526
2527 {
2528 int rc;
2529 size_t size;
2530
2531 #line 562
2532
2533 #line 562
2534 struct mf_message *mtab = env_get_builtin_priv(env,MSGTAB_id);
2535 #line 562
2536 struct mf_message *mp;
2537 #line 562
2538
2539 #line 562
2540 if (!(nmsg >= 0 && nmsg < nmsgs))
2541 #line 562
2542 (
2543 #line 562
2544 env_throw_bi(env, mfe_range, "message_read_body_line", _("invalid message descriptor"))
2545 #line 562
2546 )
2547 #line 562
2548 ;
2549 #line 562
2550 mp = mtab + nmsg;
2551 #line 562
2552 if (!(mp->msg))
2553 #line 562
2554 (
2555 #line 562
2556 env_throw_bi(env, mfe_failure, "message_read_body_line", _("message not open"))
2557 #line 562
2558 )
2559 #line 562
2560
2561 #line 562
2562 ;
2563 #line 562
2564 if (!mp->body) {
2565 #line 562
2566 int rc = mu_message_get_body(mp->msg, &mp->body);
2567 #line 562
2568 if (!(rc == 0))
2569 #line 562
2570 (
2571 #line 562
2572 env_throw_bi(env, mfe_failure, "message_read_body_line", "mu_message_get_body: %s",mu_strerror(rc))
2573 #line 562
2574 )
2575 #line 562
2576 ;
2577 #line 562
2578 }
2579 #line 562
2580 ;
2581
2582 if (!mp->bstr) {
2583 rc = mu_body_get_streamref(mp->body, &mp->bstr);
2584 if (!(rc == 0))
2585 #line 566
2586 (
2587 #line 566
2588 env_throw_bi(env, mfe_failure, "message_read_body_line", "mu_body_get_stream: %s",mu_strerror(rc))
2589 #line 566
2590 )
2591 #line 569
2592 ;
2593 }
2594 rc = mu_stream_getline(mp->bstr, &mp->buf, &mp->bufsize, &size);
2595 if (!(rc == 0))
2596 #line 572
2597 (
2598 #line 572
2599 env_throw_bi(env, mfe_io, "message_read_body_line", "mu_stream_getline: %s",mu_strerror(rc))
2600 #line 572
2601 )
2602 #line 575
2603 ;
2604 if (!(size > 0))
2605 #line 576
2606 (
2607 #line 576
2608 env_throw_bi(env, mfe_eof, "message_read_body_line", "mu_stream_getline: %s",_("end of input"))
2609 #line 576
2610 )
2611 #line 579
2612 ;
2613
2614 #line 580
2615 do {
2616 #line 580
2617 pushs(env, mp->buf);
2618 #line 580
2619 goto endlab;
2620 #line 580
2621 } while (0);
2622 }
2623 endlab:
2624 #line 582
2625 env_function_cleanup_flush(env, NULL);
2626 #line 582
2627 return;
2628 #line 582
2629 }
2630
2631 /* string message_to_stream(number fd, number msg; string mu_filter_chain) */
2632 void
2633 #line 585
bi_message_to_stream(eval_environ_t env)2634 bi_message_to_stream(eval_environ_t env)
2635 #line 585
2636
2637 #line 585
2638
2639 #line 585 "msg.bi"
2640 {
2641 #line 585
2642
2643 #line 585
2644
2645 #line 585
2646 long __bi_argcnt;
2647 #line 585
2648 long fd;
2649 #line 585
2650 long nmsg;
2651 #line 585
2652 char * fltchain;
2653 #line 585
2654
2655 #line 585
2656 get_numeric_arg(env, 1, &fd);
2657 #line 585
2658 get_numeric_arg(env, 2, &nmsg);
2659 #line 585
2660 get_string_arg(env, 3, &fltchain);
2661 #line 585
2662
2663 #line 585
2664 get_numeric_arg(env, 0, &__bi_argcnt);
2665 #line 585
2666 adjust_stack(env, __bi_argcnt + 1);
2667 #line 585
2668
2669 #line 585
2670
2671 #line 585
2672 if (builtin_module_trace(BUILTIN_IDX_msg))
2673 #line 585
2674 prog_trace(env, "message_to_stream %lu %lu %s",fd, nmsg, ((__bi_argcnt > 2) ? fltchain : ""));;
2675
2676 {
2677 int rc;
2678 int yes = 1;
2679 mu_stream_t dst;
2680 char *flts = ((__bi_argcnt > 2) ? fltchain : 0);
2681
2682
2683 #line 593
2684 struct mf_message *mtab = env_get_builtin_priv(env,MSGTAB_id);
2685 #line 593
2686 struct mf_message *mp;
2687 #line 593
2688
2689 #line 593
2690 if (!(nmsg >= 0 && nmsg < nmsgs))
2691 #line 593
2692 (
2693 #line 593
2694 env_throw_bi(env, mfe_range, "message_to_stream", _("invalid message descriptor"))
2695 #line 593
2696 )
2697 #line 593
2698 ;
2699 #line 593
2700 mp = mtab + nmsg;
2701 #line 593
2702 if (!(mp->msg))
2703 #line 593
2704 (
2705 #line 593
2706 env_throw_bi(env, mfe_failure, "message_to_stream", _("message not open"))
2707 #line 593
2708 )
2709 #line 593
2710
2711 #line 593
2712 ;
2713
2714 rc = mu_fd_stream_create(&dst, NULL, _bi_io_fd(env, fd, 1),
2715 MU_STREAM_WRITE);
2716 if (!(rc == 0))
2717 #line 597
2718 (
2719 #line 597
2720 env_throw_bi(env, mfe_failure, "message_to_stream", "mu_fd_stream_create: %s",mu_strerror(rc))
2721 #line 597
2722 )
2723 #line 600
2724 ;
2725 mu_stream_ioctl(dst, MU_IOCTL_FD, MU_IOCTL_FD_SET_BORROW, &yes);
2726 if (flts) {
2727 struct mu_wordsplit ws;
2728 mu_stream_t flt;
2729
2730 rc = mu_wordsplit(flts, &ws, MU_WRDSF_DEFFLAGS);
2731 if (!(rc == 0))
2732 #line 607
2733 (
2734 #line 607
2735 env_throw_bi(env, mfe_failure, "message_to_stream", "mu_wordsplit: %s",mu_wordsplit_strerror(&ws))
2736 #line 607
2737 )
2738 #line 610
2739 ;
2740 rc = mu_filter_chain_create(&flt, dst, MU_FILTER_ENCODE,
2741 MU_STREAM_WRITE,
2742 ws.ws_wordc, ws.ws_wordv);
2743 mu_wordsplit_free(&ws);
2744 if (!(rc == 0))
2745 #line 615
2746 (
2747 #line 615
2748 env_throw_bi(env, mfe_failure, "message_to_stream", "mu_filter_chain_create(\"%s\"): %s",flts,mu_strerror(rc))
2749 #line 615
2750 )
2751 #line 619
2752 ;
2753 mu_stream_unref(dst);
2754 dst = flt;
2755 }
2756
2757 if (!mp->mstr) {
2758 rc = mu_message_get_streamref(mp->msg, &mp->mstr);
2759 if (!(rc == 0))
2760 #line 626
2761 (
2762 #line 626
2763 env_throw_bi(env, mfe_failure, "message_to_stream", "mu_message_get_stream: %s",mu_strerror(rc))
2764 #line 626
2765 )
2766 #line 629
2767 ;
2768 }
2769 rc = mu_stream_copy(dst, mp->mstr, 0, NULL);
2770 if (!(rc == 0))
2771 #line 632
2772 (
2773 #line 632
2774 env_throw_bi(env, mfe_failure, "message_to_stream", "mu_stream_copy: %s",mu_strerror(rc))
2775 #line 632
2776 )
2777 #line 635
2778 ;
2779 mu_stream_close(dst);
2780 mu_stream_unref(dst);
2781 }
2782
2783 #line 639
2784 env_function_cleanup_flush(env, NULL);
2785 #line 639
2786 return;
2787 #line 639
2788 }
2789
2790 /* number message_from_stream(number fd; string mu_filter_chain) */
2791 void
2792 #line 642
bi_message_from_stream(eval_environ_t env)2793 bi_message_from_stream(eval_environ_t env)
2794 #line 642
2795
2796 #line 642
2797
2798 #line 642 "msg.bi"
2799 {
2800 #line 642
2801
2802 #line 642
2803
2804 #line 642
2805 long __bi_argcnt;
2806 #line 642
2807 long fd;
2808 #line 642
2809 char * fltchain;
2810 #line 642
2811
2812 #line 642
2813 get_numeric_arg(env, 1, &fd);
2814 #line 642
2815 get_string_arg(env, 2, &fltchain);
2816 #line 642
2817
2818 #line 642
2819 get_numeric_arg(env, 0, &__bi_argcnt);
2820 #line 642
2821 adjust_stack(env, __bi_argcnt + 1);
2822 #line 642
2823
2824 #line 642
2825
2826 #line 642
2827 if (builtin_module_trace(BUILTIN_IDX_msg))
2828 #line 642
2829 prog_trace(env, "message_from_stream %lu %s",fd, ((__bi_argcnt > 1) ? fltchain : ""));;
2830
2831 {
2832 int rc;
2833 int yes = 1;
2834 mu_stream_t src;
2835 char *flts = ((__bi_argcnt > 1) ? fltchain : 0);
2836 mu_message_t msg;
2837
2838 rc = mu_fd_stream_create(&src, NULL, _bi_io_fd(env, fd, 0),
2839 MU_STREAM_READ|MU_STREAM_SEEK);
2840
2841 if (!(rc == 0))
2842 #line 654
2843 (
2844 #line 654
2845 env_throw_bi(env, mfe_failure, "message_from_stream", "mu_fd_stream_create: %s",mu_strerror(rc))
2846 #line 654
2847 )
2848 #line 657
2849 ;
2850 mu_stream_ioctl(src, MU_IOCTL_FD, MU_IOCTL_FD_SET_BORROW, &yes);
2851 if (flts) {
2852 struct mu_wordsplit ws;
2853 mu_stream_t flt;
2854
2855 rc = mu_wordsplit(flts, &ws, MU_WRDSF_DEFFLAGS);
2856 if (!(rc == 0))
2857 #line 664
2858 (
2859 #line 664
2860 env_throw_bi(env, mfe_failure, "message_from_stream", "mu_wordsplit: %s",mu_wordsplit_strerror(&ws))
2861 #line 664
2862 )
2863 #line 667
2864 ;
2865 rc = mu_filter_chain_create(&flt, src, MU_FILTER_ENCODE,
2866 MU_STREAM_READ,
2867 ws.ws_wordc, ws.ws_wordv);
2868 mu_wordsplit_free(&ws);
2869 if (!(rc == 0))
2870 #line 672
2871 (
2872 #line 672
2873 env_throw_bi(env, mfe_failure, "message_from_stream", "mu_filter_chain_create(\"%s\"): %s",flts,mu_strerror(rc))
2874 #line 672
2875 )
2876 #line 676
2877 ;
2878 mu_stream_unref(src);
2879 src = flt;
2880 }
2881
2882 msg = _builtin_mu_stream_to_message(src, env, "message_from_stream");
2883
2884 rc = bi_message_register(env, NULL, msg, MF_MSG_STANDALONE);
2885 if (rc < 0) {
2886 mu_message_destroy(&msg, mu_message_get_owner(msg));
2887 (
2888 #line 686
2889 env_throw_bi(env, mfe_failure, "message_from_stream", _("no more message slots available"))
2890 #line 686
2891 );
2892 #line 688
2893 }
2894
2895 #line 689
2896 do {
2897 #line 689
2898 push(env, (STKVAL)(mft_number)(rc));
2899 #line 689
2900 goto endlab;
2901 #line 689
2902 } while (0);
2903 }
2904 endlab:
2905 #line 691
2906 env_function_cleanup_flush(env, NULL);
2907 #line 691
2908 return;
2909 #line 691
2910 }
2911
2912 /* string message_body_to_stream(number fd, number msg; string mu_filter_chain) */
2913 void
2914 #line 694
bi_message_body_to_stream(eval_environ_t env)2915 bi_message_body_to_stream(eval_environ_t env)
2916 #line 694
2917
2918 #line 694
2919
2920 #line 694 "msg.bi"
2921 {
2922 #line 694
2923
2924 #line 694
2925
2926 #line 694
2927 long __bi_argcnt;
2928 #line 694
2929 long fd;
2930 #line 694
2931 long nmsg;
2932 #line 694
2933 char * fltchain;
2934 #line 694
2935
2936 #line 694
2937 get_numeric_arg(env, 1, &fd);
2938 #line 694
2939 get_numeric_arg(env, 2, &nmsg);
2940 #line 694
2941 get_string_arg(env, 3, &fltchain);
2942 #line 694
2943
2944 #line 694
2945 get_numeric_arg(env, 0, &__bi_argcnt);
2946 #line 694
2947 adjust_stack(env, __bi_argcnt + 1);
2948 #line 694
2949
2950 #line 694
2951
2952 #line 694
2953 if (builtin_module_trace(BUILTIN_IDX_msg))
2954 #line 694
2955 prog_trace(env, "message_body_to_stream %lu %lu %s",fd, nmsg, ((__bi_argcnt > 2) ? fltchain : ""));;
2956
2957 {
2958 int rc;
2959 int yes = 1;
2960 mu_stream_t dst;
2961 char *flts = ((__bi_argcnt > 2) ? fltchain : 0);
2962
2963
2964 #line 702
2965
2966 #line 702
2967 struct mf_message *mtab = env_get_builtin_priv(env,MSGTAB_id);
2968 #line 702
2969 struct mf_message *mp;
2970 #line 702
2971
2972 #line 702
2973 if (!(nmsg >= 0 && nmsg < nmsgs))
2974 #line 702
2975 (
2976 #line 702
2977 env_throw_bi(env, mfe_range, "message_body_to_stream", _("invalid message descriptor"))
2978 #line 702
2979 )
2980 #line 702
2981 ;
2982 #line 702
2983 mp = mtab + nmsg;
2984 #line 702
2985 if (!(mp->msg))
2986 #line 702
2987 (
2988 #line 702
2989 env_throw_bi(env, mfe_failure, "message_body_to_stream", _("message not open"))
2990 #line 702
2991 )
2992 #line 702
2993
2994 #line 702
2995 ;
2996 #line 702
2997 if (!mp->body) {
2998 #line 702
2999 int rc = mu_message_get_body(mp->msg, &mp->body);
3000 #line 702
3001 if (!(rc == 0))
3002 #line 702
3003 (
3004 #line 702
3005 env_throw_bi(env, mfe_failure, "message_body_to_stream", "mu_message_get_body: %s",mu_strerror(rc))
3006 #line 702
3007 )
3008 #line 702
3009 ;
3010 #line 702
3011 }
3012 #line 702
3013 ;
3014
3015 rc = mu_fd_stream_create(&dst, NULL, _bi_io_fd(env, fd, 1),
3016 MU_STREAM_WRITE);
3017 if (!(rc == 0))
3018 #line 706
3019 (
3020 #line 706
3021 env_throw_bi(env, mfe_failure, "message_body_to_stream", "mu_fd_stream_create: %s",mu_strerror(rc))
3022 #line 706
3023 )
3024 #line 709
3025 ;
3026 mu_stream_ioctl(dst, MU_IOCTL_FD, MU_IOCTL_FD_SET_BORROW, &yes);
3027 if (flts) {
3028 struct mu_wordsplit ws;
3029 mu_stream_t flt;
3030
3031 rc = mu_wordsplit(flts, &ws, MU_WRDSF_DEFFLAGS);
3032 if (!(rc == 0))
3033 #line 716
3034 (
3035 #line 716
3036 env_throw_bi(env, mfe_failure, "message_body_to_stream", "mu_wordsplit: %s",mu_wordsplit_strerror(&ws))
3037 #line 716
3038 )
3039 #line 719
3040 ;
3041 rc = mu_filter_chain_create(&flt, dst, MU_FILTER_ENCODE,
3042 MU_STREAM_WRITE,
3043 ws.ws_wordc, ws.ws_wordv);
3044 mu_wordsplit_free(&ws);
3045 if (!(rc == 0))
3046 #line 724
3047 (
3048 #line 724
3049 env_throw_bi(env, mfe_failure, "message_body_to_stream", "mu_filter_chain_create(\"%s\"): %s",flts,mu_strerror(rc))
3050 #line 724
3051 )
3052 #line 728
3053 ;
3054 mu_stream_unref(dst);
3055 dst = flt;
3056 }
3057
3058 if (!mp->bstr) {
3059 rc = mu_body_get_streamref(mp->body, &mp->bstr);
3060 if (!(rc == 0))
3061 #line 735
3062 (
3063 #line 735
3064 env_throw_bi(env, mfe_failure, "message_body_to_stream", "mu_body_get_stream: %s",mu_strerror(rc))
3065 #line 735
3066 )
3067 #line 738
3068 ;
3069 }
3070 rc = mu_stream_copy(dst, mp->bstr, 0, NULL);
3071 if (!(rc == 0))
3072 #line 741
3073 (
3074 #line 741
3075 env_throw_bi(env, mfe_failure, "message_body_to_stream", "mu_stream_copy: %s",mu_strerror(rc))
3076 #line 741
3077 )
3078 #line 744
3079 ;
3080 mu_stream_close(dst);
3081 mu_stream_unref(dst);
3082 }
3083
3084 #line 748
3085 env_function_cleanup_flush(env, NULL);
3086 #line 748
3087 return;
3088 #line 748
3089 }
3090
3091
3092 #line 982 "../../src/builtin/snarf.m4"
3093
3094 #line 982
3095
3096 #line 982
3097
3098 #line 982
3099 void
3100 #line 982
msg_init_builtin(void)3101 msg_init_builtin(void)
3102 #line 982
3103 {
3104 #line 982
3105
3106 #line 982
3107 #line 59 "msg.bi"
3108 MSGTAB_id = builtin_priv_register(alloc_msgs, destroy_msgs,
3109 #line 59
3110 drop_current_message);
3111 #line 202 "msg.bi"
3112 va_builtin_install_ex("message_close", bi_message_close, 0, dtype_unspecified, 1, 0, 0|0, dtype_number);
3113 #line 210 "msg.bi"
3114 va_builtin_install_ex("message_size", bi_message_size, 0, dtype_number, 1, 0, 0|0, dtype_number);
3115 #line 228 "msg.bi"
3116 va_builtin_install_ex("message_lines", bi_message_lines, 0, dtype_number, 1, 0, 0|0, dtype_number);
3117 #line 244 "msg.bi"
3118 va_builtin_install_ex("message_body_size", bi_message_body_size, 0, dtype_number, 1, 0, 0|0, dtype_number);
3119 #line 262 "msg.bi"
3120 va_builtin_install_ex("message_body_is_empty", bi_message_body_is_empty, 0, dtype_number, 1, 0, 0|0, dtype_number);
3121 #line 313 "msg.bi"
3122 va_builtin_install_ex("message_body_lines", bi_message_body_lines, 0, dtype_number, 1, 0, 0|0, dtype_number);
3123 #line 332 "msg.bi"
3124 va_builtin_install_ex("message_header_size", bi_message_header_size, 0, dtype_number, 1, 0, 0|0, dtype_number);
3125 #line 350 "msg.bi"
3126 va_builtin_install_ex("message_header_lines", bi_message_header_lines, 0, dtype_number, 1, 0, 0|0, dtype_number);
3127 #line 366 "msg.bi"
3128 va_builtin_install_ex("message_header_count", bi_message_header_count, 0, dtype_number, 2, 1, 0|0, dtype_number, dtype_string);
3129 #line 397 "msg.bi"
3130 va_builtin_install_ex("message_has_header", bi_message_has_header, 0, dtype_number, 3, 1, 0|0, dtype_number, dtype_string, dtype_number);
3131 #line 410 "msg.bi"
3132 va_builtin_install_ex("message_find_header", bi_message_find_header, 0, dtype_string, 3, 1, 0|0, dtype_number, dtype_string, dtype_number);
3133 #line 427 "msg.bi"
3134 va_builtin_install_ex("message_nth_header_name", bi_message_nth_header_name, 0, dtype_string, 2, 0, 0|0, dtype_number, dtype_number);
3135 #line 443 "msg.bi"
3136 va_builtin_install_ex("message_nth_header_value", bi_message_nth_header_value, 0, dtype_string, 2, 0, 0|0, dtype_number, dtype_number);
3137 #line 462 "msg.bi"
3138 va_builtin_install_ex("message_is_multipart", bi_message_is_multipart, 0, dtype_number, 1, 0, 0|0, dtype_number);
3139 #line 477 "msg.bi"
3140 va_builtin_install_ex("message_count_parts", bi_message_count_parts, 0, dtype_number, 1, 0, 0|0, dtype_number);
3141 #line 492 "msg.bi"
3142 va_builtin_install_ex("message_get_part", bi_message_get_part, 0, dtype_number, 2, 0, 0|0, dtype_number, dtype_number);
3143 #line 515 "msg.bi"
3144 va_builtin_install_ex("message_rewind", bi_message_rewind, 0, dtype_unspecified, 1, 0, 0|0, dtype_number);
3145 #line 523 "msg.bi"
3146 va_builtin_install_ex("message_read_line", bi_message_read_line, 0, dtype_string, 1, 0, 0|0, dtype_number);
3147 #line 550 "msg.bi"
3148 va_builtin_install_ex("message_body_rewind", bi_message_body_rewind, 0, dtype_unspecified, 1, 0, 0|0, dtype_number);
3149 #line 558 "msg.bi"
3150 va_builtin_install_ex("message_read_body_line", bi_message_read_body_line, 0, dtype_string, 1, 0, 0|0, dtype_number);
3151 #line 585 "msg.bi"
3152 va_builtin_install_ex("message_to_stream", bi_message_to_stream, 0, dtype_unspecified, 3, 1, 0|0, dtype_number, dtype_number, dtype_string);
3153 #line 642 "msg.bi"
3154 va_builtin_install_ex("message_from_stream", bi_message_from_stream, 0, dtype_number, 2, 1, 0|0, dtype_number, dtype_string);
3155 #line 694 "msg.bi"
3156 va_builtin_install_ex("message_body_to_stream", bi_message_body_to_stream, 0, dtype_unspecified, 3, 1, 0|0, dtype_number, dtype_number, dtype_string);
3157
3158 #line 982 "../../src/builtin/snarf.m4"
3159
3160 #line 982
3161 mf_add_runtime_params(msg_cfg_param);
3162 #line 982
3163
3164 #line 982
3165 }
3166 #line 982 "../../src/builtin/snarf.m4"
3167
3168