git.sip-router.org Git - sip-router/blob - 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