perl(k): fix mk_action call
[sip-router] / modules_k / perl / openserxs.xs
1 /*
2  * $Id$
3  *
4  * Perl module for OpenSER
5  *
6  * Copyright (C) 2006 Collax GmbH
7  *                    (Bastian Friedrich <bastian.friedrich@collax.com>)
8  *
9  * This file is part of openser, a free SIP server.
10  *
11  * openser is free software; you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License as published by
13  * the Free Software Foundation; either version 2 of the License, or
14  * (at your option) any later version
15  *
16  * openser is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software
23  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
24  *
25  */
26
27 #include <EXTERN.h>
28 #include <perl.h>
29 #include <XSUB.h>
30 #include <unistd.h>
31 #undef load_module
32
33 /* perl.h defines union semun */
34 #ifdef USE_SYSV_SEM
35 # undef _SEM_SEMUN_UNDEFINED
36 #endif
37
38 #include "../../sr_module.h"
39 #include "../../parser/msg_parser.h"
40 #include "../../parser/parse_uri.h"
41 #include "../../usr_avp.h"
42 #include "../../action.h"
43 #include "../../flags.h"
44 #include "../../pvar.h"
45 #include "../../dset.h"
46 #include "../../mem/mem.h"
47 #include "../../route_struct.h"
48 #include "../../qvalue.h"
49 #include "../../dprint.h"
50
51 extern int unsafemodfnc;
52
53 enum xs_uri_members {
54         XS_URI_USER = 0,
55         XS_URI_PASSWD,
56         XS_URI_HOST,
57         XS_URI_PORT,
58         XS_URI_PARAMS,
59         XS_URI_HEADERS,
60         XS_URI_TRANSPORT,
61         XS_URI_TTL,
62         XS_URI_USER_PARAM,
63         XS_URI_MADDR,
64         XS_URI_METHOD,
65         XS_URI_LR,
66         XS_URI_R2,
67         XS_URI_TRANSPORT_VAL,
68         XS_URI_TTL_VAL,
69         XS_URI_USER_PARAM_VAL,
70         XS_URI_MADDR_VAL,
71         XS_URI_METHOD_VAL,
72         XS_URI_LR_VAL,
73         XS_URI_R2_VAL
74         
75         /* These members are no strings:
76                 unsigned short port_no;
77         unsigned short proto; / * from transport * /
78         uri_type type; / * uri scheme */
79 };
80
81 /*
82  * Return the sip_msg struct referred to by perl reference sv
83  */
84 struct sip_msg * sv2msg(SV *sv) {
85         struct sip_msg* m;
86         if (SvROK(sv)) {
87                 sv = SvRV(sv);
88                 if (SvIOK(sv)) {
89                         m = INT2PTR(struct sip_msg*, SvIV(sv));
90                         return m;
91                 }
92         }
93         return NULL; /* In case of error above... */
94 }
95
96 struct sip_uri * sv2uri(SV *sv) {
97         struct sip_uri* u;
98         if (SvROK(sv)) {
99                 sv = SvRV(sv);
100                 if (SvIOK(sv)) {
101                         u = INT2PTR(struct sip_uri*, SvIV(sv));
102                         return u;
103                 }
104         }
105         return NULL; /* In case of error above... */
106 }
107
108 struct action * sv2action(SV *sv) {
109         struct action* a;
110         if (SvROK(sv)) {
111                 sv = SvRV(sv);
112                 if (SvIOK(sv)) {
113                         a = INT2PTR(struct action*, SvIV(sv));
114                         return a;
115                 }
116         }
117         return NULL; /* In case of error above... */
118 }
119
120 /*
121  * We have a private function for two reasons:
122  * a) Return SIP_INVALID even if type was sth different
123  * b) easy access
124  */
125
126 inline static int getType(struct sip_msg *msg) {
127         int t = SIP_INVALID;
128
129         if (!msg) return SIP_INVALID;
130
131         switch ((msg->first_line).type) {
132                 case SIP_REQUEST:       t = SIP_REQUEST; break;
133                 case SIP_REPLY:         t = SIP_REPLY; break;
134         }
135         return t;
136 }
137                 
138
139 SV *getStringFromURI(SV *self, enum xs_uri_members what) {
140         struct sip_uri *myuri = sv2uri(self);
141         str *ret = NULL;
142
143         if (!myuri) {
144                 LM_ERR("Invalid URI reference\n");
145                 ret = NULL;
146         } else {
147                 
148                 switch (what) {
149                         case XS_URI_USER:       ret = &(myuri->user);
150                                                 break;
151                         case XS_URI_HOST:       ret = &(myuri->host);
152                                                 break;
153                         case XS_URI_PASSWD:     ret = &(myuri->passwd);
154                                                 break;
155                         case XS_URI_PORT:       ret = &(myuri->port);
156                                                 break;
157                         case XS_URI_PARAMS:     ret = &(myuri->params);
158                                                 break;
159                         case XS_URI_HEADERS:    ret = &(myuri->headers);
160                                                 break;
161                         case XS_URI_TRANSPORT:  ret = &(myuri->transport);
162                                                 break;
163                         case XS_URI_TTL:                ret = &(myuri->ttl);
164                                                 break;
165                         case XS_URI_USER_PARAM: ret = &(myuri->user_param);
166                                                 break;
167                         case XS_URI_MADDR:      ret = &(myuri->maddr);
168                                                 break;
169                         case XS_URI_METHOD:     ret = &(myuri->method);
170                                                 break;
171                         case XS_URI_LR:         ret = &(myuri->lr);
172                                                 break;
173                         case XS_URI_R2:         ret = &(myuri->r2);
174                                                 break;
175                         case XS_URI_TRANSPORT_VAL:      ret = &(myuri->transport_val);
176                                                 break;
177                         case XS_URI_TTL_VAL:    ret = &(myuri->ttl_val);
178                                                 break;
179                         case XS_URI_USER_PARAM_VAL:     ret = &(myuri->user_param_val);
180                                                 break;
181                         case XS_URI_MADDR_VAL:  ret = &(myuri->maddr_val);
182                                                 break;
183                         case XS_URI_METHOD_VAL: ret = &(myuri->method_val);
184                                                 break;
185                         case XS_URI_LR_VAL:     ret = &(myuri->lr_val);
186                                                 break;
187                         case XS_URI_R2_VAL:     ret = &(myuri->r2_val);
188                                                 break;
189
190                         default:        LM_INFO("Unknown URI element"
191                                                 " requested: %d\n", what);
192                                         break;
193                 }
194         }
195
196         if ((ret) && (ret->len)) {
197                 return sv_2mortal(newSVpv(ret->s, ret->len));
198         } else {
199                 return &PL_sv_undef;
200         }
201 }
202
203
204
205 /*
206  * Calls an exported function. Parameters are copied and fixup'd.
207  *
208  * Return codes:
209  *   -1 - Function not available (or other error).
210  *    1 - Function was called. Its return value is returned via the retval
211  *        parameter.
212  */
213
214 int moduleFunc(struct sip_msg *m, char *func,
215                char *param1, char *param2,
216                int *retval) {
217
218     union cmd_export_u* exp_func_struct;
219         struct action *act;
220         unsigned mod_ver;
221         char *argv[2];
222         int argc = 0;
223         struct run_act_ctx ra_ctx;
224
225         if (!func) {
226                 LM_ERR("moduleFunc called with null function name. Error.");
227                 return -1;
228         }
229
230         if ((!param1) && param2) {
231                 LM_ERR("moduleFunc called with parameter 1 UNSET and"
232                            " parameter 2 SET. Error.");
233                 return -1;
234         }
235
236
237         if (param1) {
238                 argv[0] = (char *)pkg_malloc(strlen(param1)+1);
239                 strcpy(argv[0], param1);
240                 argc++;
241         } else {
242                 argv[0] = NULL;
243         }
244
245         if (param2) {
246                 argv[1] = (char *)pkg_malloc(strlen(param2)+1);
247                 strcpy(argv[1], param2);
248                 argc++;
249         } else {
250                 argv[1] = NULL;
251         }
252
253         exp_func_struct = find_export_record(func, argc, 0, &mod_ver);
254         if (!exp_func_struct || mod_ver < 1) {
255                 LM_ERR("function '%s' called, but not available.", func);
256                 *retval = -1;
257                 if (argv[0]) pkg_free(argv[0]);
258                 if (argv[1]) pkg_free(argv[1]);
259                 return -1;
260         }
261
262         act = mk_action(MODULE_T, 4 /* number of (type, value) pairs */,
263                                         MODEXP_ST, exp_func_struct, /* function */
264                                         NUMBER_ST, 2,  /* parameter number */
265                                         STRING_ST, argv[0], /* param. 1 */
266                                         STRING_ST, argv[1]  /* param. 2 */
267                         );
268
269
270         if (!act) {
271                 LM_ERR("action structure could not be created. Error.");
272                 if (argv[0]) pkg_free(argv[0]);
273                 if (argv[1]) pkg_free(argv[1]);
274                 return -1;
275         }
276
277
278         if (exp_func_struct->v1.fixup) {
279                 if (!unsafemodfnc) {
280                         LM_ERR("Module function '%s' is unsafe. Call is refused.\n", func);
281                         if (argv[0]) pkg_free(argv[0]);
282                         if (argv[1]) pkg_free(argv[1]);
283                         *retval = -1;
284                         return -1;
285                 }
286
287                 if (argc>=2) {
288                         *retval = exp_func_struct->v1.fixup(&(act->val[2].u.data), 2);
289                         if (*retval < 0) {
290                                 LM_ERR("Error in fixup (2)\n");
291                                 return -1;
292                         }
293                         act->val[2].type = MODFIXUP_ST;
294                 }
295                 if (argc>=1) {
296                         *retval = exp_func_struct->v1.fixup(&(act->val[1].u.data), 1);
297                         if (*retval < 0) {
298                                 LM_ERR("Error in fixup (1)\n");
299                                 return -1;
300                         }
301                         act->val[1].type = MODFIXUP_ST;
302                 }
303                 if (argc==0) {
304                         *retval = exp_func_struct->v1.fixup(0, 0);
305                         if (*retval < 0) {
306                                 LM_ERR("Error in fixup (0)\n");
307                                 return -1;
308                         }
309                 }
310         }
311
312         init_run_actions_ctx(&ra_ctx);
313         *retval = do_action(&ra_ctx, act, m);
314
315         if ((act->val[2].type == MODFIXUP_ST) && (act->val[2].u.data)) {
316                 /* pkg_free(act->elem[2].u.data); */
317                 LM_WARN("moduleFunction: A fixup function was called. "
318                                 "This currently creates a memory leak.\n");
319         }
320
321         if ((act->val[1].type == MODFIXUP_ST) && (act->val[1].u.data)) {
322                 /* pkg_free(act->elem[1].u.data); */
323                 LM_WARN("moduleFunction: A fixup function was called. "
324                                 "This currently creates a memory leak.\n");
325         }
326
327         if (argv[0]) pkg_free(argv[0]);
328         if (argv[1]) pkg_free(argv[1]);
329
330         pkg_free(act);
331         
332         return 1;
333 }
334
335
336 /**
337  * Rewrite Request-URI
338  */
339 static inline int rewrite_ruri(struct sip_msg* _m, char* _s)
340 {
341         struct action act;
342         struct run_act_ctx ra_ctx;
343
344         act.type = SET_URI_T;
345         act.val[0].type = STRING_ST;
346         act.val[0].u.string = _s;
347         act.next = 0;
348
349         init_run_actions_ctx(&ra_ctx);  
350         if (do_action(&ra_ctx, &act, _m) < 0)
351         {
352                 LM_ERR("rewrite_ruri: Error in do_action\n");
353                 return -1;
354         }
355         return 0;
356 }
357
358
359 /**
360  * Compile a string with pseudo variables substituted by their values.
361  * A string buffer is allocated. Deallocate afterwards!
362  */
363 char *pv_sprintf(struct sip_msg *m, char *fmt) {
364         int buf_size = 4096;
365         pv_elem_t *model;
366         str s;
367         char *out = (char *)pkg_malloc(buf_size);
368         char *ret = NULL;
369
370         if (!out) {
371                 LM_ERR("pv_sprintf: Memory exhausted!\n");
372                 return NULL;
373         }
374
375         s.s = fmt; s.len = strlen(s.s);
376         if(pv_parse_format(&s, &model) < 0) {
377                 LM_ERR("pv_sprintf: ERROR: wrong format[%s]!\n",
378                         fmt);
379                 return NULL;
380         }
381
382         if(pv_printf(m, model, out, &buf_size) < 0) {
383                 ret = NULL;
384         } else {
385                 ret = strdup(out);
386         }
387
388         pv_elem_free_all(model);
389         pkg_free(out);
390
391         return ret;
392 }
393
394 /**
395  * Convert an SV to an int_str struct. Needed in AVP package.
396  * - val: SV to convert.
397  * - is: pointer to resulting int_str
398  * - flags: pointer to flags to set
399  * - strflag: flag mask to be or-applied for string match
400  */
401
402 inline int sv2int_str(SV *val, int_str *is,
403                       unsigned short *flags, unsigned short strflag) {
404         char *s;
405         STRLEN len;
406
407         if (!SvOK(val)) {
408                 LM_ERR("AVP:sv2int_str: Invalid value "
409                         "(not a scalar).\n");
410                 return 0;
411         }
412         
413         if (SvIOK(val)) { /* numerical name */
414                 is->n = SvIV(val);
415                 *flags = 0;
416                 return 1;
417         } else if (SvPOK(val)) {
418                 s = SvPV(val, len);
419                 is->s.len = len;
420                 is->s.s = s;
421                 (*flags) |= strflag;
422                 return 1;
423         } else {
424                 LM_ERR("AVP:sv2int_str: Invalid value "
425                         "(neither string nor integer).\n");
426                 return 0;
427         }
428 }
429
430 /* ************************************************************************ */
431 /* Object methods begin here */
432
433 =head1 OpenSER
434
435 This module provides access to a limited number of OpenSER core functions.
436 As the most interesting functions deal with SIP messages, they are located
437 in the OpenSER::Message class below.
438
439 =cut
440
441 MODULE = OpenSER PACKAGE = OpenSER
442
443 =head2 log(level,message)
444
445 Logs the message with OpenSER's logging facility. The logging level
446 is one of the following:
447
448  * L_ALERT
449  * L_CRIT
450  * L_ERR
451  * L_WARN
452  * L_NOTICE
453  * L_INFO
454  * L_DBG
455
456 Please note that this method is I<NOT> automatically exported, as it collides
457 with the perl function log (which calculates the logarithm). Either explicitly
458 import the function (via C<use OpenSER qw ( log );>), or call it with its full
459 name:
460
461  OpenSER::log(L_INFO, "foobar");
462
463 =cut
464
465 void
466 log(level, log)
467     int level
468     char *log
469   PREINIT:
470   INIT:
471   CODE:
472         switch (level) {
473         case L_ALERT:   LM_ALERT("%s", log); break;
474         case L_CRIT:    LM_CRIT("%s", log); break;
475         case L_ERR:     LM_ERR("%s", log); break;
476         case L_WARN:    LM_WARN("%s", log); break;
477         case L_NOTICE:  LM_NOTICE("%s", log); break;
478         case L_INFO:    LM_INFO("%s", log); break;
479         default:        LM_DBG("%s", log); break;
480         }
481   OUTPUT:
482
483
484
485 MODULE = OpenSER PACKAGE = OpenSER::Message
486
487 PROTOTYPES: ENABLE
488
489 =head1 OpenSER::Message
490
491 This package provides access functions for an OpenSER C<sip_msg> structure and
492 its sub-components. Through its means it is possible to fully configure
493 alternative routing decisions.
494
495 =cut
496
497 =head2 getType()
498
499 Returns one of the constants SIP_REQUEST, SIP_REPLY, SIP_INVALID stating the
500 type of the current message.
501
502 =cut
503
504 int
505 getType(self)
506     SV *self
507   PREINIT:
508     struct sip_msg *msg = sv2msg(self);
509   INIT:
510   CODE:
511         RETVAL = getType(msg);
512   OUTPUT:
513         RETVAL
514         
515         
516
517 =head2 getStatus()
518
519 Returns the status code of the current Reply message. This function is invalid
520 in Request context!
521
522 =cut
523
524 SV *
525 getStatus(self)
526     SV *self
527   PREINIT:
528     struct sip_msg *msg = sv2msg(self);
529     str *ret;
530   INIT:
531   CODE:
532         if (!msg) {
533                 LM_ERR("Invalid message reference\n");
534                 ST(0) = &PL_sv_undef;
535         } else {
536                 if (getType(msg) != SIP_REPLY) {
537                         LM_ERR("getStatus: Status not available in"
538                                 " non-reply messages.");
539                         ST(0) = &PL_sv_undef;
540                 } else {
541                         ret = &((msg->first_line).u.reply.status);
542                         ST(0) = sv_2mortal(newSVpv(ret->s, ret->len));
543                 }
544         }
545
546
547 =head2 getReason()
548
549 Returns the reason of the current Reply message. This function is invalid
550 in Request context!
551
552 =cut
553
554 SV *
555 getReason(self)
556     SV *self
557   PREINIT:
558     struct sip_msg *msg = sv2msg(self);
559     str *ret;
560   INIT:
561   CODE:
562         if (!msg) {
563                 LM_ERR("Invalid message reference\n");
564                 ST(0) = &PL_sv_undef;
565         } else {
566                 if (getType(msg) != SIP_REPLY) {
567                         LM_ERR("getReason: Reason not available in"
568                                 " non-reply messages.");
569                         ST(0) = &PL_sv_undef;
570                 } else {
571                         ret = &((msg->first_line).u.reply.reason);
572                         ST(0) = sv_2mortal(newSVpv(ret->s, ret->len));
573                 }
574         }
575
576
577 =head2 getVersion()
578
579 Returns the version string of the current SIP message.
580
581 =cut
582
583 SV *
584 getVersion(self)
585     SV *self
586   PREINIT:
587     struct sip_msg *msg = sv2msg(self);
588     str *ret;
589   INIT:
590   CODE:
591         if (!msg) {
592                 LM_ERR("Invalid message reference\n");
593                 ST(0) = &PL_sv_undef;
594         } else {
595                 if (getType(msg) == SIP_REQUEST) {
596                         ret = &((msg->first_line).u.request.version);
597                 } else { /* SIP_REPLY */
598                         ret = &((msg->first_line).u.reply.version);
599                 }
600                 ST(0) = sv_2mortal(newSVpv(ret->s, ret->len));
601         }
602
603
604 =head2 getRURI()
605
606 This function returns the recipient URI of the present SIP message:
607
608 C<< my $ruri = $m->getRURI(); >>
609
610 getRURI returns a string. See L</"getParsedRURI()"> below how to receive a
611 parsed structure.
612
613 This function is valid in request messages only.
614
615 =cut
616
617 SV *
618 getRURI(self)
619     SV *self
620   PREINIT:
621     struct sip_msg *msg = sv2msg(self);
622     str *ret;
623   INIT:
624   CODE:
625         if (!msg) {
626                 LM_ERR("Invalid message reference\n");
627                 ST(0) = &PL_sv_undef;
628         } else {
629                 if (getType(msg) != SIP_REQUEST) {
630                         LM_ERR("Not a request message - "
631                                 "no RURI available.\n");
632                         ST(0) = &PL_sv_undef;
633                 } else {
634                         ret = &((msg->first_line).u.request.uri);
635                         ST(0) = sv_2mortal(newSVpv(ret->s, ret->len));
636                 }
637         }
638
639
640 =head2 getMethod()
641
642 Returns the current method, such as C<INVITE>, C<REGISTER>, C<ACK> and so on.
643
644 C<< my $method = $m->getMethod(); >>
645
646 This function is valid in request messages only.
647
648 =cut
649
650 char *
651 getMethod(self)
652     SV *self
653   PREINIT:
654     struct sip_msg *msg = sv2msg(self);
655     str *ret;
656   INIT:
657   CODE:
658         if (!msg) {
659                 LM_ERR("Invalid message reference\n");
660                 ST(0) = &PL_sv_undef;
661         } else {
662                 if (getType(msg) != SIP_REQUEST) {
663                         LM_ERR("Not a request message - "
664                                 "no method available.\n");
665                         ST(0) = &PL_sv_undef;
666                 } else {
667                         ret = &((msg->first_line).u.request.method);
668                         ST(0) = sv_2mortal(newSVpv(ret->s, ret->len));
669                 }
670         }
671
672
673 =head2 getFullHeader()
674
675 Returns the full message header as present in the current message.
676 You might use this header to further work with it with your
677 favorite MIME package.
678
679 C<< my $hdr = $m->getFullHeader(); >>
680
681 =cut
682
683 SV *
684 getFullHeader(self)
685     SV *self
686   PREINIT:
687     struct sip_msg *msg = sv2msg(self);
688     char *firsttoken;
689     long headerlen;
690   INIT:
691   CODE:
692         if (!msg) {
693                 LM_ERR("Invalid message reference\n");
694                 ST(0) = &PL_sv_undef;
695         } else {
696                 if (getType(msg) == SIP_INVALID) {
697                         LM_ERR("getFullHeader: Invalid message type.\n");
698                         ST(0)  = &PL_sv_undef;
699                 } else {
700                         parse_headers(msg, ~0, 0);
701                         if (getType(msg) == SIP_REQUEST) {
702                                 firsttoken = (msg->first_line).u.request.method.s;
703                         } else { /* SIP_REPLY */
704                                 firsttoken = (msg->first_line).u.reply.version.s;
705                         }
706
707                         if (msg->eoh == NULL)
708                                 headerlen = 0;
709                         else
710                                 headerlen = ((long)(msg->eoh))
711                                                 -((long)(firsttoken));
712
713                         if (headerlen > 0) {
714                                 ST(0) = 
715                                     sv_2mortal(newSVpv(firsttoken, headerlen));
716                         } else {
717                                 ST(0) = &PL_sv_undef;
718                         }
719                 }
720         }
721
722
723 =head2 getBody()
724
725 Returns the message body.
726
727 =cut
728
729 SV *
730 getBody(self)
731     SV *self
732   PREINIT:
733     struct sip_msg *msg = sv2msg(self);
734   INIT:
735   CODE:
736         if (!msg) {
737                 LM_ERR("Invalid message reference\n");
738                 ST(0) = &PL_sv_undef;
739         } else {
740                 parse_headers(msg, ~0, 0);
741                 ST(0) = sv_2mortal(newSVpv(get_body(msg), 0));
742         }
743
744
745 =head2 getMessage()
746
747 Returns the whole message including headers and body.
748
749 =cut
750
751 SV *
752 getMessage(self)
753     SV *self
754   PREINIT:
755     struct sip_msg *msg = sv2msg(self);
756   INIT:
757   CODE:
758         if (!msg) {
759                 LM_ERR("Invalid message reference\n");
760                 ST(0) = &PL_sv_undef;
761         } else {
762                 ST(0) = sv_2mortal(newSVpv(msg->buf, 0));
763         }
764
765
766 =head2 getHeader(name)
767
768 Returns the body of the first message header with this name.
769
770 C<< print $m->getHeader("To"); >>
771
772 B<C<< "John" <sip:john@doe.example> >>>
773
774 =cut
775
776 SV *
777 getHeader(self, name)
778     SV *self;
779     char *name;
780   PREINIT:
781     struct sip_msg *msg = sv2msg(self);
782     str *body = NULL;
783     struct hdr_field *hf;
784     int found = 0;
785     int namelen = strlen(name);
786   INIT:
787   PPCODE:
788         LM_DBG("searching '%s'\n", name);
789
790         if (!msg) {
791                 LM_ERR("Invalid message reference\n");
792         } else {
793                 parse_headers(msg, ~0, 0);
794                 for (hf = msg->headers; hf; hf = hf->next) {
795                         if (namelen == hf->name.len) {
796                                 if (strncmp(name, hf->name.s, namelen) == 0) {
797                                         /* Found the right header. */
798                                         found = 1;
799                                         body = &(hf->body);
800                                         XPUSHs(sv_2mortal(newSVpv(body->s,
801                                                                   body->len)));
802                                 }
803                         }
804                 }
805         }
806         if (!found) {
807                 XPUSHs(&PL_sv_undef);
808         }
809
810
811
812 =head2 getHeaderNames()
813
814 Returns an array of all header names. Duplicates possible!
815
816 =cut
817
818 AV *
819 getHeaderNames(self)
820     SV *self;
821   PREINIT:
822     struct sip_msg *msg = sv2msg(self);
823     struct hdr_field *hf = NULL;
824     int found = 0;
825   PPCODE:
826         
827         if (!msg) {
828                 LM_ERR("Invalid message reference\n");
829         } else {
830                 parse_headers(msg, ~0, 0);
831                 for (hf = msg->headers; hf; hf = hf->next) {
832                         found = 1;
833                         XPUSHs(sv_2mortal(newSVpv(hf->name.s, hf->name.len)));
834                 }
835         }
836         if (!found) {
837                 XPUSHs(&PL_sv_undef);
838         }
839
840
841 =head2 moduleFunction(func,string1,string2)
842
843 Search for an arbitrary function in module exports and call it with the
844 parameters self, string1, string2.
845
846 C<string1> and/or C<string2> may be omitted.
847
848 As this function provides access to the functions that are exported to the
849 OpenSER configuration file, it is autoloaded for unknown functions. Instead of
850 writing
851
852  $m->moduleFunction("sl_send_reply", "500", "Internal Error");
853  $m->moduleFunction("xlog", "L_INFO", "foo");
854  
855 you may as well write
856
857  $m->sl_send_reply("500", "Internal Error");
858  $m->xlog("L_INFO", "foo");
859
860 WARNING
861
862 In OpenSER 1.2, only a limited subset of module functions is available. This
863 restriction will be removed in a later version.
864
865 Here is a list of functions that are expected to be working (not claiming
866 completeness):
867
868  * alias_db_lookup
869  * consume_credentials
870  * is_rpid_user_e164
871  * append_rpid_hf
872  * bind_auth
873  * avp_print
874  * cpl_process_register
875  * cpl_process_register_norpl
876  * load_dlg
877  * ds_next_dst
878  * ds_next_domain
879  * ds_mark_dst
880  * ds_mark_dst
881  * is_from_local
882  * is_uri_host_local
883  * dp_can_connect
884  * dp_apply_policy
885  * enum_query (without parameters)
886  * enum_fquery (without parameters)
887  * is_from_user_enum (without parameters)
888  * i_enum_query (without parameters)
889  * imc_manager
890  * jab_* (all functions from the jabber module)
891  * load_gws (without parameters)
892  * next_gw
893  * from_gw (without parameters)
894  * to_gw (without parameters)
895  * sdp_mangle_ip
896  * sdp_mangle_port
897  * encode_contact
898  * decode_contact
899  * decode_contact_header
900  * fix_contact
901  * use_media_proxy
902  * end_media_session
903  * m_store
904  * m_dump
905  * fix_nated_contact
906  * unforce_rtp_proxy
907  * force_rtp_proxy
908  * fix_nated_register
909  * add_rcv_param
910  * options_reply
911  * checkospheader
912  * validateospheader
913  * requestosprouting
914  * checkosproute
915  * prepareosproute
916  * prepareallosproutes
917  * checkcallingtranslation
918  * reportospusage
919  * mangle_pidf
920  * mangle_message_cpim
921  * add_path (without parameters)
922  * add_path_received (without parameters)
923  * prefix2domain
924  * allow_routing (without parameters)
925  * allow_trusted
926  * pike_check_req
927  * handle_publish
928  * handle_subscribe
929  * stored_pres_info
930  * bind_pua
931  * send_publish
932  * send_subscribe
933  * pua_set_publish
934  * loose_route
935  * record_route
936  * load_rr
937  * sip_trace
938  * sl_reply_error
939  * sms_send_msg
940  * sd_lookup
941  * sstCheckMin
942  * append_time
943  * has_body (without parameters)
944  * is_peer_verified
945  * t_newtran
946  * t_release
947  * t_relay (without parameters)
948  * t_flush_flags
949  * t_check_trans
950  * t_was_cancelled
951  * t_load_contacts
952  * t_next_contacts
953  * uac_restore_from
954  * uac_auth
955  * has_totag
956  * tel2sip
957  * check_to
958  * check_from
959  * radius_does_uri_exist
960  * ul_* (All functions exported by the usrloc module for user access)
961  * xmpp_send_message
962
963 =cut
964
965
966 int
967 moduleFunction (self, func, string1 = NULL, string2 = NULL)
968     SV *self;
969     char *func;
970     char *string1;
971     char *string2;
972   PREINIT:
973     struct sip_msg *msg = sv2msg(self);
974     int retval; /* Return value of called function */
975     int ret;    /* Return value of moduleFunc - < 0 for "non existing function" and other errors */
976   INIT:
977   CODE:
978         LM_DBG("Calling exported func '%s', Param1 is '%s',"
979                 " Param2 is '%s'\n", func, string1, string2);
980
981         ret = moduleFunc(msg, func, string1, string2, &retval);
982         if (ret < 0) {
983                 LM_ERR("calling module function '%s' failed."
984                         " Missing loadmodule?\n", func);
985                 retval = -1;
986         }
987         RETVAL = retval;
988   OUTPUT:
989         RETVAL
990
991
992
993 =head2 log(level,message) (deprecated type)
994
995 Logs the message with OpenSER's logging facility. The logging level
996 is one of the following:
997
998  * L_ALERT
999  * L_CRIT
1000  * L_ERR
1001  * L_WARN
1002  * L_NOTICE
1003  * L_INFO
1004  * L_DBG
1005
1006 The logging function should be accessed via the OpenSER module variant. This
1007 one, located in OpenSER::Message, is deprecated.
1008
1009 =cut
1010
1011 void
1012 log(self, level, log)
1013     SV *self
1014     int level
1015     char *log
1016   PREINIT:
1017   INIT:
1018   CODE:
1019         switch (level) {
1020         case L_ALERT:   LM_ALERT("%s", log); break;
1021         case L_CRIT:    LM_CRIT("%s", log); break;
1022         case L_ERR:     LM_ERR("%s", log); break;
1023         case L_WARN:    LM_WARN("%s", log); break;
1024         case L_NOTICE:  LM_NOTICE("%s", log); break;
1025         case L_INFO:    LM_INFO("%s", log); break;
1026         default:        LM_DBG("%s", log); break;
1027         }
1028
1029
1030
1031 =head2 rewrite_ruri(newruri)
1032
1033 Sets a new destination (recipient) URI. Useful for rerouting the
1034 current message/call.
1035
1036  if ($m->getRURI() =~ m/\@somedomain.net/) {
1037    $m->rewrite_ruri("sip:dispatcher\@organization.net");
1038  }
1039
1040 =cut
1041
1042 int
1043 rewrite_ruri(self, newruri)
1044     SV *self;
1045     char *newruri;
1046   PREINIT:
1047     struct sip_msg *msg = sv2msg(self);
1048   INIT:
1049   CODE:
1050         if (!msg) {
1051                 LM_ERR("Invalid message reference\n");
1052                 RETVAL = -1;
1053         } else {
1054                 if (getType(msg) != SIP_REQUEST) {
1055                         LM_ERR("Not a Request. RURI rewrite unavailable.\n");
1056                         RETVAL = -1;
1057                 } else {
1058                         LM_DBG("New R-URI is [%s]\n", newruri);
1059                         RETVAL = rewrite_ruri(msg, newruri);
1060                 }
1061         }
1062   OUTPUT:
1063         RETVAL
1064
1065
1066
1067 =head2 setFlag(flag)
1068
1069 Sets a message flag. The constants as known from the C API may be used,
1070 when Constants.pm is included.
1071
1072 =cut
1073
1074 int
1075 setFlag(self, flag)
1076     SV *self;
1077     unsigned int flag;
1078   PREINIT:
1079         struct sip_msg *msg = sv2msg(self);
1080   INIT:
1081   CODE:
1082         if (!msg) {
1083                 LM_ERR("Invalid message reference\n");
1084                 RETVAL = -1;
1085         } else {
1086                 RETVAL = setflag(msg, flag);
1087         }
1088   OUTPUT:
1089         RETVAL
1090
1091
1092 =head2 resetFlag(flag)
1093
1094 Resets a message flag.
1095
1096 =cut
1097
1098 int
1099 resetFlag(self, flag)
1100     SV *self;
1101     unsigned int flag;
1102   PREINIT:
1103         struct sip_msg *msg = sv2msg(self);
1104   INIT:
1105   CODE:
1106         if (!msg) {
1107                 LM_ERR("Invalid message reference\n");
1108                 RETVAL = -1;
1109         } else {
1110                 RETVAL = resetflag(msg, flag);
1111         }
1112   OUTPUT:
1113         RETVAL
1114
1115 =head2 isFlagSet(flag)
1116
1117 Returns whether a message flag is set or not.
1118
1119 =cut
1120
1121 int
1122 isFlagSet(self, flag)
1123     SV *self;
1124     unsigned int flag;
1125   PREINIT:
1126         struct sip_msg *msg = sv2msg(self);
1127   INIT:
1128   CODE:
1129         if (!msg) {
1130                 LM_ERR("Invalid message reference\n");
1131                 RETVAL = -1;
1132         } else {
1133                 RETVAL = isflagset(msg, flag) == 1 ? 1 : 0;
1134         }
1135   OUTPUT:
1136         RETVAL
1137
1138
1139 =head2 pseudoVar(string)
1140
1141 Returns a new string where all pseudo variables are substituted by their values.
1142 Can be used to receive the values of single variables, too.
1143
1144 B<Please remember that you need to escape the '$' sign in perl strings!>
1145
1146 =cut
1147
1148 SV *
1149 pseudoVar(self, varstring)
1150     SV *self;
1151     char *varstring;
1152   PREINIT:
1153         struct sip_msg *msg = sv2msg(self);
1154         char *ret;
1155   CODE:
1156         if (!msg) {
1157                 LM_ERR("Invalid message reference\n");
1158                 ST(0) = &PL_sv_undef;
1159         } else {
1160                 ret = pv_sprintf(msg, varstring);
1161                 if (ret) {
1162                         ST(0) = sv_2mortal(newSVpv(ret, strlen(ret)));
1163                         free(ret);
1164                 } else {
1165                         ST(0) = &PL_sv_undef;
1166                 }
1167         }
1168
1169
1170
1171 =head2 append_branch(branch,qval)
1172
1173 Append a branch to current message.
1174
1175 =cut
1176
1177 int
1178 append_branch(self, branch = NULL, qval = NULL)
1179         SV *self;
1180         char *branch;
1181         char *qval;
1182   PREINIT:
1183         struct sip_msg *msg = sv2msg(self);
1184         qvalue_t q = Q_UNSPECIFIED;
1185         str b = {0, 0};
1186   INIT:
1187   CODE:
1188         if (!msg) {
1189                 LM_ERR("Invalid message reference\n");
1190                 RETVAL = -1;
1191         } else {
1192                 if (qval) {
1193                         if (str2q(&q, qval, strlen(qval)) < 0) {
1194                                 LM_ERR("append_branch: Bad q value.");
1195                         } else { /* branch and qval set */
1196                                 b.s = branch;
1197                                 b.len = strlen(branch);
1198                         }
1199                 } else {
1200                         if (branch) { /* branch set, qval unset */
1201                                 b.s = branch;
1202                                 b.len = strlen(branch);
1203                         }
1204                 }
1205
1206                 RETVAL = km_append_branch(msg, (b.s!=0)?&b:0, 0, 0, q, 0, 0);
1207         }
1208   OUTPUT:
1209         RETVAL
1210
1211
1212
1213 =head2 getParsedRURI()
1214
1215 Returns the current destination URI as an OpenSER::URI object.
1216
1217 =cut
1218
1219 SV *
1220 getParsedRURI(self)
1221     SV *self;
1222   PREINIT:
1223     struct sip_msg *msg = sv2msg(self);
1224     struct sip_uri *uri;
1225     SV *ret;
1226   INIT:
1227   CODE:
1228         if (!msg) {
1229                 LM_ERR("Invalid message reference\n");
1230                 ST(0) = NULL;
1231         } else {
1232                 parse_sip_msg_uri(msg);
1233                 parse_headers(msg, ~0, 0);
1234
1235                 uri = &(msg->parsed_uri);
1236                 ret = sv_newmortal();
1237                 sv_setref_pv(ret, "OpenSER::URI", (void *)uri);
1238                 SvREADONLY_on(SvRV(ret));
1239
1240                 ST(0) = ret;
1241         }
1242         
1243
1244
1245 MODULE = OpenSER PACKAGE = OpenSER::URI
1246
1247 =head1 OpenSER::URI
1248
1249 This package provides functions for access to sip_uri structures.
1250
1251 =cut
1252
1253
1254
1255
1256 =head2 user()
1257
1258 Returns the user part of this URI.
1259
1260 =cut
1261
1262 SV *
1263 user(self)
1264     SV *self;
1265   CODE:
1266         ST(0) = getStringFromURI(self, XS_URI_USER);
1267
1268
1269 =head2 host()
1270
1271 Returns the host part of this URI.
1272
1273 =cut
1274
1275 SV *
1276 host(self)
1277     SV *self;
1278   CODE:
1279         ST(0) = getStringFromURI(self, XS_URI_HOST);
1280
1281
1282 =head2 passwd()
1283
1284 Returns the passwd part of this URI.
1285
1286 =cut
1287
1288 SV *
1289 passwd(self)
1290     SV *self;
1291   CODE:
1292         ST(0) = getStringFromURI(self, XS_URI_PASSWD);
1293
1294
1295 =head2 port()
1296
1297 Returns the port part of this URI.
1298
1299 =cut
1300
1301 SV *
1302 port(self)
1303     SV *self;
1304   CODE:
1305         ST(0) = getStringFromURI(self, XS_URI_PORT);
1306
1307
1308 =head2 params()
1309
1310 Returns the params part of this URI.
1311
1312 =cut
1313
1314 SV *
1315 params(self)
1316     SV *self;
1317   CODE:
1318         ST(0) = getStringFromURI(self, XS_URI_PARAMS);
1319
1320
1321 =head2 headers()
1322
1323 Returns the headers part of this URI.
1324
1325 =cut
1326
1327 SV *
1328 headers(self)
1329     SV *self;
1330   CODE:
1331         ST(0) = getStringFromURI(self, XS_URI_HEADERS);
1332
1333
1334 =head2 transport()
1335
1336 Returns the transport part of this URI.
1337
1338 =cut
1339
1340 SV *
1341 transport(self)
1342     SV *self;
1343   CODE:
1344         ST(0) = getStringFromURI(self, XS_URI_TRANSPORT);
1345
1346
1347 =head2 ttl()
1348
1349 Returns the ttl part of this URI.
1350
1351 =cut
1352
1353 SV *
1354 ttl(self)
1355     SV *self;
1356   CODE:
1357         ST(0) = getStringFromURI(self, XS_URI_TTL);
1358
1359
1360 =head2 user_param()
1361
1362 Returns the user_param part of this URI.
1363
1364 =cut
1365
1366 SV *
1367 user_param(self)
1368     SV *self;
1369   CODE:
1370         ST(0) = getStringFromURI(self, XS_URI_USER_PARAM);
1371
1372
1373
1374 =head2 maddr()
1375
1376 Returns the maddr part of this URI.
1377
1378 =cut
1379
1380 SV *
1381 maddr(self)
1382     SV *self;
1383   CODE:
1384         ST(0) = getStringFromURI(self, XS_URI_MADDR);
1385
1386 =head2 method()
1387
1388 Returns the method part of this URI.
1389
1390 =cut
1391
1392 SV *
1393 method(self)
1394     SV *self;
1395   CODE:
1396         ST(0) = getStringFromURI(self, XS_URI_METHOD);
1397
1398
1399 =head2 lr()
1400
1401 Returns the lr part of this URI.
1402
1403 =cut
1404
1405 SV *
1406 lr(self)
1407     SV *self;
1408   CODE:
1409         ST(0) = getStringFromURI(self, XS_URI_LR);
1410
1411
1412 =head2 r2()
1413
1414 Returns the r2 part of this URI.
1415
1416 =cut
1417
1418 SV *
1419 r2(self)
1420     SV *self;
1421   CODE:
1422         ST(0) = getStringFromURI(self, XS_URI_R2);
1423
1424
1425 =head2 transport_val()
1426
1427 Returns the transport_val part of this URI.
1428
1429 =cut
1430
1431 SV *
1432 transport_val(self)
1433     SV *self;
1434   CODE:
1435         ST(0) = getStringFromURI(self, XS_URI_TRANSPORT_VAL);
1436
1437
1438 =head2 ttl_val()
1439
1440 Returns the ttl_val part of this URI.
1441
1442 =cut
1443
1444 SV *
1445 ttl_val(self)
1446     SV *self;
1447   CODE:
1448         ST(0) = getStringFromURI(self, XS_URI_TTL_VAL);
1449
1450
1451 =head2 user_param_val()
1452
1453 Returns the user_param_val part of this URI.
1454
1455 =cut
1456
1457 SV *
1458 user_param_val(self)
1459     SV *self;
1460   CODE:
1461         ST(0) = getStringFromURI(self, XS_URI_USER_PARAM_VAL);
1462
1463
1464 =head2 maddr_val()
1465
1466 Returns the maddr_val part of this URI.
1467
1468 =cut
1469
1470 SV *
1471 maddr_val(self)
1472     SV *self;
1473   CODE:
1474         ST(0) = getStringFromURI(self, XS_URI_MADDR_VAL);
1475
1476
1477 =head2 method_val()
1478
1479 Returns the method_val part of this URI.
1480
1481 =cut
1482
1483 SV *
1484 method_val(self)
1485     SV *self;
1486   CODE:
1487         ST(0) = getStringFromURI(self, XS_URI_METHOD_VAL);
1488
1489
1490 =head2 lr_val()
1491
1492 Returns the lr_val part of this URI.
1493
1494 =cut
1495
1496 SV *
1497 lr_val(self)
1498     SV *self;
1499   CODE:
1500         ST(0) = getStringFromURI(self, XS_URI_LR_VAL);
1501
1502
1503 =head2 r2_val()
1504
1505 Returns the r2_val part of this URI.
1506
1507 =cut
1508
1509 SV *
1510 r2_val(self)
1511     SV *self;
1512   CODE:
1513         ST(0) = getStringFromURI(self, XS_URI_R2_VAL);
1514
1515
1516
1517 =head1 OpenSER::AVP
1518
1519 This package provides access functions for OpenSER's AVPs.
1520 These variables can be created, evaluated, modified and removed through this
1521 package.
1522
1523 Please note that these functions do NOT support the notation used
1524 in the configuration file, but directly work on strings or numbers. See
1525 documentation of add method below.
1526
1527 =cut
1528
1529
1530 MODULE = OpenSER PACKAGE = OpenSER::AVP
1531
1532 =head2 add(name,val)
1533
1534 Add an AVP.
1535
1536 Add an OpenSER AVP to its environment. name and val may both be integers or
1537 strings; this function will try to guess what is correct. Please note that
1538  
1539  OpenSER::AVP::add("10", "10")
1540
1541 is something different than
1542
1543  OpenSER::AVP::add(10, 10)
1544
1545 due to this evaluation: The first will create _string_ AVPs with the name
1546 10, while the latter will create a numerical AVP.
1547
1548 You can modify/overwrite AVPs with this function.
1549
1550 =cut
1551
1552 int
1553 add(p_name, p_val)
1554         SV *p_name;
1555         SV *p_val;
1556   PREINIT:
1557         int_str name;
1558         int_str val;
1559         unsigned short flags = 0;
1560         char *s;
1561         STRLEN len;
1562   CODE:
1563         RETVAL = 0;
1564         if (SvOK(p_name) && SvOK(p_val)) {
1565                 if (!sv2int_str(p_name, &name, &flags, AVP_NAME_STR)) {
1566                         RETVAL = -1;
1567                 } else if (!sv2int_str(p_val, &val, &flags, AVP_VAL_STR)) {
1568                         RETVAL = -1;
1569                 }
1570
1571                 if (RETVAL == 0) {
1572                         RETVAL = add_avp(flags, name, val);
1573                 }
1574         }
1575   OUTPUT:
1576         RETVAL
1577
1578
1579
1580
1581 =head2 get(name)
1582
1583 get an OpenSER AVP:
1584
1585  my $numavp = OpenSER::AVP::get(5);
1586  my $stravp = OpenSER::AVP::get("foo");
1587
1588 =cut
1589
1590 int
1591 get(p_name)
1592         SV *p_name;
1593   PREINIT:
1594         struct usr_avp *first_avp;
1595         int_str name;
1596         int_str val;
1597         unsigned short flags = 0;
1598         SV *ret = &PL_sv_undef;
1599         int err = 0;
1600         char *s;
1601         STRLEN len;
1602   CODE:
1603         if (SvOK(p_name)) {
1604                 if (!sv2int_str(p_name, &name, &flags, AVP_NAME_STR)) {
1605                         LM_ERR("AVP:get: Invalid name.");
1606                         err = 1;
1607                 }
1608         } else {
1609                 LM_ERR("AVP:get: Invalid name.");
1610                 err = 1;
1611         }
1612         
1613         if (err == 0) {
1614                 first_avp = search_first_avp(flags, name, &val, NULL);
1615                 
1616                 if (first_avp != NULL) { /* found correct AVP */
1617                         if (is_avp_str_val(first_avp)) {
1618                                 ret = sv_2mortal(newSVpv(val.s.s, val.s.len));
1619                         } else {
1620                                 ret = sv_2mortal(newSViv(val.n));
1621                         }
1622                 } else {
1623                         /* Empty AVP requested. */
1624                 }
1625         }
1626
1627         ST(0) = ret;
1628
1629
1630
1631
1632 =head2 destroy(name)
1633
1634 Destroy an AVP.
1635
1636  OpenSER::AVP::destroy(5);
1637  OpenSER::AVP::destroy("foo");
1638
1639 =cut
1640
1641 int
1642 destroy(p_name)
1643         SV *p_name;
1644   PREINIT:
1645         struct usr_avp *first_avp;
1646         int_str name;
1647         int_str val;
1648         unsigned short flags = 0;
1649         SV *ret = &PL_sv_undef;
1650         char *s;
1651         STRLEN len;
1652   CODE:
1653         RETVAL = 1;
1654         if (SvOK(p_name)) {
1655                 if (!sv2int_str(p_name, &name, &flags, AVP_NAME_STR)) {
1656                         RETVAL = 0;
1657                         LM_ERR("AVP:destroy: Invalid name.");
1658                 }
1659         } else {
1660                 RETVAL = 0;
1661                 LM_ERR("VP:destroy: Invalid name.");
1662         }
1663         
1664         if (RETVAL == 1) {
1665                 first_avp = search_first_avp(flags, name, &val, NULL);
1666                 
1667                 if (first_avp != NULL) { /* found correct AVP */
1668                         destroy_avp(first_avp);
1669                 } else {
1670                         RETVAL = 0;
1671                         /* Empty AVP requested. */
1672                 }
1673         }
1674
1675   OUTPUT:
1676         RETVAL
1677
1678