sr-dev

sr-dev@lists.kamailio.org

15 participants
44239 discussions

git:master: core: include replaced with include_file

by Daniel-Constantin Mierla

Module: sip-router Branch: master Commit: 1c9c433f7be395652bb28c5af61d2f64f33da926 URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=1c9c433… Author: Daniel-Constantin Mierla <miconda(a)gmail.com> Committer: Daniel-Constantin Mierla <miconda(a)gmail.com> Date: Thu Sep 3 13:18:31 2009 +0300 core: include replaced with include_file - due to opinions expressed on mailing list suggesting it reflects better the meaning --- cfg.lex | 10 +++++----- 1 files changed, 5 insertions(+), 5 deletions(-) diff --git a/cfg.lex b/cfg.lex index a5941e4..9723877 100644 --- a/cfg.lex +++ b/cfg.lex @@ -156,7 +156,7 @@ /* start conditions */ %x STRING1 STRING2 STR_BETWEEN COMMENT COMMENT_LN ATTR SELECT AVP_PVAR PVAR_P -%x PVARID INCL +%x PVARID INCLF /* config script types : #!SER or #!KAMAILIO or #!MAX_COMPAT */ SER_CFG SER @@ -220,7 +220,7 @@ CASE "case" DEFAULT "default" WHILE "while" -INCLUDE "include" +INCLUDEFILE "include_file" /*ACTION LVALUES*/ URIHOST "uri:host" @@ -577,7 +577,7 @@ EAT_ABLE [\ \t\b\r] <INITIAL>{DEFAULT} { count(); yylval.strval=yytext; return DEFAULT; } <INITIAL>{WHILE} { count(); yylval.strval=yytext; return WHILE; } -<INITIAL>{INCLUDE} { count(); BEGIN(INCL); } +<INITIAL>{INCLUDEFILE} { count(); BEGIN(INCLF); } <INITIAL>{URIHOST} { count(); yylval.strval=yytext; return URIHOST; } <INITIAL>{URIPORT} { count(); yylval.strval=yytext; return URIPORT; } @@ -1120,8 +1120,8 @@ EAT_ABLE [\ \t\b\r] <SELECT>. { unput(yytext[0]); state = INITIAL_S; BEGIN(INITIAL); } /* Rescan the token in INITIAL state */ -<INCL>[ \t]* /* eat the whitespace */ -<INCL>[^ \t\n]+ { /* get the include file name */ +<INCLF>[ \t]* /* eat the whitespace */ +<INCLF>[^ \t\n]+ { /* get the include file name */ if(sr_push_yy_state(yytext)<0) exit(-1); BEGIN(INITIAL);

15 years, 4 months

CVS:commitlog: sip_router/cfg cfg_struct.c cfg_struct.h sip_router/doc cfg.txt sip_router main.c sip_router/modules/cpl-c cpl.c sip_router/modules/ctl ctl.c sip_router/modules/fifo fifo.c sip_router/modules/jabber jabber.c sip_router/modules/nathelper ...

by Miklos Tirpak

tirpi 2009/09/03 11:56:19 CEST SER CVS Repository Modified files: cfg cfg_struct.c cfg_struct.h doc cfg.txt . main.c modules/cpl-c cpl.c modules/ctl ctl.c modules/fifo fifo.c modules/jabber jabber.c modules/nathelper natping.c modules/sms sms.c Log: cfg framework: fix the initialization of child processes (backport from sip-router) The number of child processes that keep updating their local configuration needs to be known before any child process is forked. Before this the child processes increased the reference counter of the callback function list items after forking. If a child process was forked "too fast" then it freed the list before the other processes had a chance to refer to the list item. The result was that some child processes missed the initial configuration changes. (Those changes that had per-child process callback defined.) Revision Changes Path 1.14 +40 -3 sip_router/cfg/cfg_struct.c http://cvs.berlios.de/cgi-bin/viewcvs.cgi/ser/sip_router/cfg/cfg_struct.c.d… 1.8 +18 -2 sip_router/cfg/cfg_struct.h http://cvs.berlios.de/cgi-bin/viewcvs.cgi/ser/sip_router/cfg/cfg_struct.h.d… 1.12 +16 -3 sip_router/doc/cfg.txt http://cvs.berlios.de/cgi-bin/viewcvs.cgi/ser/sip_router/doc/cfg.txt.diff?r… 1.276 +28 -2 sip_router/main.c http://cvs.berlios.de/cgi-bin/viewcvs.cgi/ser/sip_router/main.c.diff?r1=1.2… 1.66 +5 -1 sip_router/modules/cpl-c/cpl.c http://cvs.berlios.de/cgi-bin/viewcvs.cgi/ser/sip_router/modules/cpl-c/cpl.… 1.6 +4 -1 sip_router/modules/ctl/ctl.c http://cvs.berlios.de/cgi-bin/viewcvs.cgi/ser/sip_router/modules/ctl/ctl.c.… 1.7 +8 -2 sip_router/modules/fifo/fifo.c http://cvs.berlios.de/cgi-bin/viewcvs.cgi/ser/sip_router/modules/fifo/fifo.… 1.64 +10 -3 sip_router/modules/jabber/jabber.c http://cvs.berlios.de/cgi-bin/viewcvs.cgi/ser/sip_router/modules/jabber/jab… 1.26 +6 -3 sip_router/modules/nathelper/natping.c http://cvs.berlios.de/cgi-bin/viewcvs.cgi/ser/sip_router/modules/nathelper/… 1.42 +5 -1 sip_router/modules/sms/sms.c http://cvs.berlios.de/cgi-bin/viewcvs.cgi/ser/sip_router/modules/sms/sms.c.…

15 years, 4 months

git:andrei/rpc_async: core: rpc capabilities and delayed reply api

by Andrei Pelinescu-Onciul

Module: sip-router Branch: andrei/rpc_async Commit: e256ce91db53172264a6e42cfd5040b30dada526 URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=e256ce9… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Thu Jul 30 15:40:42 2009 +0200 core: rpc capabilities and delayed reply api - added a new rpc function for interrogating the current rpc transport capabilities (for now the only extra capability is RPC_DELAYED_REPLY). - added a new special delayed reply rpc context and rpc functions hooks for creating and closing it. --- rpc.h | 25 ++++++++++++++++++++++++- 1 files changed, 24 insertions(+), 1 deletions(-) diff --git a/rpc.h b/rpc.h index 18e767e..1434146 100644 --- a/rpc.h +++ b/rpc.h @@ -37,7 +37,13 @@ enum rpc_flags { RET_ARRAY = (1 << 0), RET_VALUE = (1 << 1) }; - + +typedef enum rpc_capabilities { + RPC_DELAYED_REPLY = (1 <<0) /* delayed reply support */ +} rpc_capabilities_t; + +struct rpc_delayed_ctx; + /* Send the result to the caller */ typedef int (*rpc_send_f)(void* ctx); /* Send the reply to the client */ @@ -49,6 +55,13 @@ typedef int (*rpc_struct_add_f)(void* ctx, char* fmt, ...); /* Cr typedef int (*rpc_struct_scan_f)(void* ctx, char* fmt, ...); /* Scan attributes of a structure */ typedef int (*rpc_struct_printf_f)(void* ctx, char* name, char* fmt, ...); /* Struct version of rpc_printf */ +/* returns the supported capabilities */ +typedef rpc_capabilities_t (*rpc_capabilities_f)(void* ctx); +/* create a special "context" for delayed replies */ +typedef struct rpc_delayed_ctx* (*rpc_delayed_ctx_new_f)(void* ctx); +/* close the special "context" for delayed replies */ +typedef void (*rpc_delayed_ctx_close_f)(struct rpc_delayed_ctx* dctx); + /* * RPC context, this is what RPC functions get as a parameter and use * it to obtain the value of the parameters of the call and reference @@ -63,9 +76,19 @@ typedef struct rpc { rpc_struct_add_f struct_add; rpc_struct_scan_f struct_scan; rpc_struct_printf_f struct_printf; + rpc_capabilities_f capabilities; + rpc_delayed_ctx_new_f delayed_ctx_new; + rpc_delayed_ctx_close_f delayed_ctx_close; } rpc_t; +typedef struct rpc_delayed_ctx{ + rpc_t rpc; + void* reply_ctx; + /* more private data might follow */ +} rpc_delayed_ctx_t; + + /* * RPC Function Prototype */

15 years, 4 months

git:andrei/rpc_async: xmlrpc(s): basic support for delayed replies

by Andrei Pelinescu-Onciul

Module: sip-router Branch: andrei/rpc_async Commit: 4dc222c20c93899a35046c1559a94618fb01e84d URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=4dc222c… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Thu Jul 30 15:45:11 2009 +0200 xmlrpc(s): basic support for delayed replies Support for delaying replies with a few caveats: - a special delayed reply context must be created first (via the new rpc hooks). - a function using this context does not have any access to the original rpc message (so if it needs any parameters from the original rpc request it must pass them somehow to the function that will use the delayed reply context). - a delayed reply context can be used _only_ from one process (is not possible to add part of the reply from one process and another part from another process). - when finished the delayed reply context _must_ be closed (using the new rpc hook). This must be done from the same process in which the delayed reply context was used. --- modules_s/xmlrpc/xmlrpc.c | 140 ++++++++++++++++++++++++++++++++++++++++++++- 1 files changed, 139 insertions(+), 1 deletions(-) diff --git a/modules_s/xmlrpc/xmlrpc.c b/modules_s/xmlrpc/xmlrpc.c index c140626..f386a88 100644 --- a/modules_s/xmlrpc/xmlrpc.c +++ b/modules_s/xmlrpc/xmlrpc.c @@ -60,6 +60,7 @@ #include "../../action.h" /* run_actions */ #include "../../script_cb.h" /* exec_*_script_cb */ #include "../../route.h" /* route_get */ +#include "../../sip_msg_clone.h" /* sip_msg_shm_clone */ #include "http.h" /** @addtogroup xmlrpc @@ -316,6 +317,8 @@ typedef struct rpc_ctx { received */ struct xmlrpc_reply reply; /**< XML-RPC reply to be sent to the client */ struct rpc_struct* structs; /**< Structures to be added to the reply */ + int msg_shm_block_size; /**< non-zero for delayed reply contexts with + shm cloned msgs */ int reply_sent; /**< The flag is set after a reply is sent, this prevents a single reply being sent twice */ @@ -330,6 +333,11 @@ typedef struct rpc_ctx { } rpc_ctx_t; +/* extra rpc_ctx_t flags */ +/* first 8 bits reserved for rpc flags (e.g. RET_ARRAY) */ +#define XMLRPC_DELAYED_CTX_F 256 +#define XMLRPC_DELAYED_REPLY_F 512 + /** The structure represents a XML-RPC document structure. * * This is the data structure that represents XML-RPC structures that are sent @@ -424,6 +432,9 @@ struct module_exports exports = { #define ESC_AMP "&" +static void clean_context(rpc_ctx_t* ctx); + + /** Adds arbitrary text to the XML-RPC reply being constructed, special * characters < and & will be escaped. * @@ -606,6 +617,21 @@ static int init_xmlrpc_reply(struct xmlrpc_reply* reply) } + +/* if this a delayed reply context, and it's never been use before, fix it */ +static int fix_delayed_reply_ctx(rpc_ctx_t* ctx) +{ + if ((ctx->flags & XMLRPC_DELAYED_CTX_F) && (ctx->reply.buf.s==0)){ + if (init_xmlrpc_reply(&ctx->reply) <0) return -1; + add_xmlrpc_reply(&ctx->reply, &success_prefix); + if (ctx->flags & RET_ARRAY) + return add_xmlrpc_reply(&ctx->reply, &array_prefix); + } + return 0; +} + + + /** Free all memory used by the XML-RPC reply structure. */ static void clean_xmlrpc_reply(struct xmlrpc_reply* reply) { @@ -990,6 +1016,7 @@ static int rpc_add(rpc_ctx_t* ctx, char* fmt, ...) struct xmlrpc_reply* reply; struct rpc_struct* p; + fix_delayed_reply_ctx(ctx); va_start(ap, fmt); reply = &ctx->reply; @@ -1479,6 +1506,7 @@ static int rpc_printf(rpc_ctx_t* ctx, char* fmt, ...) str s; struct xmlrpc_reply* reply; + fix_delayed_reply_ctx(ctx); reply = &ctx->reply; buf = (char*)pkg_malloc(RPC_BUF_SIZE); if (!buf) { @@ -1746,6 +1774,111 @@ static int rpc_struct_scan(struct rpc_struct* s, char* fmt, ...) } +/** Returns the RPC capabilities supported by the xmlrpc driver. + */ +static rpc_capabilities_t rpc_capabilities(rpc_ctx_t* ctx) +{ + return RPC_DELAYED_REPLY; +} + + +/** Returns a new "delayed reply" context. + * Creates a new delayed reply context in shm and returns it. + * @return 0 - not supported, already replied, or no more memory; + * !=0 pointer to the special delayed ctx. + * Note1: one should use the returned ctx reply context to build a reply and + * when finished call rpc_delayed_ctx_close(). + * Note2: adding pieces to the reply in different processes is not supported. + */ +static struct rpc_delayed_ctx* rpc_delayed_ctx_new(rpc_ctx_t* ctx) +{ + struct rpc_delayed_ctx* ret; + int size; + rpc_ctx_t* r_ctx; + struct sip_msg* shm_msg; + int len; + + ret=0; + shm_msg=0; + + if (ctx->reply_sent) + return 0; /* no delayed reply if already replied */ + /* clone the sip msg */ + shm_msg=sip_msg_shm_clone(ctx->msg, &len, 1); + if (shm_msg==0) + goto error; + + /* alloc into one block */ + size=ROUND_POINTER(sizeof(*ret))+sizeof(rpc_ctx_t); + if ((ret=shm_malloc(size))==0) + goto error; + memset(ret, 0, size); + ret->rpc=func_param; + ret->reply_ctx=(char*)ret+ROUND_POINTER(sizeof(*ret)); + r_ctx=ret->reply_ctx; + r_ctx->flags=ctx->flags | XMLRPC_DELAYED_CTX_F; + ctx->flags |= XMLRPC_DELAYED_REPLY_F; + r_ctx->msg=shm_msg; + r_ctx->msg_shm_block_size=len; + + return ret; +error: + if (shm_msg) + shm_free(shm_msg); + if (ret) + shm_free(ret); + return 0; +} + + + +/** Closes a "delayed reply" context and sends the reply. + * If no reply has been sent the reply will be built and sent automatically. + * See the notes from rpc_new_delayed_ctx() + */ +static void rpc_delayed_ctx_close(struct rpc_delayed_ctx* dctx) +{ + rpc_ctx_t* r_ctx; + struct hdr_field* hdr; + + r_ctx=dctx->reply_ctx; + if (unlikely(!(r_ctx->flags & XMLRPC_DELAYED_CTX_F))){ + BUG("reply ctx not marked as async/delayed\n"); + goto error; + } + if (fix_delayed_reply_ctx(r_ctx)<0) + goto error; + if (!r_ctx->reply_sent){ + rpc_send(r_ctx); + } +error: + clean_context(r_ctx); + /* collect possible garbage (e.g. generated by structures) */ + collect_garbage(); + /* free added lumps (rpc_send adds a body lump) */ + del_nonshm_lump( &(r_ctx->msg->add_rm) ); + del_nonshm_lump( &(r_ctx->msg->body_lumps) ); + del_nonshm_lump_rpl( &(r_ctx->msg->reply_lump) ); + /* free header's parsed structures that were added by failure handlers */ + for( hdr=r_ctx->msg->headers ; hdr ; hdr=hdr->next ) { + if ( hdr->parsed && hdr_allocs_parse(hdr) && + (hdr->parsed<(void*)r_ctx->msg || + hdr->parsed>=(void*)(r_ctx->msg+r_ctx->msg_shm_block_size))) { + /* header parsed filed doesn't point inside uas.request memory + * chunck -> it was added by failure funcs.-> free it as pkg */ + DBG("DBG:free_faked_req: removing hdr->parsed %d\n", + hdr->type); + clean_hdr_field(hdr); + hdr->parsed = 0; + } + } + shm_free(r_ctx->msg); + r_ctx->msg=0; + dctx->reply_ctx=0; + shm_free(dctx); +} + + /** Starts parsing XML-RPC document, get the name of the method to be called * and position the cursor at the first parameter in the document. */ @@ -1832,6 +1965,7 @@ static void close_doc(rpc_ctx_t* ctx) static int init_context(rpc_ctx_t* ctx, sip_msg_t* msg) { ctx->msg = msg; + ctx->msg_shm_block_size=0; ctx->method = 0; ctx->reply_sent = 0; ctx->act_param = 0; @@ -2066,7 +2200,7 @@ static int dispatch_rpc(sip_msg_t* msg, char* s1, char* s2) skip: /* The function may have sent the reply itself */ - if (!ctx.reply_sent) { + if (!ctx.reply_sent && !(ctx.flags&XMLRPC_DELAYED_REPLY_F)) { ret = rpc_send(&ctx); } clean_context(&ctx); @@ -2212,6 +2346,10 @@ static int mod_init(void) func_param.struct_add = (rpc_struct_add_f)rpc_struct_add; func_param.struct_scan = (rpc_struct_scan_f)rpc_struct_scan; func_param.struct_printf = (rpc_struct_printf_f)rpc_struct_printf; + func_param.capabilities = (rpc_capabilities_f)rpc_capabilities; + func_param.delayed_ctx_new = (rpc_delayed_ctx_new_f)rpc_delayed_ctx_new; + func_param.delayed_ctx_close = + (rpc_delayed_ctx_close_f)rpc_delayed_ctx_close; register_select_table(xmlrpc_sel); /* register non-sip hooks */

15 years, 4 months

git:andrei/rpc_async: core+tm: moved sip msg clone functions to the core

by Andrei Pelinescu-Onciul

Module: sip-router Branch: andrei/rpc_async Commit: 81860287cd49b762eafb49a50a0345fc89be2b93 URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=8186028… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Thu Jul 30 15:35:37 2009 +0200 core+tm: moved sip msg clone functions to the core - moved all sip msg clone related functions to the core, since the xmlrpc modules will need them too. - renamed sip_msg_cloner() to sip_msg_shm_clone(). - msg_lump_cloner() is no longer static and returns 1 for no change, 0 for successful cloning and -1 on error. --- modules/tm/fix_lumps.h => fix_lumps.h | 1 - modules/tm/h_table.c | 2 +- modules/tm/sip_msg.c | 964 +------------------------------- modules/tm/t_fwd.c | 2 +- modules/tm/t_reply.c | 2 +- sip_msg_clone.c | 976 +++++++++++++++++++++++++++++++++ sip_msg_clone.h | 44 ++ 7 files changed, 1050 insertions(+), 941 deletions(-) Diff: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commitdiff;h=818…

15 years, 4 months

git:andrei/rpc_async: tm: async t_uac (t_uac_wait) support

by Andrei Pelinescu-Onciul

Module: sip-router Branch: andrei/rpc_async Commit: d12ab1890360072e6b1658b3f738f56a9590f872 URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=d12ab18… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Tue Sep 1 18:44:36 2009 +0200 tm: async t_uac (t_uac_wait) support t_uac_wait implemented using the new rpc "wait" support. For now the implementation is just the fifo uac updated to use rpcs. The result of the rpc call is the reply code (int) followed by a list of strings: reason phrase, request uri, next hop uri, dialog routes list (one string with all of them), rest of the reply (everything except the first line in one string). Missing parts are represented by empty strings. The current format is not yet final. It might make sense to switch to a structure if there is no backwards compatibility problem. --- modules/tm/rpc_uac.c | 167 +++++++++++++++++++++++++++++++++++++++++++++++++- 1 files changed, 165 insertions(+), 2 deletions(-) diff --git a/modules/tm/rpc_uac.c b/modules/tm/rpc_uac.c index 043fc65..3dc34a9 100644 --- a/modules/tm/rpc_uac.c +++ b/modules/tm/rpc_uac.c @@ -300,6 +300,156 @@ static char *get_hfblock(str *uri, struct hdr_field *hf, int proto, } +#define RPC_ROUTE_PREFIX "Route: " +#define RPC_ROUTE_PREFIX_LEN (sizeof(RPC_ROUTE_PREFIX)-1) +#define RPC_ROUTE_SEPARATOR ", " +#define RPC_ROUTE_SEPARATOR_LEN (sizeof(RPC_ROUTE_SEPARATOR)-1) + + +/** internal print routes into rpc reply function. + * Prints the dialog routes. It's used internally by + * rpx_print_uris (called from rpc_uac_callback()). + * @param rpc + * @param c - rpc context + * @param reply - sip reply + */ +static void rpc_print_routes(rpc_t* rpc, void* c, + dlg_t* d) +{ + rr_t* ptr; + int size; + char* buf; + char* p; + + + if (d->hooks.first_route == 0){ + rpc->add(c, "s", ""); + return; + } + size=RPC_ROUTE_PREFIX_LEN; + for (ptr=d->hooks.first_route; ptr; ptr=ptr->next) + size+=ptr->len+(ptr->next!=0)*RPC_ROUTE_SEPARATOR_LEN; + if (d->hooks.last_route) + size+=RPC_ROUTE_SEPARATOR_LEN + 1 /* '<' */ + + d->hooks.last_route->len +1 /* '>' */; + + buf=pkg_malloc(size+1); + if (buf==0){ + ERR("out of memory\n"); + rpc->add(c, "s", ""); + return; + } + p=buf; + memcpy(p, RPC_ROUTE_PREFIX, RPC_ROUTE_PREFIX_LEN); + p+=RPC_ROUTE_PREFIX_LEN; + for (ptr=d->hooks.first_route; ptr; ptr=ptr->next){ + memcpy(p, ptr->nameaddr.name.s, ptr->len); + p+=ptr->len; + if (ptr->next!=0){ + memcpy(p, RPC_ROUTE_SEPARATOR, RPC_ROUTE_SEPARATOR_LEN); + p+=RPC_ROUTE_SEPARATOR_LEN; + } + } + if (d->hooks.last_route){ + memcpy(p, RPC_ROUTE_SEPARATOR, RPC_ROUTE_SEPARATOR_LEN); + p+=RPC_ROUTE_SEPARATOR_LEN; + *p='<'; + p++; + memcpy(p, d->hooks.last_route->s, d->hooks.last_route->len); + p+=d->hooks.last_route->len; + *p='>'; + p++; + } + *p=0; + rpc->add(c, "s", buf); + pkg_free(buf); + return; +} + + +/** internal print uri into rpc reply function. + * Prints the uris into rpc reply. It's used internally by + * rpc_uac_callback(). + * @param rpc + * @param c - rpc context + * @param reply - sip reply + */ +static void rpc_print_uris(rpc_t* rpc, void* c, struct sip_msg* reply) +{ + dlg_t* dlg; + dlg=shm_malloc(sizeof(dlg_t)); + if (dlg==0){ + ERR("out of memory (shm)\n"); + return; + } + memset(dlg, 0, sizeof(dlg_t)); + if (dlg_response_uac(dlg, reply, TARGET_REFRESH_UNKNOWN) < 0) { + ERR("failure while filling dialog structure\n"); + free_dlg(dlg); + return; + } + if (dlg->state != DLG_CONFIRMED) { + free_dlg(dlg); + return; + } + if (dlg->hooks.request_uri->s){ + rpc->add(c, "S", dlg->hooks.request_uri); + }else{ + rpc->add(c, "s", ""); + } + if (dlg->hooks.next_hop->s) { + rpc->add(c, "S", dlg->hooks.next_hop); + } else { + rpc->add(c, "s", ""); + } + rpc_print_routes(rpc, c, dlg); + free_dlg(dlg); + return; +} + + + +/* t_uac callback */ +static void rpc_uac_callback(struct cell* t, int type, struct tmcb_params* ps) +{ + rpc_delayed_ctx_t* dctx; + str text; + rpc_t* rpc; + void* c; + int code; + str* preason; + + dctx=(rpc_delayed_ctx_t*)*ps->param; + *ps->param=0; + if (dctx==0){ + BUG("null delayed reply ctx\n"); + return; + } + rpc=&dctx->rpc; + c=dctx->reply_ctx; + if (ps->rpl==FAKED_REPLY) { + text.s=error_text(ps->code); + text.len=strlen(text.s); + code=ps->code; + preason=&text; + rpc->add(c, "dS", code, preason); + rpc->add(c, "s", ""); /* request uri (rpc_print_uris)*/ + rpc->add(c, "s", ""); /* next hop (rpc_print_uris) */ + rpc->add(c, "s", ""); /* dialog routes (rpc_print_routes) */ + rpc->add(c, "s", ""); /* rest of the reply */ + }else{ + code=ps->rpl->first_line.u.reply.statuscode; + preason=&ps->rpl->first_line.u.reply.reason; + rpc->add(c, "dS", code, preason); + rpc_print_uris(rpc, c, ps->rpl); + /* print all the reply (from the first header) */ + rpc->add(c, "s", ps->rpl->headers->name.s); + } + rpc->delayed_ctx_close(dctx); + ps->param=0; +} + + /** rpc t_uac version- * It expects the following list of strings as parameters: @@ -339,11 +489,14 @@ static void rpc_t_uac(rpc_t* rpc, void* c, int reply_wait) char err_buf[MAX_REASON_LEN]; dlg_t dlg; uac_req_t uac_req; + rpc_delayed_ctx_t* dctx; body.s=0; body.len=0; - if (reply_wait){ - rpc->fault(c, 600, "Reply wait/async mode not supported"); + if (reply_wait && (rpc->capabilities == 0 || + !(rpc->capabilities(c) & RPC_DELAYED_REPLY))) { + rpc->fault(c, 600, "Reply wait/async mode not supported" + " by this rpc transport"); return; } ret=rpc->scan(c, "SSSSS*S", @@ -442,6 +595,16 @@ static void rpc_t_uac(rpc_t* rpc, void* c, int reply_wait) uac_req.headers=&hfb; uac_req.body=body.len?&body:0; uac_req.dialog=&dlg; + if (reply_wait){ + dctx=rpc->delayed_ctx_new(c); + if (dctx==0){ + rpc->fault(c, 500, "internal error: failed to create context"); + return; + } + uac_req.cb=rpc_uac_callback; + uac_req.cbp=dctx; + uac_req.cb_flags=TMCB_LOCAL_COMPLETED; + } ret = t_uac(&uac_req); if (ret <= 0) {

15 years, 4 months

SF.net SVN: openser:[5920] branches

by Henning Westerholt

Revision: 5920 http://openser.svn.sourceforge.net/openser/?rev=5920&view=rev Author: henningw Date: 2009-09-03 09:07:46 +0000 (Thu, 03 Sep 2009) Log Message: ----------- - spelling fix in error message Modified Paths: -------------- branches/1.4/modules/imc/imc.c branches/1.5/modules/imc/imc.c This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

15 years, 4 months

SF.net SVN: openser:[5919] branches

by Henning Westerholt

Revision: 5919 http://openser.svn.sourceforge.net/openser/?rev=5919&view=rev Author: henningw Date: 2009-09-03 09:06:46 +0000 (Thu, 03 Sep 2009) Log Message: ----------- - spelling fix in module docs Modified Paths: -------------- branches/1.4/modules/carrierroute/README branches/1.4/modules/carrierroute/doc/carrierroute_admin.xml branches/1.4/modules/sst/README branches/1.4/modules/sst/doc/sst_admin.xml branches/1.5/modules/carrierroute/README branches/1.5/modules/carrierroute/doc/carrierroute_admin.xml branches/1.5/modules/sst/README branches/1.5/modules/sst/doc/sst_admin.xml This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

15 years, 4 months

warning on missing stateless_reply route

by jh＠tutpro.com

when i start sr, i get to syslog: Sep 2 21:00:18 localhost sip-router: WARNING: tm [tm.c:502]: WARNING: on_sl_reply("stateless_reply"): empty/non existing route warning text is not true, because i do have such route and it is not empty: onreply_route [stateless_reply] { # process transactionless replies xlog("L_NOTICE", "Reply from $si does not belong to transaction\n"); return 0; # 0 == drop } if i remember correctly, this used to work at some point, but not anymore. -- juha

15 years, 4 months

check myself callbacks

by Daniel-Constantin Mierla

Hello, I added a simple callback mechanism for check myself conditions. Therefore modules can register a function to be executed when 'mysef' check is performed, making possible to match the domains' list handled by domain module. if(uri==myself) will match if the uri has the hostname in domain module list. Juha, I have updated modules_k/domain do register a callback, can you check to see if I haven't missed something there? Any developer of modules_s/domain that is willing to update it? One thing that should be decided is whether to make this an option via a module parameter or leave it as it is by default. Thanks, Daniel -- Daniel-Constantin Mierla * http://www.asipto.com/

15 years, 4 months

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

sr-dev