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