sr-dev

sr-dev@lists.kamailio.org

44307 discussions

git:master: xmlrpc: new parameter - mode

by Daniel-Constantin Mierla

Module: sip-router Branch: master Commit: 42d7638f14064c5901048131ad7887c6f4b70447 URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=42d7638… Author: Daniel-Constantin Mierla <miconda(a)gmail.com> Committer: Daniel-Constantin Mierla <miconda(a)gmail.com> Date: Tue May 25 10:29:03 2010 +0200 xmlrpc: new parameter - mode - mode parameter controls the registration for non-SIP message callbacks - if set to 1, module does not register the callback, the execution of XMLRPC functions being done from config. Useful if other module register callback for same type of messages, i.e., HTTP - default is 0 (backward compatible default behavior) --- modules/xmlrpc/README | 21 +++++++++++++++++---- modules/xmlrpc/doc/params.xml | 19 +++++++++++++++++++ modules/xmlrpc/xmlrpc.c | 21 +++++++++++++-------- 3 files changed, 49 insertions(+), 12 deletions(-) diff --git a/modules/xmlrpc/README b/modules/xmlrpc/README index fed4a70..7a7b6f7 100644 --- a/modules/xmlrpc/README +++ b/modules/xmlrpc/README @@ -2,7 +2,7 @@ Jan Janak iptelorg GmbH - Copyright � 2005 iptelorg GmbH + Copyright © 2005 iptelorg GmbH Revision History Revision $Revision$ $Date$ __________________________________________________________________ @@ -24,6 +24,7 @@ Jan Janak 1.5.2. autoconversion (string) 1.5.3. escape_cr (integer) 1.5.4. double_lf_to_crlf (integer) + 1.5.5. mode (integer) 1.6. Functions @@ -407,7 +408,7 @@ Content-Length: 276 1.3.3. Type Conversion The data types of the RPC API are converted to the data types of - XML-RPC and vice versa. Table 1, "Data Type Conversion" shows for each + XML-RPC and vice versa. Table 1, “Data Type Conversion” shows for each RPC API data type corresponding XML-RPC data type. Table 1. Data Type Conversion @@ -565,6 +566,18 @@ modparam("xmlrpc", "escape_cr", 1) Example 5. Set the double_lf_to_crlf parameter modparam("xmlrpc", "double_lf_to_crlf", 1) +1.5.5. mode (integer) + + When set to 1, xmlrpc module does not register to core the callback + functions for non-SIP messages. Useful when other module register a + callback for HTTP request, being the decision of admin when to call the + XMLRPC route (or functions). + + Default: 0. + + Example 6. Set the mode parameter +modparam("xmlrpc", "mode", 1) + 1.6. Functions Revision History @@ -586,7 +599,7 @@ modparam("xmlrpc", "double_lf_to_crlf", 1) function with matching name. If such a function is found then dispatch_rpc() will pass control to the function to handle the request. - Example 6. dispatch_rpc usage + Example 7. dispatch_rpc usage #... modparam("xmlrpc", "route", "XMLRPC"); #... @@ -602,7 +615,7 @@ route[XMLRPC]{ This function can be called from the config script to directly generate an XML-RPC reply. - Example 7. xmlrpc_reply usage + Example 8. xmlrpc_reply usage #... modparam("xmlrpc", "route", "XMLRPC"); #... diff --git a/modules/xmlrpc/doc/params.xml b/modules/xmlrpc/doc/params.xml index f200b55..67e7a5f 100644 --- a/modules/xmlrpc/doc/params.xml +++ b/modules/xmlrpc/doc/params.xml @@ -116,6 +116,25 @@ modparam("xmlrpc", "double_lf_to_crlf", 1) </example> </section> + <section id="param_mode"> + <title><varname>mode</varname> (integer)</title> + <para> + When set to 1, xmlrpc module does not register to core the callback + functions for non-SIP messages. Useful when other module register + a callback for HTTP request, being the decision of admin when to + call the XMLRPC route (or functions). + </para> + <para> + Default: 0. + </para> + <example> + <title>Set the <varname>mode</varname> parameter</title> + <programlisting> +modparam("xmlrpc", "mode", 1) + </programlisting> + </example> + </section> + <!-- Obsolete (hardwired on in the rpc core functions, cannot be turned off) -andrei diff --git a/modules/xmlrpc/xmlrpc.c b/modules/xmlrpc/xmlrpc.c index dc7af86..c502ad9 100644 --- a/modules/xmlrpc/xmlrpc.c +++ b/modules/xmlrpc/xmlrpc.c @@ -397,7 +397,8 @@ static int escape_cr=1; /* default on */ /* convert double LF to CR LF (when on, LFLF becomes an escape for CRLF, needed with some xmlrpc clients that are not escaping CR to  )*/ static int lflf2crlf=0; /* default off */ - +/* do not register for non-sip requests */ +static int xmlrpc_mode = 0; /* * Exported functions @@ -417,6 +418,7 @@ static param_export_t params[] = { {"autoconversion", PARAM_INT, &autoconvert}, {"escape_cr", PARAM_INT, &escape_cr}, {"double_lf_to_crlf", PARAM_INT, &lflf2crlf}, + {"mode", PARAM_INT, &xmlrpc_mode}, {0, 0, 0} }; @@ -2388,13 +2390,16 @@ static int mod_init(void) register_select_table(xmlrpc_sel); /* register non-sip hooks */ - memset(&nsh, 0, sizeof(nsh)); - nsh.name="xmlrpc"; - nsh.destroy=0; - nsh.on_nonsip_req=process_xmlrpc; - if (register_nonsip_msg_hook(&nsh)<0){ - ERR("Failed to register non sip msg hooks\n"); - return -1; + if(xmlrpc_mode==0) + { + memset(&nsh, 0, sizeof(nsh)); + nsh.name="xmlrpc"; + nsh.destroy=0; + nsh.on_nonsip_req=process_xmlrpc; + if (register_nonsip_msg_hook(&nsh)<0){ + ERR("Failed to register non sip msg hooks\n"); + return -1; + } } return 0; }

14 years, 8 months

Re: [sr-dev] direction check missing in record_route()

by NeoTel Lists

