git.sip-router.org Git - sip-router/blob - modules/app_python/python_msgobj.c

   1 /* $Id$
   2  *
   3  * Copyright (C) 2009 Sippy Software, Inc., http://www.sippysoft.com
   4  *
   5  * This file is part of SIP-Router, a free SIP server.
   6  *
   7  * SIP-Router is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version
  11  *
  12  * SIP-Router is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  *
  21 */
  22
  23 #include "../../action.h"
  24 #include "../../mem/mem.h"
  25 #include "../../sr_module.h"
  26 #include "../../parser/msg_parser.h"
  27
  28 #include <Python.h>
  29 #include "structmember.h"
  30
  31 #ifndef Py_TYPE
  32 #define Py_TYPE(ob)               (((PyObject*)(ob))->ob_type)
  33 #endif
  34
  35 typedef struct {
  36     PyObject_HEAD
  37     struct sip_msg *msg;
  38 } msgobject;
  39
  40 static PyTypeObject MSGtype;
  41
  42 #define is_msgobject(v)         ((v)->ob_type == &MSGtype)
  43
  44 msgobject *
  45 newmsgobject(struct sip_msg *msg)
  46 {
  47     msgobject *msgp;
  48
  49     msgp = PyObject_New(msgobject, &MSGtype);
  50     if (msgp == NULL)
  51         return NULL;
  52
  53     msgp->msg = msg;
  54     return msgp;
  55 }
  56
  57 void
  58 msg_invalidate(msgobject *self)
  59 {
  60
  61     self->msg = NULL;
  62 }
  63
  64 static void
  65 msg_dealloc(msgobject *msgp)
  66 {
  67
  68     PyObject_Del(msgp);
  69 }
  70
  71 static PyObject *
  72 msg_copy(msgobject *self)
  73 {
  74     msgobject *msgp;
  75
  76     if ((msgp = newmsgobject(self->msg)) == NULL)
  77         return NULL;
  78
  79     return (PyObject *)msgp;
  80 }
  81
  82 static PyObject *
  83 msg_rewrite_ruri(msgobject *self, PyObject *args)
  84 {
  85     char *ruri;
  86     struct action act;
  87     struct run_act_ctx ra_ctx;
  88
  89     if (self->msg == NULL) {
  90         PyErr_SetString(PyExc_RuntimeError, "self->msg is NULL");
  91         Py_INCREF(Py_None);
  92         return Py_None;
  93     }
  94
  95     if ((self->msg->first_line).type != SIP_REQUEST) {
  96         PyErr_SetString(PyExc_RuntimeError, "Not a request message - "
  97           "rewrite is not possible.\n");
  98         Py_INCREF(Py_None);
  99         return Py_None;
 100     }
 101
 102     if(!PyArg_ParseTuple(args, "s:rewrite_ruri", &ruri))
 103         return NULL;
 104
 105     memset(&act, '\0', sizeof(act));
 106
 107     act.type = SET_URI_T;
 108     act.val[0].type = STR_ST;
 109     act.val[0].u.str.s = ruri;
 110     act.val[0].u.str.len = strlen(ruri);
 111
 112     init_run_actions_ctx(&ra_ctx);
 113     if (do_action(&ra_ctx, &act, self->msg) < 0) {
 114         LM_ERR("Error in do_action\n");
 115         PyErr_SetString(PyExc_RuntimeError, "Error in do_action\n");
 116     }
 117
 118     Py_INCREF(Py_None);
 119     return Py_None;
 120 }
 121
 122 static PyObject *
 123 msg_set_dst_uri(msgobject *self, PyObject *args)
 124 {
 125     str ruri;
 126
 127     if (self->msg == NULL) {
 128         PyErr_SetString(PyExc_RuntimeError, "self->msg is NULL");
 129         Py_INCREF(Py_None);
 130         return Py_None;
 131     }
 132
 133     if ((self->msg->first_line).type != SIP_REQUEST) {
 134         PyErr_SetString(PyExc_RuntimeError, "Not a request message - "
 135           "set destination is not possible.\n");
 136         Py_INCREF(Py_None);
 137         return Py_None;
 138     }
 139
 140     if(!PyArg_ParseTuple(args, "s:set_dst_uri", &ruri.s))
 141         return NULL;
 142
 143     ruri.len = strlen(ruri.s);
 144
 145     if (set_dst_uri(self->msg, &ruri) < 0) {
 146         LM_ERR("Error in set_dst_uri\n");
 147         PyErr_SetString(PyExc_RuntimeError, "Error in set_dst_uri\n");
 148     }
 149
 150     Py_INCREF(Py_None);
 151     return Py_None;
 152 }
 153
 154 static PyObject *
 155 msg_getHeader(msgobject *self, PyObject *args)
 156 {
 157     struct hdr_field *hf;
 158     str hname, *hbody;
 159
 160     if (self->msg == NULL) {
 161         PyErr_SetString(PyExc_RuntimeError, "self->msg is NULL");
 162         Py_INCREF(Py_None);
 163         return Py_None;
 164     }
 165
 166     if(!PyArg_ParseTuple(args, "s:getHeader", &hname.s))
 167         return NULL;
 168     hname.len = strlen(hname.s);
 169
 170     parse_headers(self->msg, ~0, 0);
 171     hbody = NULL;
 172     for (hf = self->msg->headers; hf != NULL; hf = hf->next) {
 173         if (hname.len == hf->name.len &&
 174           strncasecmp(hname.s, hf->name.s, hname.len) == 0) {
 175             hbody = &(hf->body);
 176             break;
 177         }
 178     }
 179
 180     if (hbody == NULL) {
 181         Py_INCREF(Py_None);
 182         return Py_None;
 183     }
 184
 185     return PyString_FromStringAndSize(hbody->s, hbody->len);
 186 }
 187
 188 static PyObject *
 189 msg_call_function(msgobject *self, PyObject *args)
 190 {
 191     int i, rval;
 192     char *fname, *arg1, *arg2;
 193     union cmd_export_u* fexport;
 194     struct action *act;
 195     struct run_act_ctx ra_ctx;
 196     unsigned mod_ver;
 197
 198     if (self->msg == NULL) {
 199         PyErr_SetString(PyExc_RuntimeError, "self->msg is NULL");
 200         Py_INCREF(Py_None);
 201         return Py_None;
 202     }
 203
 204     i = PySequence_Size(args);
 205     if (i < 1 || i > 3) {
 206         PyErr_SetString(PyExc_RuntimeError, "call_function() should " \
 207           "have from 1 to 3 arguments");
 208         Py_INCREF(Py_None);
 209         return Py_None;
 210     }
 211
 212     if(!PyArg_ParseTuple(args, "s|ss:call_function", &fname, &arg1, &arg2))
 213         return NULL;
 214
 215     fexport = find_export_record(fname, i - 2, 0, &mod_ver);
 216     if (fexport == NULL) {
 217         PyErr_SetString(PyExc_RuntimeError, "no such function");
 218         Py_INCREF(Py_None);
 219         return Py_None;
 220     }
 221
 222     act = mk_action(MODULE2_T, 4 /* number of (type, value) pairs */,
 223                     MODEXP_ST, fexport, /* function */
 224                     NUMBER_ST, 2,       /* parameter number */
 225                     STRING_ST, arg1,    /* param. 1 */
 226                     STRING_ST, arg2     /* param. 2 */
 227                    );
 228
 229     if (act == NULL) {
 230         PyErr_SetString(PyExc_RuntimeError,
 231           "action structure could not be created");
 232         Py_INCREF(Py_None);
 233         return Py_None;
 234     }
 235
 236     if (fexport->v1.fixup != NULL) {
 237         if (i >= 3) {
 238             rval = fexport->v1.fixup(&(act->val[2].u.data), 2);
 239             if (rval < 0) {
 240                 PyErr_SetString(PyExc_RuntimeError, "Error in fixup (2)");
 241                 Py_INCREF(Py_None);
 242                 return Py_None;
 243             }
 244             act->val[2].type = MODFIXUP_ST;
 245         }
 246         if (i >= 2) {
 247             rval = fexport->v1.fixup(&(act->val[1].u.data), 1);
 248             if (rval < 0) {
 249                 PyErr_SetString(PyExc_RuntimeError, "Error in fixup (1)");
 250                 Py_INCREF(Py_None);
 251                 return Py_None;
 252             }
 253             act->val[1].type = MODFIXUP_ST;
 254         }
 255         if (i == 1) {
 256             rval = fexport->v1.fixup(0, 0);
 257             if (rval < 0) {
 258                 PyErr_SetString(PyExc_RuntimeError, "Error in fixup (0)");
 259                 Py_INCREF(Py_None);
 260                 return Py_None;
 261             }
 262         }
 263     }
 264
 265     init_run_actions_ctx(&ra_ctx);
 266     rval = do_action(&ra_ctx, act, self->msg);
 267
 268     if ((act->val[2].type == MODFIXUP_ST) && (act->val[2].u.data)) {
 269        pkg_free(act->val[2].u.data);
 270     }
 271
 272     if ((act->val[1].type == MODFIXUP_ST) && (act->val[1].u.data)) {
 273         pkg_free(act->val[1].u.data);
 274     }
 275
 276     pkg_free(act);
 277
 278     return PyInt_FromLong(rval);
 279 }
 280
 281 PyDoc_STRVAR(copy_doc,
 282 "copy() -> msg object\n\
 283 \n\
 284 Return a copy (``clone'') of the msg object.");
 285
 286 static PyMethodDef msg_methods[] = {
 287     {"copy",          (PyCFunction)msg_copy,          METH_NOARGS,  copy_doc},
 288     {"rewrite_ruri",  (PyCFunction)msg_rewrite_ruri,  METH_VARARGS,
 289       "Rewrite Request-URI."},
 290     {"set_dst_uri",   (PyCFunction)msg_set_dst_uri,   METH_VARARGS,
 291       "Set destination URI."},
 292     {"getHeader",     (PyCFunction)msg_getHeader,     METH_VARARGS,
 293       "Get SIP header field by name."},
 294     {"call_function", (PyCFunction)msg_call_function, METH_VARARGS,
 295       "Invoke function exported by the other module."},
 296     {NULL, NULL, 0, NULL}                              /* sentinel */
 297 };
 298
 299 static PyObject *
 300 msg_getType(msgobject *self, PyObject *unused)
 301 {
 302     const char *rval;
 303
 304     if (self->msg == NULL) {
 305         PyErr_SetString(PyExc_RuntimeError, "self->msg is NULL");
 306         Py_INCREF(Py_None);
 307         return Py_None;
 308     }
 309
 310     switch ((self->msg->first_line).type) {
 311     case SIP_REQUEST:
 312        rval = "SIP_REQUEST";
 313        break;
 314
 315     case SIP_REPLY:
 316        rval = "SIP_REPLY";
 317        break;
 318
 319     default:
 320        /* Shouldn't happen */
 321        abort();
 322     }
 323     return PyString_FromString(rval);
 324 }
 325
 326 static PyObject *
 327 msg_getMethod(msgobject *self, PyObject *unused)
 328 {
 329     str *rval;
 330
 331     if (self->msg == NULL) {
 332         PyErr_SetString(PyExc_RuntimeError, "self->msg is NULL");
 333         Py_INCREF(Py_None);
 334         return Py_None;
 335     }
 336
 337     if ((self->msg->first_line).type != SIP_REQUEST) {
 338         PyErr_SetString(PyExc_RuntimeError, "Not a request message - "
 339           "no method available.\n");
 340         Py_INCREF(Py_None);
 341         return Py_None;
 342     }
 343     rval = &((self->msg->first_line).u.request.method);
 344     return PyString_FromStringAndSize(rval->s, rval->len);
 345 }
 346
 347 static PyObject *
 348 msg_getStatus(msgobject *self, PyObject *unused)
 349 {
 350     str *rval;
 351
 352     if (self->msg == NULL) {
 353         PyErr_SetString(PyExc_RuntimeError, "self->msg is NULL");
 354         Py_INCREF(Py_None);
 355         return Py_None;
 356     }
 357
 358     if ((self->msg->first_line).type != SIP_REPLY) {
 359         PyErr_SetString(PyExc_RuntimeError, "Not a non-reply message - "
 360           "no status available.\n");
 361         Py_INCREF(Py_None);
 362         return Py_None;
 363     }
 364
 365     rval = &((self->msg->first_line).u.reply.status);
 366     return PyString_FromStringAndSize(rval->s, rval->len);
 367 }
 368
 369 static PyObject *
 370 msg_getRURI(msgobject *self, PyObject *unused)
 371 {
 372     str *rval;
 373
 374     if (self->msg == NULL) {
 375         PyErr_SetString(PyExc_RuntimeError, "self->msg is NULL");
 376         Py_INCREF(Py_None);
 377         return Py_None;
 378     }
 379
 380     if ((self->msg->first_line).type != SIP_REQUEST) {
 381         PyErr_SetString(PyExc_RuntimeError, "Not a request message - "
 382           "RURI is not available.\n");
 383         Py_INCREF(Py_None);
 384         return Py_None;
 385     }
 386
 387     rval = &((self->msg->first_line).u.request.uri);
 388     return PyString_FromStringAndSize(rval->s, rval->len);
 389 }
 390
 391 static PyObject *
 392 msg_get_src_address(msgobject *self, PyObject *unused)
 393 {
 394     PyObject *src_ip, *src_port, *pyRval;
 395
 396     if (self->msg == NULL) {
 397         PyErr_SetString(PyExc_RuntimeError, "self->msg is NULL");
 398         Py_INCREF(Py_None);
 399         return Py_None;
 400     }
 401
 402     src_ip = PyString_FromString(ip_addr2a(&self->msg->rcv.src_ip));
 403     if (src_ip == NULL) {
 404         Py_INCREF(Py_None);
 405         return Py_None;
 406     }
 407
 408     src_port = PyInt_FromLong(self->msg->rcv.src_port);
 409     if (src_port == NULL) {
 410         Py_DECREF(src_ip);
 411         Py_INCREF(Py_None);
 412         return Py_None;
 413     }
 414
 415     pyRval = PyTuple_Pack(2, src_ip, src_port);
 416     Py_DECREF(src_ip);
 417     Py_DECREF(src_port);
 418     if (pyRval == NULL) {
 419         Py_INCREF(Py_None);
 420         return Py_None;
 421     }
 422
 423     return pyRval;
 424 }
 425
 426 static PyObject *
 427 msg_get_dst_address(msgobject *self, PyObject *unused)
 428 {
 429     PyObject *dst_ip, *dst_port, *pyRval;
 430
 431     if (self->msg == NULL) {
 432         PyErr_SetString(PyExc_RuntimeError, "self->msg is NULL");
 433         Py_INCREF(Py_None);
 434         return Py_None;
 435     }
 436
 437     dst_ip = PyString_FromString(ip_addr2a(&self->msg->rcv.dst_ip));
 438     if (dst_ip == NULL) {
 439         Py_INCREF(Py_None);
 440         return Py_None;
 441     }
 442
 443     dst_port = PyInt_FromLong(self->msg->rcv.dst_port);
 444     if (dst_port == NULL) {
 445         Py_DECREF(dst_ip);
 446         Py_INCREF(Py_None);
 447         return Py_None;
 448     }
 449
 450     pyRval = PyTuple_Pack(2, dst_ip, dst_port);
 451     Py_DECREF(dst_ip);
 452     Py_DECREF(dst_port);
 453     if (pyRval == NULL) {
 454         Py_INCREF(Py_None);
 455         return Py_None;
 456     }
 457
 458     return pyRval;
 459 }
 460
 461 static PyGetSetDef msg_getseters[] = {
 462     {"Type",
 463      (getter)msg_getType, NULL, NULL,
 464      "Get message type - \"SIP_REQUEST\" or \"SIP_REPLY\"."},
 465     {"Method",
 466      (getter)msg_getMethod, NULL, NULL,
 467      "Get SIP method name."},
 468     {"Status",
 469      (getter)msg_getStatus, NULL, NULL,
 470      "Get SIP status code string."},
 471     {"RURI",
 472      (getter)msg_getRURI, NULL, NULL,
 473      "Get SIP Request-URI."},
 474     {"src_address",
 475      (getter)msg_get_src_address, NULL, NULL,
 476      "Get (IP, port) tuple representing source address of the message."},
 477     {"dst_address",
 478      (getter)msg_get_dst_address, NULL, NULL,
 479      "Get (IP, port) tuple representing destination address of the message."},
 480     {NULL, NULL, NULL, NULL, NULL}  /* Sentinel */
 481 };
 482
 483 static PyTypeObject MSGtype = {
 484 #if PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION >= 6
 485     PyVarObject_HEAD_INIT(NULL, 0)
 486 #else
 487     PyObject_HEAD_INIT(NULL)
 488     0,                        /*ob_size*/
 489 #endif
 490     "Router.msg",             /*tp_name*/
 491     sizeof(msgobject),        /*tp_size*/
 492     0,                        /*tp_itemsize*/
 493     /* methods */
 494     (destructor)msg_dealloc,  /*tp_dealloc*/
 495     0,                        /*tp_print*/
 496     0,                        /*tp_getattr*/
 497     0,                        /*tp_setattr*/
 498     0,                        /*tp_compare*/
 499     0,                        /*tp_repr*/
 500     0,                        /*tp_as_number*/
 501     0,                        /*tp_as_sequence*/
 502     0,                        /*tp_as_mapping*/
 503     0,                        /*tp_hash*/
 504     0,                        /*tp_call*/
 505     0,                        /*tp_str*/
 506     0,                        /*tp_getattro*/
 507     0,                        /*tp_setattro*/
 508     0,                        /*tp_as_buffer*/
 509     Py_TPFLAGS_DEFAULT,       /*tp_flags*/
 510     0,                        /*tp_doc*/
 511     0,                        /*tp_traverse*/
 512     0,                        /*tp_clear*/
 513     0,                        /*tp_richcompare*/
 514     0,                        /*tp_weaklistoffset*/
 515     0,                        /*tp_iter*/
 516     0,                        /*tp_iternext*/
 517     msg_methods,              /*tp_methods*/
 518     0,                        /*tp_members*/
 519     msg_getseters,            /*tp_getset*/
 520 };
 521
 522 int
 523 python_msgobj_init(void)
 524 {
 525
 526     Py_TYPE(&MSGtype) = &PyType_Type;
 527     if (PyType_Ready(&MSGtype) < 0)
 528         return -1;
 529     return 0;
 530 }