all: updated FSF address in GPL text
[sip-router] / modules / osp / orig_transaction.c
1 /*
2  * Kamailio osp module. 
3  *
4  * This module enables Kamailio to communicate with an Open Settlement 
5  * Protocol (OSP) server.  The Open Settlement Protocol is an ETSI 
6  * defined standard for Inter-Domain VoIP pricing, authorization
7  * and usage exchange.  The technical specifications for OSP 
8  * (ETSI TS 101 321 V4.1.1) are available at www.etsi.org.
9  *
10  * Uli Abend was the original contributor to this module.
11  * 
12  * Copyright (C) 2001-2005 Fhg Fokus
13  *
14  * This file is part of Kamailio, a free SIP server.
15  *
16  * Kamailio is free software; you can redistribute it and/or modify
17  * it under the terms of the GNU General Public License as published by
18  * the Free Software Foundation; either version 2 of the License, or
19  * (at your option) any later version
20  *
21  * Kamailio is distributed in the hope that it will be useful,
22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
24  * GNU General Public License for more details.
25  *
26  * You should have received a copy of the GNU General Public License
27  * along with this program; if not, write to the Free Software
28  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
29  */
30
31 #include <string.h>
32 #include <osp/osp.h>
33 #include "../../dset.h"
34 #include "../../usr_avp.h"
35 #include "../../mem/mem.h"
36 #include "../../modules/siputils/siputils.h"
37 #include "orig_transaction.h"
38 #include "destination.h"
39 #include "osptoolkit.h"
40 #include "sipheader.h"
41 #include "usage.h"
42
43 extern char* _osp_device_ip;
44 extern char* _osp_device_port;
45 extern int _osp_max_dests;
46 extern int _osp_redir_uri;
47 extern int_str _osp_snid_avpname;
48 extern unsigned short _osp_snid_avptype;
49 extern OSPTPROVHANDLE _osp_provider;
50 extern siputils_api_t osp_siputils;
51
52 const int OSP_FIRST_ROUTE = 1;
53 const int OSP_NEXT_ROUTE = 0;
54 const int OSP_MAIN_ROUTE = 1;
55 const int OSP_BRANCH_ROUTE = 0;
56 const str OSP_CALLING_NAME = {"_osp_calling_translated_", 24};
57
58 static int ospLoadRoutes(OSPTTRANHANDLE transaction, int destcount, char* source, char* sourcedev, char* origcalled, time_t authtime);
59 static int ospPrepareDestination(struct sip_msg* msg, int isfirst, int type, int format);
60 static int ospSetRpid(struct sip_msg* msg, osp_dest* dest);
61
62 /*
63  * Get routes from AuthRsp
64  * param transaction Transaction handle
65  * param destcount Expected destination count
66  * param source Source IP
67  * param sourcedev Source device IP
68  * param origcalled Original called number
69  * param authtime Request authorization time
70  * return 0 success, -1 failure
71  */
72 static int ospLoadRoutes(
73     OSPTTRANHANDLE transaction, 
74     int destcount, 
75     char* source, 
76     char* sourcedev, 
77     char* origcalled, 
78     time_t authtime)
79 {
80     int count;
81     int errorcode;
82     osp_dest* dest;
83     osp_dest dests[OSP_DEF_DESTS];
84     OSPE_DEST_PROT protocol;
85     OSPE_DEST_OSP_ENABLED enabled;
86     int result = 0;
87     
88     for (count = 0; count < destcount; count++) {
89         /* This is necessary because we will save destinations in reverse order */
90         dest = ospInitDestination(&dests[count]);
91
92         if (dest == NULL) {
93             result = -1;
94             break;
95         }
96
97         dest->destinationCount = count + 1;
98         strncpy(dest->origcalled, origcalled, sizeof(dest->origcalled) - 1);
99
100         if (count == 0) {
101             errorcode = OSPPTransactionGetFirstDestination(
102                 transaction,
103                 sizeof(dest->validafter),
104                 dest->validafter,
105                 dest->validuntil,
106                 &dest->timelimit,
107                 &dest->callidsize,
108                 (void*)dest->callid,
109                 sizeof(dest->called),
110                 dest->called,
111                 sizeof(dest->calling),
112                 dest->calling,
113                 sizeof(dest->host),
114                 dest->host,
115                 sizeof(dest->destdev),
116                 dest->destdev,
117                 &dest->tokensize,
118                 dest->token);
119         } else {
120             errorcode = OSPPTransactionGetNextDestination(
121                 transaction,
122                 0,
123                 sizeof(dest->validafter),
124                 dest->validafter,
125                 dest->validuntil,
126                 &dest->timelimit,
127                 &dest->callidsize,
128                 (void*)dest->callid,
129                 sizeof(dest->called),
130                 dest->called,
131                 sizeof(dest->calling),
132                 dest->calling,
133                 sizeof(dest->host),
134                 dest->host,
135                 sizeof(dest->destdev),
136                 dest->destdev,
137                 &dest->tokensize,
138                 dest->token);
139         }
140         
141         if (errorcode != OSPC_ERR_NO_ERROR) {
142             LM_ERR("failed to load routes (%d) expected '%d' current '%d'\n", 
143                 errorcode, 
144                 destcount, 
145                 count);
146             result = -1;
147             break;
148         }
149
150         errorcode = OSPPTransactionGetDestProtocol(transaction, &protocol);
151         if (errorcode != OSPC_ERR_NO_ERROR) {
152             /* This does not mean an ERROR. The OSP server may not support OSP 2.1.1 */
153             LM_DBG("cannot get dest protocol (%d)\n", errorcode);
154             protocol = OSPE_DEST_PROT_SIP;
155         }
156         switch (protocol) {
157             case OSPE_DEST_PROT_H323_LRQ:
158             case OSPE_DEST_PROT_H323_SETUP:
159             case OSPE_DEST_PROT_IAX:
160                 dest->supported = 0;
161                 break;
162             case OSPE_DEST_PROT_SIP:
163             case OSPE_DEST_PROT_UNDEFINED:
164             case OSPE_DEST_PROT_UNKNOWN:
165             default:
166                 dest->supported = 1;
167                 break;
168         }
169
170         errorcode = OSPPTransactionIsDestOSPEnabled(transaction, &enabled);
171         if (errorcode != OSPC_ERR_NO_ERROR) {
172             /* This does not mean an ERROR. The OSP server may not support OSP 2.1.1 */
173             LM_DBG("cannot get dest OSP version (%d)\n", errorcode);
174         } else if (enabled == OSPE_OSP_FALSE) {
175             /* Destination device does not support OSP. Do not send token to it */
176             dest->token[0] = '\0';
177             dest->tokensize = 0;
178         }
179
180         errorcode = OSPPTransactionGetDestNetworkId(transaction, dest->networkid);
181         if (errorcode != OSPC_ERR_NO_ERROR) {
182             /* This does not mean an ERROR. The OSP server may not support OSP 2.1.1 */
183             LM_DBG("cannot get dest network ID (%d)\n", errorcode);
184             dest->networkid[0] = '\0';
185         }
186
187         strncpy(dest->source, source, sizeof(dest->source) - 1);
188         strncpy(dest->srcdev, sourcedev, sizeof(dest->srcdev) - 1);
189         dest->type = OSPC_SOURCE;
190         dest->transid = ospGetTransactionId(transaction);
191         dest->authtime = authtime;
192
193         LM_INFO("get destination '%d': "
194             "valid after '%s' "
195             "valid until '%s' "
196             "time limit '%d' seconds "
197             "call id '%.*s' "
198             "calling '%s' "
199             "called '%s' "
200             "host '%s' "
201             "supported '%d' "
202             "network id '%s' "
203             "token size '%d'\n",
204             count, 
205             dest->validafter, 
206             dest->validuntil, 
207             dest->timelimit, 
208             dest->callidsize, 
209             dest->callid, 
210             dest->calling, 
211             dest->called, 
212             dest->host, 
213             dest->supported,
214             dest->networkid, 
215             dest->tokensize);
216     }
217
218     /* 
219      * Save destination in reverse order,
220      * when we start searching avps the destinations
221      * will be in order 
222      */
223     if (result == 0) {
224         for(count = destcount -1; count >= 0; count--) {
225             if (ospSaveOrigDestination(&dests[count]) == -1) {
226                 LM_ERR("failed to save originate destination\n");
227                 /* Report terminate CDR */
228                 ospRecordEvent(0, 500);
229                 result = -1;
230                 break;
231             }
232         }
233     }
234
235     return result;
236 }
237
238 /*
239  * Request OSP authorization and routeing
240  * param msg SIP message
241  * param ignore1
242  * param ignore2
243  * return MODULE_RETURNCODE_TRUE success, MODULE_RETURNCODE_FALSE failure, MODULE_RETURNCODE_ERROR error
244  */
245 int ospRequestRouting(
246     struct sip_msg* msg, 
247     char* ignore1, 
248     char* ignore2)
249 {
250     int errorcode;
251     time_t authtime;
252     char called[OSP_E164BUF_SIZE];
253     char calling[OSP_E164BUF_SIZE];
254     char sourcedev[OSP_STRBUF_SIZE];
255     char deviceinfo[OSP_STRBUF_SIZE];
256     struct usr_avp* snidavp = NULL;
257     int_str snidval;
258     char snid[OSP_STRBUF_SIZE];
259     unsigned int callidnumber = 1;
260     OSPTCALLID* callids[callidnumber];
261     unsigned int logsize = 0;
262     char* detaillog = NULL;
263     const char** preferred = NULL;
264     unsigned int destcount;
265     OSPTTRANHANDLE transaction = -1;
266     int result = MODULE_RETURNCODE_FALSE;
267
268     authtime = time(NULL);
269
270     destcount = _osp_max_dests;
271
272     if ((errorcode = OSPPTransactionNew(_osp_provider, &transaction)) != OSPC_ERR_NO_ERROR) {
273         LM_ERR("failed to create new OSP transaction (%d)\n", errorcode);
274     } else if ((ospGetRpidUserpart(msg, calling, sizeof(calling)) != 0) &&
275         (ospGetFromUserpart(msg, calling, sizeof(calling)) != 0)) 
276     {
277         LM_ERR("failed to extract calling number\n");
278     } else if ((ospGetUriUserpart(msg, called, sizeof(called)) != 0) &&
279         (ospGetToUserpart(msg, called, sizeof(called)) != 0)) 
280     {
281         LM_ERR("failed to extract called number\n");
282     } else if (ospGetCallId(msg, &(callids[0])) != 0) {
283         LM_ERR("failed to extract call id\n");
284     } else if (ospGetSourceAddress(msg, sourcedev, sizeof(sourcedev)) != 0) {
285         LM_ERR("failed to extract source deivce address\n");
286     } else {
287         ospConvertAddress(sourcedev, deviceinfo, sizeof(deviceinfo));
288
289         if ((_osp_snid_avpname.n != 0) &&
290             ((snidavp = search_first_avp(_osp_snid_avptype, _osp_snid_avpname, &snidval, 0)) != NULL) &&
291             (snidavp->flags & AVP_VAL_STR) && (snidval.s.s && snidval.s.len)) 
292         {
293             snprintf(snid, sizeof(snid), "%.*s", snidval.s.len, snidval.s.s);
294             OSPPTransactionSetNetworkIds(transaction, snid, "");
295         } else {
296             snid[0] = '\0';
297         }
298
299         LM_INFO("request auth and routing for: "
300             "source_ip '%s' "
301             "source_port '%s' "
302             "source_dev '%s' "
303             "source_networkid '%s' "
304             "calling '%s' "
305             "called '%s' "
306             "call_id '%.*s' "
307             "dest_count '%d'\n",
308             _osp_device_ip,
309             _osp_device_port,
310             deviceinfo,         /* in "[x.x.x.x]" or host.domain format */
311             snid,
312             calling,
313             called,
314             callids[0]->ospmCallIdLen,
315             callids[0]->ospmCallIdVal,
316             destcount
317         );    
318
319         /* try to request authorization */
320         errorcode = OSPPTransactionRequestAuthorisation(
321             transaction,       /* transaction handle */
322             _osp_device_ip,    /* from the configuration file */
323             deviceinfo,        /* source device of call, protocol specific, in OSP format */
324             calling,           /* calling number in nodotted e164 notation */
325             OSPC_E164,         /* calling number format */
326             called,            /* called number */
327             OSPC_E164,         /* called number format */
328             "",                /* optional username string, used if no number */
329             callidnumber,      /* number of call ids, here always 1 */
330             callids,           /* sized-1 array of call ids */
331             preferred,         /* preferred destinations, here always NULL */
332             &destcount,        /* max destinations, after call dest_count */
333             &logsize,          /* size allocated for detaillog (next param) 0=no log */
334             detaillog);        /* memory location for detaillog to be stored */
335
336         if ((errorcode == OSPC_ERR_NO_ERROR) &&
337             (ospLoadRoutes(transaction, destcount, _osp_device_ip, sourcedev, called, authtime) == 0))
338         {
339             LM_INFO("there are '%d' OSP routes, call_id '%.*s'\n",
340                 destcount,
341                 callids[0]->ospmCallIdLen,
342                 callids[0]->ospmCallIdVal);
343             result = MODULE_RETURNCODE_TRUE;
344         } else {
345             LM_ERR("failed to request auth and routing (%d), call_id '%.*s'\n",
346                 errorcode,
347                 callids[0]->ospmCallIdLen,
348                 callids[0]->ospmCallIdVal);
349             switch (errorcode) {
350                 case OSPC_ERR_TRAN_ROUTE_BLOCKED:
351                     result = -403;
352                     break;
353                 case OSPC_ERR_TRAN_ROUTE_NOT_FOUND:
354                     result = -404;
355                     break;
356                 case OSPC_ERR_NO_ERROR:
357                     /* AuthRsp ok but ospLoadRoutes fails */
358                     result = MODULE_RETURNCODE_ERROR;
359                     break;
360                 default:
361                     result = MODULE_RETURNCODE_FALSE;
362                     break;
363             }
364         }
365     }
366
367     if (callids[0] != NULL) {
368         OSPPCallIdDelete(&(callids[0]));
369     }
370
371     if (transaction != -1) {
372         OSPPTransactionDelete(transaction);
373     }
374     
375     return result;
376 }
377
378 /*
379  * Check if there is a route
380  * param msg SIP message
381  * param ignore1
382  * param ignore2
383  * return MODULE_RETURNCODE_TRUE success, MODULE_RETURNCODE_FALSE failure
384  */
385 int ospCheckRoute(
386     struct sip_msg* msg, 
387     char* ignore1, 
388     char* ignore2)
389 {
390     if (ospCheckOrigDestination() == 0) {
391         return MODULE_RETURNCODE_TRUE;
392     } else {
393         return MODULE_RETURNCODE_FALSE;
394     }
395 }
396
397 /*
398  * Create RPID AVP
399  * param msg SIP message
400  * param dest Destination structure
401  * return 0 success, 1 calling number same, -1 failure
402  */
403 static int ospSetRpid(
404     struct sip_msg* msg, 
405     osp_dest* dest)
406 {
407     str rpid;
408     char calling[OSP_STRBUF_SIZE];
409     char source[OSP_STRBUF_SIZE];
410     char buffer[OSP_STRBUF_SIZE];
411     int result = -1;
412
413     if ((ospGetRpidUserpart(msg, calling, sizeof(calling)) != 0) &&
414         (ospGetFromUserpart(msg, calling, sizeof(calling)) !=0))
415     {
416         LM_ERR("failed to extract calling number\n");
417         return result;
418     } 
419
420     if (strcmp(calling, dest->calling) == 0) {
421         /* Do nothing for this case */ 
422         result = 1;
423     } else if ((osp_siputils.rpid_avp.s.s == NULL)
424                                 || (osp_siputils.rpid_avp.s.len == 0)) {
425         LM_WARN("rpid_avp is not foune, cannot set rpid avp\n");
426         result = -1;
427     } else {
428         if (dest->source[0] == '[') {
429             /* Strip "[]" */
430             memset(source, 0, sizeof(source));
431             strncpy(source, &dest->source[1], sizeof(source) - 1);
432             source[strlen(source) - 1] = '\0';
433         }
434     
435         snprintf(
436             buffer, 
437             sizeof(buffer), 
438             "\"%s\" <sip:%s@%s>", 
439             dest->calling, 
440             dest->calling, 
441             source);
442
443         rpid.s = buffer;
444         rpid.len = strlen(buffer);
445         add_avp(osp_siputils.rpid_avp_type | AVP_VAL_STR,
446                                 (int_str)osp_siputils.rpid_avp, (int_str)rpid);
447
448         result = 0;
449     }
450
451     return result;
452 }
453
454 /*
455  * Check if the calling number is translated.
456  *     This function checks the avp set by ospPrepareDestination.
457  * param msg SIP message
458  * param ignore1
459  * param ignore2
460  * return MODULE_RETURNCODE_TRUE calling number translated MODULE_RETURNCODE_FALSE without transaltion
461  */
462 int ospCheckTranslation(
463     struct sip_msg* msg, 
464     char* ignore1, 
465     char* ignore2)
466 {
467     int_str callingval;
468     int result = MODULE_RETURNCODE_FALSE;
469
470     if (search_first_avp(AVP_NAME_STR, (int_str)OSP_CALLING_NAME, &callingval, 0) != NULL) {
471         if (callingval.n == 0) {
472             LM_DBG("the calling number does not been translated\n");
473         } else {
474             LM_DBG("the calling number is translated\n");
475             result = MODULE_RETURNCODE_TRUE;
476         }
477     } else {
478         LM_ERR("there is not calling translation avp\n");
479     }
480
481     return result;
482 }
483
484 /*
485  * Build SIP message for destination
486  * param msg SIP message
487  * param isfirst Is first destination
488  * param type Main or branch route block
489  * param format URI format
490  * return MODULE_RETURNCODE_TRUE success MODULE_RETURNCODE_FALSE failure
491  */
492 static int ospPrepareDestination(
493     struct sip_msg* msg, 
494     int isfirst,
495     int type,
496     int format)
497 {
498     int_str val;
499     int res;
500     str newuri = {NULL, 0};
501     int result = MODULE_RETURNCODE_FALSE;
502
503     osp_dest* dest = ospGetNextOrigDestination();
504
505     if (dest != NULL) {
506         ospRebuildDestionationUri(&newuri, dest->called, dest->host, "", format);
507
508         LM_INFO("prepare route to URI '%.*s' for call_id '%.*s' transaction_id '%llu'\n",
509             newuri.len,
510             newuri.s,
511             dest->callidsize,
512             dest->callid,
513             dest->transid);
514
515         if (type == OSP_MAIN_ROUTE) {
516             if (isfirst == OSP_FIRST_ROUTE) {
517                 rewrite_uri(msg, &newuri);
518             } else {
519                 km_append_branch(msg, &newuri, NULL, NULL, Q_UNSPECIFIED, 0, NULL);
520             }
521             /* Do not add route specific OSP information */
522             result = MODULE_RETURNCODE_TRUE;
523         } else if (type == OSP_BRANCH_ROUTE) {
524             /* For branch route, add route specific OSP information */
525
526             /* Update the Request-Line */
527             rewrite_uri(msg, &newuri);
528
529             /* Add OSP token header */
530             ospAddOspHeader(msg, dest->token, dest->tokensize);
531
532             /* Add branch-specific OSP Cookie */
533             ospRecordOrigTransaction(msg, dest->transid, dest->srcdev, dest->calling, dest->called, dest->authtime, dest->destinationCount);
534
535             /* Add rpid avp for calling number translation */
536             res = ospSetRpid(msg, dest);
537             switch (res) {
538                 case 0:
539                     /* Calling number is translated */
540                     val.n = 1;
541                     add_avp(AVP_NAME_STR, (int_str)OSP_CALLING_NAME, val);
542                     break;
543                 default:
544                     LM_DBG("cannot set rpid avp\n");
545                     /* Just like without calling translation */
546                 case 1:
547                     /* Calling number does not been translated */
548                     val.n = 0;
549                     add_avp(AVP_NAME_STR, (int_str)OSP_CALLING_NAME, val);
550                     break;
551             }
552
553             result = MODULE_RETURNCODE_TRUE;
554         } else {
555             LM_ERR("unsupported route block type\n");
556         }
557     } else {
558         LM_DBG("there is no more routes\n");
559         ospReportOrigSetupUsage();
560     }
561
562     if (newuri.len > 0) {
563         pkg_free(newuri.s);
564     }
565     
566     return result;
567 }
568
569 /*
570  * Prepare OSP route
571  *     This function only works in branch route block.
572  *     This function is only for Kamailio.
573  * param msg SIP message
574  * param ignore1
575  * param ignore2
576  * return MODULE_RETURNCODE_TRUE success, MODULE_RETURNCODE_FALSE failure
577  */
578 int ospPrepareRoute(
579     struct sip_msg* msg, 
580     char* ignore1, 
581     char* ignore2)
582 {
583     int result = MODULE_RETURNCODE_TRUE;
584
585     /* The first parameter will be ignored */
586     result = ospPrepareDestination(msg, OSP_FIRST_ROUTE, OSP_BRANCH_ROUTE, 0);
587
588     return result;
589 }
590
591 /*
592  * Prepare all OSP routes
593  *     This function does not work in branch route block.
594  * param msg SIP message
595  * param ignore1
596  * param ignore2
597  * return MODULE_RETURNCODE_TRUE success, MODULE_RETURNCODE_FALSE failure
598  */
599 int ospPrepareAllRoutes(
600     struct sip_msg* msg, 
601     char* ignore1, 
602     char* ignore2)
603 {
604     int result = MODULE_RETURNCODE_TRUE;
605
606     for(result = ospPrepareDestination(msg, OSP_FIRST_ROUTE, OSP_MAIN_ROUTE, _osp_redir_uri);
607         result == MODULE_RETURNCODE_TRUE;
608         result = ospPrepareDestination(msg, OSP_NEXT_ROUTE, OSP_MAIN_ROUTE, _osp_redir_uri))
609     {
610     }
611
612     return MODULE_RETURNCODE_TRUE;
613 }
614