This patch does it for me: --- --- modules/rr/record.c.ori 2010-05-25 13:10:48.000000000 +0200 +++ modules/rr/record.c 2010-05-25 13:37:26.000000000 +0200 @@ -41,6 +41,7 @@ #include "../../data_lump.h" #include "record.h" #include "rr_mod.h" +#include "loose.h" #define RR_PREFIX "Record-Route: <sip:" @@ -291,12 +292,20 @@ } if (append_fromtag) { - if (parse_from_header(_m) < 0) { - LM_ERR("From parsing failed\n"); - return -2; + if (is_direction(_m, RR_FLOW_UPSTREAM)==0) { + /* use to-tag in script! */ + + LM_DBG("from-tag not added on upstream request (it's wrong anyway)! Must be done manually using record_route(\";ftag=$tt\");"); + + tag = 0; + } else { + if (parse_from_header(_m) < 0) { + LM_ERR("From parsing failed\n"); + return -2; + } + from = (struct to_body*)_m->from->parsed; + tag = &from->tag_value; } - from = (struct to_body*)_m->from->parsed; - tag = &from->tag_value; } else { tag = 0; } --- Plus in script after loose_route(): if (check_route_param("vsf=")) { # fix broken UAC not sending initial route-set $(var(vsf)) = $(hdr(Route)[0]{s.select,0,,}{param.value,vsf}{s.select,0,>}); xlog("L_INFO", ">> Stored UAC param vsf=$(var(vsf))"); if (is_direction("upstream")) { record_route(";ftag=$tt;vsf=$(var(vsf))"); } else { record_route(";vsf=$(var(vsf))"); } } else { if (is_direction("upstream")) { record_route(";ftag=$tt"); } else { record_route(); } } Br Walter Von: sr-dev-bounces(a)lists.sip-router.org [mailto:sr-dev-bounces@lists.sip-router.org] Im Auftrag von NeoTel Lists Gesendet: Dienstag, 25. Mai 2010 13:04 An: sr-dev(a)lists.sip-router.org Betreff: [sr-dev] direction check missing in record_route() Hi! Can someone of the experts pls help me with a fix in record.c/record_route() please? IMHO in append_fromtag=1 mode the direction check is missing, if record_route() is called in loose_route block. (Sure, I know, there is no need to call record_route() there, but since nearly all of the UA out there don't use first record set on reInvites, I must do record routing on reInvites, too!) (And I really do need the vsf parameter in subsequent messages J) So I would do the following: if (append_fromtag) { if (is_direction(_m, RR_FLOW_UPSTREAM)) { /* if not in dialog, would return 0 anyway, e.g. no Route param ftag present */ /* use to-tag! */ Unfortunately there is no "parse_to_header", bec. then it would be simple.... How to access the to-tag, if any? } else { if (parse_from_header(_m) < 0) { LM_ERR("From parsing failed\n"); return -2; } from = (struct to_body*)_m->from->parsed; tag = &from->tag_value; } } else { tag = 0; } -- What I do now is not nice: I set modparam("rr", "append_fromtag", 0) and patched rr_mod.c and uac.c not to return an Error, if append_fromtag is 0 J [root@p01-1 rr]# more ../../../rr_mod.c.patch --- modules/rr/rr_mod.c.ori 2010-05-25 11:03:29.000000000 +0200 +++ modules/rr/rr_mod.c 2010-05-25 12:08:34.000000000 +0200 @@ -172,9 +172,10 @@ int n; if (!append_fromtag) { - LM_ERR("usage of \"is_direction\" function requires parameter" - "\"append_fromtag\" enabled!!"); - return E_CFG; + LM_WARN("usage of \"is_direction\" function requires parameter" + "\"append_fromtag\" enabled!!" + " - must be done manually to work correctly!"); + /* return E_CFG; */ } if (param_no==1) { n = 0; [root@p01-1 rr]# more ../../../uac.c.patch --- modules/uac/uac.c.orig 2010-05-25 10:57:59.000000000 +0200 +++ modules/uac/uac.c 2010-05-25 11:00:40.000000000 +0200 @@ -206,9 +206,13 @@ if (from_restore_mode==FROM_AUTO_RESTORE) { /* we need the append_fromtag on in RR */ if (!uac_rrb.append_fromtag) { - LM_ERR("'append_fromtag' RR param is not enabled!" - " - required by AUTO restore mode\n"); - goto error; + LM_WARN("'append_fromtag' RR param is not enabled!" + " - required by AUTO restore mode" + " - make sure it's done manually!\n"); + /* normally ERR, but just remind script writer, that she has to do ;ftag=$ft/$tt manually + normally this would be OK, but record_route() add $ft in upsteam request + should be fixed in rr module! + goto error; */ } /* get all requests doing loose route */ if (uac_rrb.register_rrcb( rr_checker, 0)!=0) { -- Many thanks! Walter --------------------------------------- NeoTel Telefonservice GmbH & Co KG Esterhazygasse 18a/15 A-1060 Wien T: +43 1 4094181 - 81 M: +43 660 88866 - 81 F: +43 1 4094181 - 981

14 years, 8 months

direction check missing in record_route()

by NeoTel Lists

Hi! Can someone of the experts pls help me with a fix in record.c/record_route() please? IMHO in append_fromtag=1 mode the direction check is missing, if record_route() is called in loose_route block. (Sure, I know, there is no need to call record_route() there, but since nearly all of the UA out there don't use first record set on reInvites, I must do record routing on reInvites, too!) (And I really do need the vsf parameter in subsequent messages J) So I would do the following: if (append_fromtag) { if (is_direction(_m, RR_FLOW_UPSTREAM)) { /* if not in dialog, would return 0 anyway, e.g. no Route param ftag present */ /* use to-tag! */ Unfortunately there is no "parse_to_header", bec. then it would be simple.... How to access the to-tag, if any? } else { if (parse_from_header(_m) < 0) { LM_ERR("From parsing failed\n"); return -2; } from = (struct to_body*)_m->from->parsed; tag = &from->tag_value; } } else { tag = 0; } -- What I do now is not nice: I set modparam("rr", "append_fromtag", 0) and patched rr_mod.c and uac.c not to return an Error, if append_fromtag is 0 J [root@p01-1 rr]# more ../../../rr_mod.c.patch --- modules/rr/rr_mod.c.ori 2010-05-25 11:03:29.000000000 +0200 +++ modules/rr/rr_mod.c 2010-05-25 12:08:34.000000000 +0200 @@ -172,9 +172,10 @@ int n; if (!append_fromtag) { - LM_ERR("usage of \"is_direction\" function requires parameter" - "\"append_fromtag\" enabled!!"); - return E_CFG; + LM_WARN("usage of \"is_direction\" function requires parameter" + "\"append_fromtag\" enabled!!" + " - must be done manually to work correctly!"); + /* return E_CFG; */ } if (param_no==1) { n = 0; [root@p01-1 rr]# more ../../../uac.c.patch --- modules/uac/uac.c.orig 2010-05-25 10:57:59.000000000 +0200 +++ modules/uac/uac.c 2010-05-25 11:00:40.000000000 +0200 @@ -206,9 +206,13 @@ if (from_restore_mode==FROM_AUTO_RESTORE) { /* we need the append_fromtag on in RR */ if (!uac_rrb.append_fromtag) { - LM_ERR("'append_fromtag' RR param is not enabled!" - " - required by AUTO restore mode\n"); - goto error; + LM_WARN("'append_fromtag' RR param is not enabled!" + " - required by AUTO restore mode" + " - make sure it's done manually!\n"); + /* normally ERR, but just remind script writer, that she has to do ;ftag=$ft/$tt manually + normally this would be OK, but record_route() add $ft in upsteam request + should be fixed in rr module! + goto error; */ } /* get all requests doing loose route */ if (uac_rrb.register_rrcb( rr_checker, 0)!=0) { -- Many thanks! Walter --------------------------------------- NeoTel Telefonservice GmbH & Co KG Esterhazygasse 18a/15 A-1060 Wien T: +43 1 4094181 - 81 M: +43 660 88866 - 81 F: +43 1 4094181 - 981

14 years, 8 months

git:andrei/tcp_tls_changes: tls: async support (major tls core rewrite)

by Andrei Pelinescu-Onciul

Module: sip-router Branch: andrei/tcp_tls_changes Commit: 93c495f34ebb001f9509db82acad5a7483b61d41 URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=93c495f… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Thu May 20 18:24:38 2010 +0200 tls: async support (major tls core rewrite) The new tls hook interface (exported by the tcp code) is now used. All the IO operations are made through a custom SSL BIO, that reads and writes in some memory buffers (see tls_bio.h), while externally emulating a socket. This BIO provides in fact some functions that will be called by the openssl code on IO. In the case of a read event, the data is first read in memory (using tcp_read_data()), then assigned to the BIO and after that one of SSL_read(), SSL_connect/accept (if the connection is not yet established) or SSL_write (if the last write wanted to read some data due to re-keying) are called. They will all read from the custom BIO. A SSL_read() might not use all the data (in some very unlikely situations), so in this case the encrypted data is queued and the tcp code is signaled (via some flags) that it should repeat the read call when more space is available. Writes are split in 2: 1st write on a new connection in async mode and other writes (they need to be handled slightly differently). The encrypted data will end up in a memory buffer (via SSL_write() and the custom BIO). From there it will be either sent directly if possible or queued (tcp_async). In the case when the SSL_write() needs to read some data (e.g. re-keying), the whole clear text data will be queued and the SSL_write() will be retried on the first read event. There is no separate async mode for tls, if tcp is in async mode, then tls will be too and vice versa. Runtime tunning (queue sizes a.s.o) and statistics are missing for now. (C) and license changes: - moved tls_dump_verification_failure into a separate file (tls_dump_vf.c), out of tls_server.c. - the remaining tcp_server.[ch] code is either re-written (most of it, the entire read & write part) or comes from old iptel code => changed the (c) to iptelorg only and the license to BSD-like (only for tcp_server.[ch]). --- modules/tls/tls_dump_vf.c | 144 ++++++ modules/tls/tls_dump_vf.h | 41 ++ modules/tls/tls_init.c | 2 + modules/tls/tls_mod.c | 34 +- modules/tls/tls_server.c | 1105 ++++++++++++++++++++++++--------------------- modules/tls/tls_server.h | 76 ++-- 6 files changed, 831 insertions(+), 571 deletions(-) Diff: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commitdiff;h=93c…

14 years, 8 months

git:andrei/tcp_tls_changes: tls: tls_bio ctrl cmd support, fixes and debug

by Andrei Pelinescu-Onciul

Module: sip-router Branch: andrei/tcp_tls_changes Commit: c6a9ffb4f6a7b2e9f777ed47e87749eacf9782b6 URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=c6a9ffb… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Thu May 20 17:44:13 2010 +0200 tls: tls_bio ctrl cmd support, fixes and debug - proper return code for some BIO_ctrl commands used internally by SSL_*. (BIO_CTRL_DUP, BIO_CTRL_FLUSH) - when the attached memory buffer is null and read or write is attempted, behave similar to socket bio on EAGAIN (BIO_set_retry_read(b)). - fixed tls_bio_mbuf_read bug (switched params in memcpy). - added tls_mbuf_init(...) - extended debug messages if TLS_BIO_DEBUG is defined. --- modules/tls/tls_bio.c | 87 +++++++++++++++++++++++++++++++++++++++++++++---- modules/tls/tls_bio.h | 24 ++++++++++++-- 2 files changed, 101 insertions(+), 10 deletions(-) diff --git a/modules/tls/tls_bio.c b/modules/tls/tls_bio.c index a7ba50d..c82fe64 100644 --- a/modules/tls/tls_bio.c +++ b/modules/tls/tls_bio.c @@ -24,6 +24,8 @@ * History: * -------- * 2010-03-25 initial version (andrei) + * 2010-05-20 emulate EAGAIN on null rd/wr memory buffer; handle some + * needed commands in ctrl; debug support (TLS_BIO_DBG) (andrei) */ #include "tls_bio.h" @@ -35,6 +37,26 @@ internal defined BIO is 23) */ #define BIO_TYPE_TLS_MBUF (BIO_TYPE_SOURCE_SINK | 0xf2) +/* debugging */ +#ifndef NO_TLS_BIO_DEBUG +#define TLS_BIO_DEBUG +#endif +#ifdef TLS_BIO_DEBUG + #ifdef __SUNPRO_C + #define TLS_BIO_DBG(...) \ + LOG_(DEFAULT_FACILITY, L_INFO, "tls_BIO: " LOC_INFO, __VA_ARGS__) + #else + #define TLS_BIO_DBG(fmt, args...) \ + LOG_(DEFAULT_FACILITY, L_INFO, "tls_BIO: " LOC_INFO, fmt, ## args) + #endif /* __SUNPRO_c */ +#else /* TLS_BIO_DEBUG */ + #ifdef __SUNPRO_C + #define TLS_BIO_DBG(...) + #else + #define TLS_BIO_DBG(fmt, args...) + #endif /* __SUNPRO_c */ +#endif /* TLS_BIO_DEBUG */ + static int tls_bio_mbuf_new(BIO* b); static int tls_bio_mbuf_free(BIO* b); @@ -73,6 +95,7 @@ BIO* tls_BIO_new_mbuf(struct tls_mbuf* rd, struct tls_mbuf* wr) { BIO* ret; + TLS_BIO_DBG("tls_BIO_new_mbuf called (%p, %p)\n", rd, wr); ret = BIO_new(tls_BIO_mbuf()); if (unlikely(ret == 0)) return 0; @@ -92,6 +115,7 @@ int tls_BIO_mbuf_set(BIO* b, struct tls_mbuf* rd, struct tls_mbuf* wr) { struct tls_bio_mbuf_data* d; + TLS_BIO_DBG("tls_BIO_muf_set called (%p, %p)\n", rd, wr); if (unlikely(b->ptr == 0)){ BUG("null BIO ptr\n"); return 0; @@ -113,6 +137,7 @@ static int tls_bio_mbuf_new(BIO* b) { struct tls_bio_mbuf_data* d; + TLS_BIO_DBG("tls_bio_mbuf_new called (%p)\n", b); b->init = 0; /* not initialized yet */ b->num = 0; b->ptr = 0; @@ -134,6 +159,7 @@ static int tls_bio_mbuf_new(BIO* b) */ static int tls_bio_mbuf_free(BIO* b) { + TLS_BIO_DBG("tls_bio_mbuf_free called (%p)\n", b); if (unlikely( b == 0)) return 0; if (likely(b->ptr)){ @@ -164,19 +190,30 @@ static int tls_bio_mbuf_read(BIO* b, char* dst, int dst_len) if (unlikely(d == 0 || d->rd->buf == 0)) { if (d == 0) BUG("tls_BIO_mbuf %p: read called with null b->ptr\n", b); - else - BUG("tls_BIO_mbuf %p: read called with null read buffer\n", b); + else { + /* this form of calling read with a null buffer is used + as a shortcut when no data is available => + simulate EAGIAN/WANT_READ */ + TLS_BIO_DBG("read (%p, %p, %d) called with null read buffer" + " => simulating EAGAIN/WANT_READ\n", b, dst, dst_len); + BIO_set_retry_read(b); + } return -1; } rd = d->rd; if (unlikely(rd->used == rd->pos && dst_len)) { /* mimic non-blocking read behaviour */ + TLS_BIO_DBG("read (%p, %p, %d) called with full rd (%d)" + " => simulating EAGAIN/WANT_READ\n", + b, dst, dst_len, rd->used); BIO_set_retry_read(b); return -1; } ret = MIN_int(rd->used - rd->pos, dst_len); /* copy data from rd.buf into dst */ - memcpy(rd->buf+rd->pos, dst, ret); + memcpy(dst, rd->buf+rd->pos, ret); + TLS_BIO_DBG("read(%p, %p, %d) called with rd=%p pos=%d => %d bytes\n", + b, dst, dst_len, rd->buf, rd->pos, ret); rd->pos += ret; /* if (unlikely(rd->pos < rd->used)) BIO_set_retry_read(b); @@ -204,13 +241,21 @@ static int tls_bio_mbuf_write(BIO* b, const char* src, int src_len) if (unlikely(d == 0 || d->wr->buf == 0)) { if (d == 0) BUG("tls_BIO_mbuf %p: write called with null b->ptr\n", b); - else - BUG("tls_BIO_mbuf %p: write called with null read buffer\n", b); + else { + /* this form of calling write with a null buffer is used + as a shortcut when no data is available => + simulate EAGAIN/WANT_WRITE */ + TLS_BIO_DBG("write (%p, %p, %d) called with null buffer" + " => simulating WANT_WRITE\n", b, src, src_len); + BIO_set_retry_write(b); + } return -1; } wr = d->wr; if (unlikely(wr->size == wr->used && src_len)) { /* mimic non-blocking socket behaviour */ + TLS_BIO_DBG("write (%p, %p, %d) called with full wr buffer (%d)" + " => simulating WANT_WRITE\n", b, src, src_len, wr->used); BIO_set_retry_write(b); return -1; } @@ -220,6 +265,7 @@ static int tls_bio_mbuf_write(BIO* b, const char* src, int src_len) /* if (unlikely(ret < src_len)) BIO_set_retry_write(); */ + TLS_BIO_DBG("write called (%p, %p, %d) => %d\n", b, src, src_len, ret); return ret; } @@ -227,8 +273,34 @@ static int tls_bio_mbuf_write(BIO* b, const char* src, int src_len) static long tls_bio_mbuf_ctrl(BIO* b, int cmd, long arg1, void* arg2) { - /* no cmd supported */ - return 0; + long ret; + ret=0; + switch(cmd) { + case BIO_C_SET_FD: + case BIO_C_GET_FD: + ret = -1; /* error, not supported */ + break; + case BIO_CTRL_GET_CLOSE: + case BIO_CTRL_SET_CLOSE: + ret = 0; + break; + case BIO_CTRL_DUP: + case BIO_CTRL_FLUSH: + ret = 1; + break; + case BIO_CTRL_RESET: + case BIO_C_FILE_SEEK: + case BIO_C_FILE_TELL: + case BIO_CTRL_INFO: + case BIO_CTRL_PENDING: + case BIO_CTRL_WPENDING: + default: + ret = 0; + break; + } + TLS_BIO_DBG("ctrl called (%p, %d, %ld, %p) => %ld\n", + b, cmd, arg1, arg2, ret); + return ret; } @@ -237,6 +309,7 @@ static int tls_bio_mbuf_puts(BIO* b, const char* s) { int len; + TLS_BIO_DBG("puts called (%p, %s)\n", b, s); len=strlen(s); return tls_bio_mbuf_write(b, s, len); } diff --git a/modules/tls/tls_bio.h b/modules/tls/tls_bio.h index 78d5a47..5336d6b 100644 --- a/modules/tls/tls_bio.h +++ b/modules/tls/tls_bio.h @@ -34,9 +34,9 @@ /* memory buffer used for tls I/O */ struct tls_mbuf { unsigned char* buf; - int pos; /* current position in the buffer while reading*/ - int used; /* how much it's used */ - int size; /* total buffer size (fixed) */ + int pos; /**< current position in the buffer while reading or writing*/ + int used; /**< how much it's used (read or write)*/ + int size; /**< total buffer size (fixed) */ }; struct tls_bio_mbuf_data { @@ -49,6 +49,24 @@ BIO_METHOD* tls_BIO_mbuf(void); BIO* tls_BIO_new_mbuf(struct tls_mbuf* rd, struct tls_mbuf* wr); int tls_BIO_mbuf_set(BIO* b, struct tls_mbuf* rd, struct tls_mbuf* wr); + + +/** intialize an mbuf structure. + * @param mb - struct tls_mbuf pointer that will be intialized. + * @param b - buffer (unsigned char*). + * @param sz - suze of the buffer (int). + * WARNING: the buffer will not be copied, but referenced. + */ +#define tls_mbuf_init(mb, b, sz) \ + do { \ + (mb)->buf = (b); \ + (mb)->size = (sz); \ + (mb)->pos = 0; \ + (mb)->used = 0; \ + } while(0) + + + #endif /*__tls_bio_h*/ /* vi: set ts=4 sw=4 tw=79:ai:cindent: */

14 years, 8 months

git:andrei/tcp_tls_changes: tls: added a minimum overhead shm buffer queue

by Andrei Pelinescu-Onciul

Module: sip-router Branch: andrei/tcp_tls_changes Commit: c914809c9f70fe15d1a2459fa0668d722d83726c URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=c914809… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Thu May 20 16:22:16 2010 +0200 tls: added a minimum overhead shm buffer queue Minimum overhead buffer queue in shm memory, based on tcp_wbuffer_queue (tcp_conn.h). --- modules/tls/sbufq.h | 292 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 292 insertions(+), 0 deletions(-) diff --git a/modules/tls/sbufq.h b/modules/tls/sbufq.h new file mode 100644 index 0000000..6b59751 --- /dev/null +++ b/modules/tls/sbufq.h @@ -0,0 +1,292 @@ +/* + * $Id$ + * + * Copyright (C) 2010 iptelorg GmbH + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ +/** minimal overhead buffer queue in shm memory. + * @file modules/tls/sbufq.h + * @ingroup: tls + * Module: @ref tls + */ +/* + * History: + * -------- + * 2010-03-31 initial version, based on tcp_conn.h tcp_wbuffer_queue (andrei) +*/ + +#ifndef __sbufq_h +#define __sbufq_h + +#include "../../compiler_opt.h" +#include "../../ut.h" +#include "../../mem/shm_mem.h" +#include "../../timer_ticks.h" +#include "../../timer.h" +#include "../../dprint.h" +#include <string.h> + + +struct sbuf_elem { + struct sbuf_elem* next; + unsigned int b_size; /**< buf size */ + char buf[1]; /**< variable size buffer */ +}; + +struct sbuffer_queue { + struct sbuf_elem* first; + struct sbuf_elem* last; + ticks_t last_chg; /**< last change (creation time or partial flush)*/ + unsigned int queued; /**< total size */ + unsigned int offset; /**< offset in the first buffer where unflushed data + starts */ + unsigned int last_used; /**< how much of the last buffer is used */ +}; + + +/* sbufq_flush() output flags */ +#define F_BUFQ_EMPTY 1 +#define F_BUFQ_ERROR_FLUSH 2 + + +#define sbufq_empty(bq) ((bq)->first==0) +#define sbufq_non_empty(bq) ((bq)->first!=0) + + + +/** adds/appends data to a buffer queue. + * WARNING: it does no attempt to synchronize access/lock. If needed it should + * be called under lock. + * @param q - buffer queue + * @param data + * @param size + * @param min_buf_size - min size to allocate for new buffer elements + * @return 0 on success, -1 on error (mem. allocation) + */ +inline static int sbufq_add(struct sbuffer_queue* q, const void* data, + unsigned int size, unsigned int min_buf_size) +{ + struct sbuf_elem* b; + unsigned int last_free; + unsigned int b_size; + unsigned int crt_size; + ticks_t t; + + t=get_ticks_raw(); + + if (likely(q->last==0)) { + b_size=MAX_unsigned(min_buf_size, size); + b=shm_malloc(sizeof(*b)+b_size-sizeof(b->buf)); + if (unlikely(b==0)) + goto error; + b->b_size=b_size; + b->next=0; + q->last=b; + q->first=b; + q->last_used=0; + q->offset=0; + q->last_chg=get_ticks_raw(); + last_free=b_size; + crt_size=size; + goto data_cpy; + }else{ + b=q->last; + } + + while(size){ + last_free=b->b_size-q->last_used; + if (last_free==0){ + b_size=MAX_unsigned(min_buf_size, size); + b=shm_malloc(sizeof(*b)+b_size-sizeof(b->buf)); + if (unlikely(b==0)) + goto error; + b->b_size=b_size; + b->next=0; + q->last->next=b; + q->last=b; + q->last_used=0; + last_free=b->b_size; + } + crt_size=MIN_unsigned(last_free, size); +data_cpy: + memcpy(b->buf+q->last_used, data, crt_size); + q->last_used+=crt_size; + size-=crt_size; + data+=crt_size; + q->queued+=crt_size; + } + return 0; +error: + return -1; +} + + + +/** inserts data (at the beginning) in a buffer queue. + * Note: should never be called after sbufq_run(). + * WARNING: it does no attempt to synchronize access/lock. If needed it should + * be called under lock. + * @param q - buffer queue + * @param data + * @param size + * @param min_buf_size - min size to allocate for new buffer elements + * @return 0 on success, -1 on error (mem. allocation) + */ +inline static int sbufq_insert(struct sbuffer_queue* q, const void* data, + unsigned int size, unsigned int min_buf_size) +{ + struct sbuf_elem* b; + + if (likely(q->first==0)) /* if empty, use sbufq_add */ + return sbufq_add(q, data, size, min_buf_size); + + if (unlikely(q->offset)){ + LOG(L_CRIT, "BUG: non-null offset %d (bad call, should" + "never be called after sbufq_run())\n", q->offset); + goto error; + } + if ((q->first==q->last) && ((q->last->b_size-q->last_used)>=size)){ + /* one block with enough space in it for size bytes */ + memmove(q->first->buf+size, q->first->buf, size); + memcpy(q->first->buf, data, size); + q->last_used+=size; + }else{ + /* create a size bytes block directly */ + b=shm_malloc(sizeof(*b)+size-sizeof(b->buf)); + if (unlikely(b==0)) + goto error; + b->b_size=size; + /* insert it */ + b->next=q->first; + q->first=b; + memcpy(b->buf, data, size); + } + + q->queued+=size; + return 0; +error: + return -1; +} + + +/** destroy a buffer queue. + * Only the content is destroyed (shm_free()'d), the queue head is + * re-intialized. + * WARNING: it does no attempt to synchronize access/lock. If needed it should + * be called under lock. + * @param q - buffer queue + * @return - number of bytes that used to be queued (>=0). + */ +inline static unsigned int sbufq_destroy(struct sbuffer_queue* q) +{ + struct sbuf_elem* b; + struct sbuf_elem* next_b; + int unqueued; + + unqueued=0; + if (likely(q->first)){ + b=q->first; + do{ + next_b=b->next; + unqueued+=(b==q->last)?q->last_used:b->b_size; + if (b==q->first) + unqueued-=q->offset; + shm_free(b); + b=next_b; + }while(b); + } + memset(q, 0, sizeof(*q)); + return unqueued; +} + + + +/** tries to flush the queue. + * Tries to flush as much as possible from the given queue, using the + * given callback. + * WARNING: it does no attempt to synchronize access/lock. If needed it should + * be called under lock. + * @param q - buffer queue + * @param *flags - set to: + * F_BUFQ_EMPTY if the queued is completely flushed + * F_BUFQ_ERROR_FLUSH if the flush_f callback returned error. + * @param flush_f - flush function (callback). modeled after write(): + * flush_f(param1, param2, const void* buf, unsigned size). + * It should return the number of bytes "flushed" on + * success, or <0 on error. If the number of bytes + * "flushed" is smaller then the requested size, it + * would be assumed that no more bytes can be flushed + * and sbufq_flush will exit. + * @param flush_p1 - parameter for the flush function callback. + * @param flush_p2 - parameter for the flush function callback. + * @return -1 on internal error, or the number of bytes flushed on + * success (>=0). Note that the flags param is + * always set and it should be used to check for errors, since + * a flush_f() failure will not result in a negative return. + */ +inline static int sbufq_flush(struct sbuffer_queue* q, int* flags, + int (*flush_f)(void* p1, void* p2, + const void* buf, + unsigned size), + void* flush_p1, void* flush_p2) +{ + struct sbuf_elem *b; + int n; + int ret; + int block_size; + char* buf; + + *flags=0; + ret=0; + while(q->first){ + block_size=((q->first==q->last)?q->last_used:q->first->b_size)- + q->offset; + buf=q->first->buf+q->offset; + n=flush_f(flush_p1, flush_p2, buf, block_size); + if (likely(n>0)){ + ret+=n; + if (likely(n==block_size)){ + b=q->first; + q->first=q->first->next; + shm_free(b); + q->offset=0; + q->queued-=block_size; + ret+=block_size; + }else{ + q->offset+=n; + q->queued-=n; + ret+=n; + break; + } + }else{ + if (unlikely(n<0)) + *flags|=F_BUFQ_ERROR_FLUSH; + break; + } + } + if (likely(q->first==0)){ + q->last=0; + q->last_used=0; + q->offset=0; + *flags|=F_BUFQ_EMPTY; + } + return ret; +} + + + + +#endif /*__sbufq_h*/ + +/* vi: set ts=4 sw=4 tw=79:ai:cindent: */

14 years, 8 months

git:andrei/tcp_tls_changes: tls: clear text write queue implementation

by Andrei Pelinescu-Onciul

Module: sip-router Branch: andrei/tcp_tls_changes Commit: c38de320d864507b38d6f99beb649fef9211a3cf URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=c38de32… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Thu May 20 16:26:22 2010 +0200 tls: clear text write queue implementation In some cases the not-yet-encrypted data must be queued on write and the write retried later (e.g. a SSL_write returns WANT_READ because of an ongoing re-keying or trying to write while the SSL connection is not yet fully established). --- modules/tls/tls_ct_q.h | 131 ++++++++++++++++++++++++++++++++++++ modules/tls/tls_ct_wrq.c | 164 ++++++++++++++++++++++++++++++++++++++++++++++ modules/tls/tls_ct_wrq.h | 53 +++++++++++++++ 3 files changed, 348 insertions(+), 0 deletions(-) Diff: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commitdiff;h=c38…

14 years, 8 months

git:andrei/tcp_tls_changes: tcp: new tls hooks interface and async tls changes

by Andrei Pelinescu-Onciul

Module: sip-router Branch: andrei/tcp_tls_changes Commit: ce51fbb84e56921030b62d8617db2365ad934b51 URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=ce51fbb… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Thu May 20 16:00:29 2010 +0200 tcp: new tls hooks interface and async tls changes - new tls hooks interface that better accommodates tls async use. Changed read() (takes an extra flags parameter now), removed blocking_write() and fix_read_con(), added do_send() and fst_send() (both of them handle snd_flags now and might return a command that should be sent to tcp_main). - more tcp send functions (tcpconn_1st_send(), tcpconn_send_unsafe()) and more send functions exported (tls_int_send.h) for use from the tls module. - split tcp_read() into tcp_read() and tcp_read_data() and exported tcp_read_data() (tcp_read.h). - support for repeating a tcp_read() if indicated (RD_CONN_REPEAT_READ), needed for tls. --- tcp_int_send.h | 50 +++++ tcp_main.c | 651 ++++++++++++++++++++++++++++++++------------------------ tcp_read.c | 144 ++++++++----- tcp_read.h | 46 ++++ tls_hooks.h | 31 ++-- 5 files changed, 579 insertions(+), 343 deletions(-) Diff: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commitdiff;h=ce5…

14 years, 8 months

git:andrei/tcp_tls_changes: tcp: minor cleanups & spelling

by Andrei Pelinescu-Onciul

Module: sip-router Branch: andrei/tcp_tls_changes Commit: 7f1b8eb817b26c27d273433d4365d10defca6301 URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=7f1b8eb… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Thu Mar 25 20:29:32 2010 +0100 tcp: minor cleanups & spelling - removed F_CONN_NON_BLOCKING (not used anymore) - spelling & whitespace cleanups --- tcp_conn.h | 1 - tcp_main.c | 4 ++-- tcp_read.c | 2 +- 3 files changed, 3 insertions(+), 4 deletions(-) diff --git a/tcp_conn.h b/tcp_conn.h index bedaf4d..3ce6084 100644 --- a/tcp_conn.h +++ b/tcp_conn.h @@ -61,7 +61,6 @@ /* tcp connection flags */ -#define F_CONN_NON_BLOCKING 1 #define F_CONN_READ_W 2 /* watched for READ ev. in main */ #define F_CONN_WRITE_W 4 /* watched for WRITE (main) */ #define F_CONN_READER 8 /* handled by a tcp reader */ diff --git a/tcp_main.c b/tcp_main.c index 1b26add..e539896 100644 --- a/tcp_main.c +++ b/tcp_main.c @@ -3750,9 +3750,9 @@ inline static int handle_tcpconn_ev(struct tcp_connection* tcpconn, short ev, #ifdef TCP_ASYNC send_to_child: #endif - DBG("tcp: DBG: sendig to child, events %x\n", ev); + DBG("tcp: DBG: sending to child, events %x\n", ev); #ifdef POLLRDHUP - tcpconn->flags|=((int)!(ev & (POLLRDHUP|POLLHUP|POLLERR)) -1) & + tcpconn->flags|=((int)!(ev & (POLLRDHUP|POLLHUP|POLLERR)) -1) & F_CONN_EOF_SEEN; #else /* POLLRDHUP */ tcpconn->flags|=((int)!(ev & (POLLHUP|POLLERR)) -1) & F_CONN_EOF_SEEN; diff --git a/tcp_read.c b/tcp_read.c index c5fc575..2946554 100644 --- a/tcp_read.c +++ b/tcp_read.c @@ -928,7 +928,7 @@ again: } /* if we received the fd there is most likely data waiting to * be read => process it first to avoid extra sys calls */ - read_flags=((con->flags & (F_CONN_EOF_SEEN|F_CONN_FORCE_EOF)) && + read_flags=((con->flags & (F_CONN_EOF_SEEN|F_CONN_FORCE_EOF)) && !(con->flags & F_CONN_OOB_DATA))? RD_CONN_FORCE_EOF :0; resp=tcp_read_req(con, &n, &read_flags);

14 years, 8 months

git:andrei/tcp_tls_changes: tls: added custom memory based bio

by Andrei Pelinescu-Onciul

Module: sip-router Branch: andrei/tcp_tls_changes Commit: d13629b64226ba665bf9ed2d8211189215bb5157 URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=d13629b… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Thu Mar 25 20:30:57 2010 +0100 tls: added custom memory based bio Added a custom memory based BIO, that reads and writes in some memory buffers. It will be used to replace the direct socket access. --- modules/tls/tls_bio.c | 246 +++++++++++++++++++++++++++++++++++++++++++++++++ modules/tls/tls_bio.h | 54 +++++++++++ 2 files changed, 300 insertions(+), 0 deletions(-) diff --git a/modules/tls/tls_bio.c b/modules/tls/tls_bio.c new file mode 100644 index 0000000..a7ba50d --- /dev/null +++ b/modules/tls/tls_bio.c @@ -0,0 +1,246 @@ +/* + * $Id$ + * + * Copyright (C) 2010 iptelorg GmbH + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ +/** openssl BIOs for reading/writing via a fixed memory buffer. + * @file /home/andrei/sr.git/modules/tls/tls_bio.c + * @ingroup tls + * @Module: @ref tls + */ +/* + * History: + * -------- + * 2010-03-25 initial version (andrei) +*/ + +#include "tls_bio.h" +#include "../../compiler_opt.h" +#include "../../dprint.h" +#include "../../ut.h" + +/* 0xf2 should be unused (as of openssl 1.0.0 max. + internal defined BIO is 23) */ +#define BIO_TYPE_TLS_MBUF (BIO_TYPE_SOURCE_SINK | 0xf2) + + +static int tls_bio_mbuf_new(BIO* b); +static int tls_bio_mbuf_free(BIO* b); +static int tls_bio_mbuf_write(BIO* b, const char* buf, int num); +static int tls_bio_mbuf_read(BIO* b, char* buf, int num); +static int tls_bio_mbuf_puts(BIO* b, const char* s); +static long tls_bio_mbuf_ctrl(BIO* b, int cmd, long arg1, void* arg2); + + +static BIO_METHOD tls_mbuf_method = { + BIO_TYPE_TLS_MBUF, /* type */ + "sr_tls_mbuf", /* name */ + tls_bio_mbuf_write, /* write function */ + tls_bio_mbuf_read, /* read function */ + tls_bio_mbuf_puts, /* puts function */ + 0, /* gets function */ + tls_bio_mbuf_ctrl, /* ctrl function */ + tls_bio_mbuf_new, /* create(new) function */ + tls_bio_mbuf_free, /* destroy(free) function */ + 0 /* ctrl callback */ +}; + + +/** returns a custom tls_mbuf BIO. */ +BIO_METHOD* tls_BIO_mbuf(void) +{ + return &tls_mbuf_method; +} + + + +/** create an initialize a new tls_BIO_mbuf. + * @return new BIO on success (!=0), 0 on error. + */ +BIO* tls_BIO_new_mbuf(struct tls_mbuf* rd, struct tls_mbuf* wr) +{ + BIO* ret; + + ret = BIO_new(tls_BIO_mbuf()); + if (unlikely(ret == 0)) + return 0; + if (unlikely(tls_BIO_mbuf_set(ret, rd, wr) == 0)) { + BIO_free(ret); + return 0; + } + return ret; +} + + + +/** sets the read and write mbuf for an mbuf BIO. + * @return 1 on success, 0 on error (openssl BIO convention). + */ +int tls_BIO_mbuf_set(BIO* b, struct tls_mbuf* rd, struct tls_mbuf* wr) +{ + struct tls_bio_mbuf_data* d; + + if (unlikely(b->ptr == 0)){ + BUG("null BIO ptr\n"); + return 0; + } + d = b->ptr; + d->rd = rd; + d->wr = wr; + b->init = 1; + return 1; +} + + + +/** create a new BIO. + * (internal openssl use via the tls_mbuf method) + * @return 1 on success, 0 on error. + */ +static int tls_bio_mbuf_new(BIO* b) +{ + struct tls_bio_mbuf_data* d; + + b->init = 0; /* not initialized yet */ + b->num = 0; + b->ptr = 0; + b->flags = 0; + d = OPENSSL_malloc(sizeof(*d)); + if (unlikely(d == 0)) + return 0; + d->rd = 0; + d->wr = 0; + b->ptr = d; + return 1; +} + + + +/** destroy a tls mbuf BIO. + * (internal openssl use via the tls_mbuf method) + * @return 1 on success, 0 on error. + */ +static int tls_bio_mbuf_free(BIO* b) +{ + if (unlikely( b == 0)) + return 0; + if (likely(b->ptr)){ + OPENSSL_free(b->ptr); + b->ptr = 0; + b->init = 0; + } + return 1; +} + + + +/** read from a mbuf. + * (internal openssl use via the tls_mbuf method) + * @return bytes read on success (0< ret <=dst_len), -1 on empty buffer & sets + * should_retry_read, -1 on some other errors (w/o should_retry_read set). + */ +static int tls_bio_mbuf_read(BIO* b, char* dst, int dst_len) +{ + struct tls_bio_mbuf_data* d; + struct tls_mbuf* rd; + int ret; + + ret = 0; + if (likely(dst)) { + d= b->ptr; + BIO_clear_retry_flags(b); + if (unlikely(d == 0 || d->rd->buf == 0)) { + if (d == 0) + BUG("tls_BIO_mbuf %p: read called with null b->ptr\n", b); + else + BUG("tls_BIO_mbuf %p: read called with null read buffer\n", b); + return -1; + } + rd = d->rd; + if (unlikely(rd->used == rd->pos && dst_len)) { + /* mimic non-blocking read behaviour */ + BIO_set_retry_read(b); + return -1; + } + ret = MIN_int(rd->used - rd->pos, dst_len); + /* copy data from rd.buf into dst */ + memcpy(rd->buf+rd->pos, dst, ret); + rd->pos += ret; +/* if (unlikely(rd->pos < rd->used)) + BIO_set_retry_read(b); +*/ + } + return ret; +} + + + +/** write to a mbuf. + * (internal openssl use via the tls_mbuf method) + * @return bytes written on success (0<= ret <=src_len), -1 on error or buffer + * full (in this case sets should_retry_write). + */ +static int tls_bio_mbuf_write(BIO* b, const char* src, int src_len) +{ + struct tls_bio_mbuf_data* d; + struct tls_mbuf* wr; + int ret; + + ret = 0; + d= b->ptr; + BIO_clear_retry_flags(b); + if (unlikely(d == 0 || d->wr->buf == 0)) { + if (d == 0) + BUG("tls_BIO_mbuf %p: write called with null b->ptr\n", b); + else + BUG("tls_BIO_mbuf %p: write called with null read buffer\n", b); + return -1; + } + wr = d->wr; + if (unlikely(wr->size == wr->used && src_len)) { + /* mimic non-blocking socket behaviour */ + BIO_set_retry_write(b); + return -1; + } + ret = MIN_int(wr->size - wr->used, src_len); + memcpy(wr->buf + wr->used, src, ret); + wr->used += ret; +/* if (unlikely(ret < src_len)) + BIO_set_retry_write(); +*/ + return ret; +} + + + +static long tls_bio_mbuf_ctrl(BIO* b, int cmd, long arg1, void* arg2) +{ + /* no cmd supported */ + return 0; +} + + + +static int tls_bio_mbuf_puts(BIO* b, const char* s) +{ + int len; + + len=strlen(s); + return tls_bio_mbuf_write(b, s, len); +} + + + +/* vi: set ts=4 sw=4 tw=79:ai:cindent: */ diff --git a/modules/tls/tls_bio.h b/modules/tls/tls_bio.h new file mode 100644 index 0000000..78d5a47 --- /dev/null +++ b/modules/tls/tls_bio.h @@ -0,0 +1,54 @@ +/* + * $Id$ + * + * Copyright (C) 2010 iptelorg GmbH + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ +/** openssl BIOs for reading/writing via a fixed memory buffer. + * @file modules/tls/tls_bio.h + * @ingroup tls + * @Module: @ref tls + */ +/* + * History: + * -------- + * 2010-03-25 initial version (andrei) +*/ + +#ifndef __tls_bio_h +#define __tls_bio_h + +#include <openssl/bio.h> + +/* memory buffer used for tls I/O */ +struct tls_mbuf { + unsigned char* buf; + int pos; /* current position in the buffer while reading*/ + int used; /* how much it's used */ + int size; /* total buffer size (fixed) */ +}; + +struct tls_bio_mbuf_data { + struct tls_mbuf* rd; + struct tls_mbuf* wr; +}; + + +BIO_METHOD* tls_BIO_mbuf(void); +BIO* tls_BIO_new_mbuf(struct tls_mbuf* rd, struct tls_mbuf* wr); +int tls_BIO_mbuf_set(BIO* b, struct tls_mbuf* rd, struct tls_mbuf* wr); + +#endif /*__tls_bio_h*/ + +/* vi: set ts=4 sw=4 tw=79:ai:cindent: */

14 years, 8 months

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

sr-dev