asterisk

Commit Graph

Author	SHA1	Message	Date
Richard Mudgett	110927bacc	res_sorcery_memory_cache.c: Misc tweaks. Change-Id: I8cd32dffbb4f33bb0c39518d6e4c991e73573160	10 years ago
Richard Mudgett	14ac763ab3	res_sorcery_memory_cache.c: Made use OBJ_SEARCH_MASK. Change-Id: Ibca6574dc3c213b29cc93486e01ccd51f5caa46c	10 years ago
Matthew Jordan	39fe210fd9	res/res_pjsip_dlg_options: Add a module to handle in-dialog OPTIONS requests This patch adds a new session supplement that handles in-dialog OPTIONS requests. Said OPTIONS requests are sent a 200 OK, as an endpoint lookup for the OPTIONS request would already have been done by the time the session supplement receives the inbound request. ASTERISK-24862 #close Reported by: yaron nahum patches: res_pjsip_dlg_options.c submitted by yaron nahum (License 6676) Change-Id: Iefc901a7c5c88d9d4b853188f85092d9eb7b6ada	10 years ago
Richard Mudgett	00be2f6b4f	app_queue.c: Force COLP update if outgoing channel name changed. * When a call is answered and the outgoing channel name has changed then force a connected line update because the channel is no longer the same. The channel was masqueraded into by another channel. This is usually because of a call pickup. Note: Forwarded calls are handled in a controlled manner so the original channel name is replaced with the forwarded channel. ASTERISK-25423 #close Reported by: John Hardin Change-Id: Ie275ea9e99c092ad369db23e0feb08c44498c172	10 years ago
Richard Mudgett	bd43638622	app_queue.c: Factor out a connected line update routine. Replace inlined code with update_connected_line_from_peer(). ASTERISK-25423 Reported by: John Hardin Change-Id: I33bbd033596fcb0208d41d8970369b4e87b806f3	10 years ago
Richard Mudgett	f5a935f9d1	app_dial.c: Make 'A' option pass COLP updates. While the 'A' option is playing the announcement file allow the caller and peer to exchange COLP update frames. ASTERISK-25423 Reported by: John Hardin Change-Id: Iac6cf89b56d26452c6bb88e9363622bbf23895f9	10 years ago
Richard Mudgett	91f754cb89	app_dial.c: Force COLP update if outgoing channel name changed. * When a call is answered and the outgoing channel name has changed then force a connected line update because the channel is no longer the same. The channel was masqueraded into by another channel. This is usually because of a call pickup. Note: Forwarded calls are handled in a controlled manner so the original channel name is replaced with the forwarded channel. ASTERISK-25423 Reported by: John Hardin Change-Id: I2e01f7a698fbbc8c26344a59c2be40c6cd98b00c	10 years ago
Richard Mudgett	9792b21720	app_dial.c: Factor out a connected line update routine. Replace inlined code with update_connected_line_from_peer(). ASTERISK-25423 Reported by: John Hardin Change-Id: Ia14f18def417645cd7fb453e1bdac682630a5091	10 years ago
Mark Michelson	7a4581a41b	Do not swallow frames on channels leaving bridges. When leaving a bridge, indications on a channel could be swallowed by the internal indication logic because it appears that the channel is on its way to be hung up anyway. One such situation where this is detrimental is when channels on hold are redirected out of a bridge. The AST_CONTROL_UNHOLD indication from the bridging code is swallowed, leaving the channel in question to still appear to be on hold. The fix here is to modify the logic inside ast_indicate_data() to not drop the indication if the channel is simply leaving a bridge. This way, channels on hold redirected out of a bridge revert to their expected "in use" state after the redirection. ASTERISK-25418 #close Reported by Mark Michelson Change-Id: If6115204dfa0551c050974ee138fabd15f978949	10 years ago
Richard Mudgett	86eee104be	app_page.c: Fix crash when forwarding with a predial handler. Page uses the async method of dialing with the dial API. When a call gets forwarded there is no calling channel available. If the predial handler was set then the calling channel could not be put into auto-service for the forwarded call because it doesn't exist. A crash is the result. * Moved the callee predial parameter string processing to before the string is passed to the dial API rather than having the dial API do it. There are a few benefits do doing this. The first is the predial parameter string processing doesn't need to be done for each channel called by the dial API. The second is in async mode and the forwarded channel is to have the predial handler executed on it then the non-existent calling channel does not need to be present to process the predial parameter string. * Don't start auto-service on a non-existent calling channel to execute the predial handler when the dial API is in async mode and forwarding a call. ASTERISK-25384 #close Reported by: Chet Stevens Change-Id: If53892b286d29f6cf955e2545b03dcffa2610981	10 years ago
Mark Michelson	deccd2ef3c	Resolve race conditions involving Stasis bridges. This resolves two observed race conditions. First, a bit of background on what the Stasis application does: 1a Creates a stasis_app_control structure. This structure is linked into a global container and can be looked up using a channel's unique ID. 2a Puts the channel in an event loop. The event loop can exit either because the stasis_app_control structure has been marked done, or because of some other factor, such as a hangup. In the event loop, the stasis_app_control determines if any specific ARI commands need to be run on the channel and will run them from this thread. 3a Checks if the channel is bridged. If the channel is bridged, then ast_bridge_depart() is called since channels that are added to Stasis bridges are always imparted as departable. 4a Unlink the stasis_app_control from the container. When an ARI command is received by Asterisk, the following occurs 1b A thread is spawned to handle the HTTP request 2b The stasis_app_control(s) that corresponds to the channel(s) in the request is/are retrieved. If the stasis_app_control cannot be retrieved, then it is assumed that the channel in question has exited the Stasis app or perhaps was never in Stasis in the first place. 3b A command is queued onto the stasis_app_control, and the channel's event loop thread is signaled to run the command. 4b While most ARI commands do nothing further, some, such as adding or removing channels from a bridge, will block until the command they issued has been completed by the channel's event loop. The first race condition that is solved by this patch involves a crash that can occur due to faulty detection of the channel's bridged status in step 3a. What can happen is that in step 2a, the event loop may run the ast_bridge_impart() function to asynchronously place the channel into a bridge, then immediately exit the event loop because the channel has hung up. In step 3a, we would detect that the channel was not bridged and would not call ast_bridge_depart(). The reason that the channel did not appear to be bridged was that the depart_thread that is spawned by ast_bridge_impart() had not yet started. That is the thread where the channel is marked as being bridged. Since we did not call ast_bridge_depart(), the Stasis application would exit, and then the channel would be destroyed Then the depart_thread would start up and try to manipulate the destroyed channel, causing a crash. The fix for this is to switch from using ast_channel_is_bridged() to checking the NULLity of ast_channel_internal_bridge_channel() to determine if ast_bridge_depart() needs to be called. The channel's internal bridge_channel is set when ast_bridge_impart() is called and is NULLed by the call to ast_bridge_depart(). If the channel's internal bridge_channel is non-NULL, then the channel must have been imparted into the bridge and needs to be departed, even if the actual bridging operation has not yet started. By departing the channel when necessary, the thread that is running the Stasis application will block until the bridge gives the okay that the depart_thread has exited. The second race condition that is solved by this patch involves a leak of HTTP handler threads. The problem was that step 2b would successfully retrieve a stasis_app_control structure. Then step 2a would exit the channel from the event loop due to a hangup. Steps 3a and 4a would execute, and then finally steps 3b and 4b would. The problem is that at step 4b, when attempting to add a channel to a bridge, the thread would block forever since the channel would never execute the queued command since it was finished with the event loop. This meant that the HTTP handling thread would be leaked, along with any references that thread may have owned (in my case, I was seeing bridges leaked). The fix for this is to hone in better on when the channel has exited the event loop. The stasis_app_control structure has an is_done field that is now set at each point where the channel may exit the event loop. If step 2b retrieves a valid stasis_app_control structure but the control is marked as done, then the attempted operation exits immediately since there will be nothing to service the attempted command. ASTERISK-25091 #close Reported by Ilya Trikoz Change-Id: If66265b73b4c9f8f58599124d777fedc54576628	10 years ago
Matt Jordan	37059e6242	Merge "app_record: RECORDED_FILE variable not being populated" into certified/13.1	10 years ago
Kevin Harwell	43e6804b0c	app_record: RECORDED_FILE variable not being populated The RECORDED_FILE variable is empty unless a '%d' is specified in the filename. This patch makes it so the variable is always set to the filename. ASTERISK-25410 #close Change-Id: I4ec826d8eb582ae2ad184e717be8668b74d37653	10 years ago
Joshua Colp	ca401c6842	pbx: Update device and presence state when changing a hint extension. When changing a hint extension without removing the hint first the device state and presence state is not updated. This causes the state of the hint to be that of the previous extension and not the current one. This state is kept until a state change occurs as a result of something (presence state change, device state change). This change updates the hint with the current device and presence state of the new extension when it is changed. Any state callbacks which may have been added before the hint extension is changed are also informed of the new device and presence state if either have changed. ASTERISK-25394 #close Change-Id: If268f1110290e502c73dd289c9e7e7b27bc8432f	10 years ago
Mark Michelson	20702e0cf2	res_pjsip_pubsub: Eliminate race during initial NOTIFY. There is a slim chance of a race condition occurring where two threads can both attempt to manipulate the same area. Thread A can be handling an incoming initial SUBSCRIBE request. Thread A lets the specific subscription handler know that the subscription has been established. At this point, Thread B may detect a state change on the subscribed resource and queue up a notification task on Thread C, the subscription serializer thread. Now Thread A attempts to generate the initial NOTIFY request to send to the subscriber at the same time that Thread C attempts to generate a state change NOTIFY request to send to the subscriber. The result is that Threads A and C can step on the same memory area, resulting in a crash. The crash has been observed as happening when attempting to allocate more space to hold the body for the NOTIFY. The solution presented here is to queue the subscription establishment and initial NOTIFY generation onto the subscription serializer thread (Thread C in the above scenario). This way, there is no way that a state change notification can occur before the initial NOTIFY is sent, and if there is a quick succession of NOTIFYs, we can guarantee that the two NOTIFY requests will be sent in succession. Change-Id: I5a89a77b5f2717928c54d6efb9955e5f6f5cf815	10 years ago
Mark Michelson	3ef74244a4	scheduler: Use queue for allocating sched IDs. It has been observed that on long-running busy systems, a scheduler context can eventually hit INT_MAX for its assigned IDs and end up overflowing into a very low negative number. When this occurs, this can result in odd behaviors, because a negative return is interpreted by callers as being a failure. However, the item actually was successfully scheduled. The result may be that a freed item remains in the scheduler, resulting in a crash at some point in the future. The scheduler can overflow because every time that an item is added to the scheduler, a counter is bumped and that counter's current value is assigned as the new item's ID. This patch introduces a new method for assigning scheduler IDs. Instead of assigning from a counter, a queue of available IDs is maintained. When assigning a new ID, an ID is pulled from the queue. When a scheduler item is released, its ID is pushed back onto the queue. This way, IDs may be reused when they become available, and the growth of ID numbers is directly related to concurrent activity within a scheduler context rather than the uptime of the system. Change-Id: I532708eef8f669d823457d7fefdad9a6078b99b2	10 years ago
Mark Michelson	8826e6c416	res_pjsip: Copy default_from_user to avoid crash. The default_from_user retrieval function was pulling the default_from_user from the global configuration struct in an unsafe way. If using a database as a backend configuration store, the global configuration struct is short-lived, so grabbing a pointer from it results in referencing freed memory. The fix here is to copy the default_from_user value out of the global configuration struct. Thanks go to John Hardin for discovering this problem and proposing the patch on which this fix is based. ASTERISK-25390 #close Reported by Mark Michelson Change-Id: I6b96067a495c1259da768f4012d44e03e7c6148c	10 years ago
George Joseph	943d5c0c99	res_pjsip: Validate that contact uris start with sip: or sips: Currently we use pjsip_parse_hdr to validate contact uris but it appears that it allows uris without a scheme if there's a port supplied. I.E myexample.com will fail but myexample.com:5060 will pass even though it has no scheme. This causes SEGVs later on whenever the uri is used. To prevent this, permanent_contact_validate has been updated to check that the scheme is either 'sip' or 'sips'. 2 uses of possibly-null endpoint have also been fixed in create_out_of_dialog_request. ASTERISK-24999 Change-Id: Ifc17d16a4923e1045d37fe51e43bbe29fa556ca2 Reported-by: Brad Latus (cherry picked from commit `75666ad7c6`)	10 years ago
Jonathan Rose	7b5bcbeebe	ParkAndAnnounce: Add variable inheritance In Asterisk 11, the announcer channel would receive channel variables from the channel being parked by means of normal channel inheritance. This functionality was lost during the big res_parking project in Asterisk 12. This patch restores that functionality. ASTERISK-25369 #close Review: https://gerrit.asterisk.org/#/c/1180/ Change-Id: Ie47e618330114ad2ea91e2edcef1cb6f341eed6e	10 years ago
Joshua Colp	0901a82adb	taskprocessor: Fix race condition between unreferencing and finding. When unreferencing a taskprocessor its reference count is checked to determine if it should be unlinked from the taskprocessors container and its listener shut down. In between the time when the reference count is checked and unlinking it is possible for another thread to jump in, find it, and get a reference to it. If the thread then uses the taskprocessor it may find that it is not in the state it expects. This change locks the taskprocessors container during almost the entire unreference operation to ensure that any other thread which may attempt to find the taskprocessor has to wait. ASTERISK-25295 Change-Id: Icb842db82fe1cf238da55df92e95938a4419377c (cherry picked from commit `a676ba2aad`)	10 years ago
Matt Jordan	5b06b6f1d3	Merge "res_pjsip: Change default from user value." into certified/13.1	10 years ago
Mark Michelson	500856b4f0	res_pjsip: Change default from user value. When Asterisk sends an outbound SIP request, if there is no direct reason to place a specific value for the username in the From header, Asterisk would generate a UUID. For example, this would happen when sending outbound OPTIONS requests when qualifying or when sending outbound INVITE requests when originating (if no explicit caller ID were provided). The issue is that some SIP providers reject these sorts of requests with a "Name too long" error response. This patch aims to fix this by changing the default outbound username in From headers to "asterisk". This value can be overridden by changing the default_from_user option in the global options if desired. ASTERISK-25377 #close Reported by Mark Michelson Change-Id: I6a4d34a56ff73ff4f661b0075aeba5461b7f3190	10 years ago
Jonathan Rose	42c40b59b6	Message.c: Clear message channel frames on cleanup The message channel is a special channel that doesn't actually process frames. However, certain actions can cause frames to be placed in the channel's read queue including the Hangup application which is called on the channel after each message is processed. Since the channel will continually be reused for many messages, it's necessary to flush these frames at some point. ASTERISK-25083 #close Reported by: Jonathan Rose Change-Id: Idf18df73ccd8c220be38743335b5c79c2a4c0d0f (cherry picked from commit `02c5130589`)	10 years ago
Mark Michelson	a1e1d8e815	res_pjsip: Fix contact refleak on stateful responses. When sending a stateful response, creation of the transaction can fail, most commonly because we are trying to create a transaction from a retransmitted request. When creation of the transaction fails, we end up leaking a reference to a contact that was bumped when the response was created. This patch adds the missing deref and fixes the reference leak. Change-Id: I2f97ad512aeb1b17e87ca29ae0abacb4d6395f07	10 years ago
Joshua Colp	9f5e1c0e56	pbx: Fix crash when issuing "core show hints" with long pattern match. When issuing the "core show hints" CLI command a combination of both the hint extension and context is created. This uses a fixed size buffer expecting that the extension will not exceed maximum extension length. When the extension is actually a pattern match this constraint does not hold true, and the extension may exceed the maximum extension length. In this case extra characters are written past the end of the fixed size buffer. This change makes it so the construction of the combined hint extension and context can not exceed the size of the buffer. ASTERISK-25367 #close Change-Id: Idfa1b95d0d4dc38e675be7c1de8900b3f981f499	10 years ago
Richard Mudgett	1c89230e2a	PJSIP XML, XPIDF: Fix buffer size overwrite memory corruption error. When res_pjsip body generator modules were generating XML or XPIDF response bodies, there was a chance that the generated body would be the exact size of the supplied buffer. Adding the nul string terminator would then write beyond the end of the buffer and potentially corrupt memory. * Fix MALLOC_DEBUG high fence violations caused by adding a nul string terminator on the end of a buffer for XML or XPIDF response bodies. * Made calls to pj_xml_print() safer if the XML prolog is requested. Due to a bug in pjproject, the return value could be -1 _or_ AST_PJSIP_XML_PROLOG_LEN if the supplied buffer is not large enough. * Updated the doxygen comment of AST_PJSIP_XML_PROLOG_LEN to describe the return value of pj_xml_print() when the supplied buffer is not large enough. ASTERISK-25168 Reported by: Carl Fortin Change-Id: Id70e1d373a6a2b2bd9e678b5cbc5e55b308981de	10 years ago
Mark Michelson	2f2c35e91d	res_pjsip_pubsub: re-re-fix persistent subscription storage. A recent change to res_pjsip_pubsub switched to using pjsip_msg_print as a means of writing an appropriate packet to persistent storage. While this partially solved the issue, it had its own problems. pjsip_msg_print will always add a Content-Length header to the message it prints. Frequent restarts of Asterisk can result in persistent subscriptions being written with five or more Content-Length headers. In addition, sometimes some apparent corruption of individual headers could be seen. This aims to fix the problem by not running a parsed message through an interpreter but rather by taking the raw message and saving it. The logic for what to save is going to be different depending on whether a SUBSCRIBE was received from the wire or if it was pulled from persistence. When receiving a packet from the wire, when using a streaming transport, the rdata->pkt_info.packet may contain multiple SIP messages or fragments. However, the rdata->msg_info.msg_buf will always contain the current SIP message to be processed. When pulling from persistence, though, the rdata->msg_info.msg_buf will be NULL since no transport actually handled the packet. However, since we know that we will always ever pull one SIP message from persistence, we are free to save directly from rdata->pkt_info.packet instead. ASTERISK-25365 #close Reported by Mark Michelson Change-Id: I33153b10d0b4dc8e3801aaaee2f48173b867855b	10 years ago
Mark Michelson	88ee3b3ef2	Fix deadlock on presence state changes. A deadlock was observed where three threads were competing for different locks: * One thread held the hints lock and was attempting to lock a specific hint. * One thread was holding the specific hint's lock and was attempting to lock the contexts lock * One thread was holding the contexts lock and attempting to lock the hints lock. Clearly the second thread was doing the wrong thing here. The fix for this is to make sure that the hint's lock is not held on presence state changes. Something similar is already done (and commented about) for device state changes. ASTERISK-25362 #close Reported by Mark Michelson Change-Id: I15ec2416b92978a4c0c08273b2d46cb21aff97e2	10 years ago
Matt Jordan	9121de6e9b	Merge "res_pjsip_sdp_rtp: Fix multiple keepalive scheduled items." into certified/13.1	10 years ago
Joshua Colp	8842637d8f	res_pjsip_sdp_rtp: Fix multiple keepalive scheduled items. The keepalive support in res_pjsip_sdp_rtp currently assumes that a stream will only be negotiated once. This is false. If the stream is replaced and later added back it can be negotiated again causing multiple keepalive scheduled items to exist. This change explicitly deletes the existing keepalive scheduled item before adding the new one. The res_pjsip_sdp_rtp module also does not stop RTP keepalives or timeout timer if the stream has been replaced. This change adds a callback to the session media interface to allow a media stream to be stopped without the resources being destroyed. This allows the scheduled items and RTP to be stopped when the stream no longer exists. ASTERISK-25356 #close Change-Id: Ibe6a7cc0927c87326fd5f1c0d4ad889dbfbea1de	10 years ago
Joshua Colp	06d42fede3	sched: ast_sched_del may return prematurely due to spurious wakeup When deleting a scheduled item if the item in question is currently executing the ast_sched_del function waits until it has completed. This is accomplished using ast_cond_wait. Unfortunately the ast_cond_wait function can suffer from spurious wakeups so the predicate needs to be checked after it returns to make sure it has really woken up as a result of being signaled. This change adds a loop around the ast_cond_wait to make sure that it only exits when the executing task has really completed. ASTERISK-25355 #close Change-Id: I51198270eb0b637c956c61aa409f46283432be61	10 years ago
Joshua Colp	042ece7669	Merge "Local channels: Alternate solution to ringback problem." into certified/13.1	10 years ago
Joshua Colp	9245a4a085	Merge "res_pjsip: Add common ast_sip_get_host_ip API." into certified/13.1	10 years ago
Mark Michelson	74d6ae20cb	Local channels: Alternate solution to ringback problem. Commit `54b25c80c8` solved an issue where a specific scenario involving local channels and a native local RTP bridge could result in ringback still being heard on a calling channel even after the call is bridged. That commit caused many tests in the testsuite to fail with alarming consequences, such as not sending DialBegin and DialEnd events, and giving incorrect hangup causes during calls. This commit reverts the previous commit and implements and alternate solution. This new solution involves only passing AST_CONTROL_RINGING frames across local channels if the local channel is in AST_STATE_RING. Otherwise, the frame does not traverse the local channels. By doing this, we can ensure that a playtones generator does not get started on the calling channel but rather is started on the local channel on which the ringing frame was initially indicated. ASTERISK-25250 #close Reported by Etienne Lessard Change-Id: I3bc87a18a38eb2b68064f732d098edceb5c19f39	10 years ago
Joshua Colp	54a09e4cb5	chan_sip: Allow call pickup to set the hangup cause. The call pickup implementation in chan_sip currently sets the channel hangup cause to "normal clearing" if call pickup is successfully performed. This action overwrites the "answered elsewhere" hangup cause set by the call pickup code and can result in the SIP device in question showing a missed call when it should not. This change sets the hangup cause to "normal clearing" as a default initially but allows the call pickup to change it as needed. ASTERISK-25346 #close Change-Id: I00ac2c269cee9e29586ee2c65e83c70e52a02cff	10 years ago
Joshua Colp	942d0ba96f	res_pjsip: Add common ast_sip_get_host_ip API. Modules commonly used the pj_gethostip function for retrieving the IP address of the host. This function does not cache the result and may result in a DNS lookup occurring, or additional work. If the DNS server is unreachable or network issues arise this can cause the pj_gethostip function to block for a period of time. This change adds an ast_sip_get_host_ip and ast_sip_get_host_ip_string function which does the same thing but caches the host IP address at module load time. This results in no additional work being done each time the local host IP address is needed. ASTERISK-25342 #close Change-Id: I3205deb679b01fa5ac05a94b623bfd620a2abe1e	10 years ago
Mark Michelson	30119f7e88	Merge "bridge: Kick channel from bridge if hung up during action." into certified/13.1	10 years ago
Joshua Colp	ad4e895928	bridge: Kick channel from bridge if hung up during action. When executing an action in a bridge it is possible for the channel to be hung up without the bridge becoming aware of it. This is most easily reproducible by hanging up when the bridge is streaming DTMF due to a feature timeout. This change makes it so after action execution the channel is checked to determine if it has been hung up and if it has it is kicked from the bridge. ASTERISK-25341 #close Change-Id: I6dd8b0c3f5888da1c57afed9e8a802ae0a053062	10 years ago
Joshua Colp	4083e543fd	res_pjsip_pubsub: On recreated notify fail deleted sub_tree is referenced When recreating a subscription it is possible for a freed sub_tree to be referenced when the initial NOTIFY fails to be created. Change-Id: I681c215309aad01b21d611c2de47b3b0a6022788	10 years ago
Scott Griepentrog	0b04269e73	res_pjsip_pubsub: On notify fail deleted sub_tree is then referenced This change makes the send_notify of the sub_tree not happen when the sub_tree has been deleted due to the notify call failing, which avoids a crash. ASTERISK-24970 #close Change-Id: I1f20ffc08b192f59c457293b218025a693992cbf (cherry picked from commit `8d4ce7cc2b`)	10 years ago
Mark Michelson	f049ad951b	res_pjsip_sdp_rtp: Restore removed NULL check. When sending an RTP keepalive, we need to be sure we're not dealing with a NULL RTP instance. There had been a NULL check, but the commit that added the rtp_timeout and rtp_hold_timeout options removed the NULL check. Change-Id: I2d7dcd5022697cfc6bf3d9e19245419078e79b64	10 years ago
Richard Mudgett	fb347a4ded	audiohook.c: Fix MixMonitor crash when using the r() or t() options. The built frame format in audiohook_read_frame_both() is now set to a signed linear format before the rx and tx frames are duplicated instead of only for the mixed audio frame duplication. ASTERISK-25322 #close Reported by Sean Pimental Change-Id: I86f85b5c48c49e4e2d3b770797b9d484250a1538	10 years ago
Mark Michelson	a8207b6c37	Merge "chan_sip.c: wrong peer searched in sip_report_security_event" into certified/13.1	10 years ago
Kevin Harwell	a5049df640	chan_sip.c: wrong peer searched in sip_report_security_event In chan_sip, after handling an incoming invite a security event is raised describing authorization (success, failure, etc...). However, it was doing a lookup of the peer by extension. This is fine for register messages, but in the case of an invite it may search and find the wrong peer, or a non existent one (for instance, in the case of call pickup). Also, if the peers are configured through realtime this may cause an unnecessary database lookup when caching is enabled. This patch makes it so that sip_report_security_event searches by IP address when looking for a peer instead of by extension after an invite is processed. ASTERISK-25320 #close Change-Id: I9b3f11549efb475b6561c64f0e6da1a481d98bc4	10 years ago
Joshua Colp	7089472637	res_http_websocket: When shutting down a session don't close closed socket Due to the use of ast_websocket_close in session termination it is possible for the underlying socket to already be closed when the session is terminated. This occurs when the close frame is attempted to be written out but fails. Change-Id: I7572583529a42a7dc911ea77a974d8307d5c0c8b	10 years ago
Joshua Colp	28a98b9715	Merge "res_http_websocket: Forcefully terminate on write errors." into certified/13.1	10 years ago
Joshua Colp	128d2348e6	res_http_websocket: Forcefully terminate on write errors. The res_http_websocket module will currently attempt to close the WebSocket connection if fatal cases occur, such as when attempting to write out data and being unable to. When the fatal cases occur the code attempts to write a WebSocket close frame out to have the remote side close the connection. If writing this fails then the connection is not terminated. This change forcefully terminates the connection if the WebSocket is to be closed but is unable to send the close frame. ASTERISK-25312 #close Change-Id: I10973086671cc192a76424060d9ec8e688602845	10 years ago
Richard Mudgett	6b219a866c	chan_dahdi.c: Flush the DAHDI write buffer after starting DTMF. Pressing DTMF digits on a phone to go out on a DAHDI channel can result in the digit not being recognized or even heard by the peer. Phone -> Asterisk -> DAHDI/channel Turns out the DAHDI behavior with DTMF generation (and any other generated tones) is exposed by the "buffers=" setting in chan_dahdi.conf. When Asterisk requests to start sending DTMF then DAHDI waits until its write buffer is empty before generating any samples for the DTMF tones. When Asterisk subsequently requests DAHDI to stop sending DTMF then DAHDI immediately stops generating the DTMF samples. As a result, the more samples there are in the DAHDI write buffer the shorter the time DTMF actually gets sent on the wire. If there are more samples in the write buffer than the time DTMF is supposed to be sent then no DTMF gets sent on the wire. With the "buffers=12,half" setting and each buffer representing 20 ms of samples then the DAHDI write buffer is going to contain around 120 ms of samples. For DTMF to be recognized by the peer the actual sent DTMF duration needs to be a minimum of 40 ms. Therefore, the intended duration needs to be a minimum of 160 ms for the peer to receive the minimum DTMF digit duration to recognize it. A simple and effective solution to work around the DAHDI behavior is for Asterisk to flush the DAHDI write buffer when sending DTMF so the full duration of DTMF is actually sent on the wire. When someone is going to send DTMF they are not likely to be talking before sending the tones so the flushed write samples are expected to just contain silence. * Made dahdi_digit_begin() flush the DAHDI write buffer after requesting to send a DTMF digit. ASTERISK-25315 #close Reported by John Hardin Change-Id: Ib56262c708cb7858082156bfc70ebd0a220efa6a	10 years ago
Richard Mudgett	fc4455216a	chan_dahdi.c: Lock private struct for ast_write(). There is a window of opportunity for DTMF to not go out if an audio frame is in the process of being written to DAHDI while another thread starts sending DTMF. The thread sending the audio frame could be past the currently dialing check before being preempted by another thread starting a DTMF generation request. When the thread sending the audio frame resumes it will then cause DAHDI to stop the DTMF tone generation. The result is no DTMF goes out. * Made dahdi_write() lock the private struct before writing to the DAHDI file descriptor. ASTERISK-25315 Reported by John Hardin Change-Id: Ib4e0264cf63305ed5da701188447668e72ec9abb	10 years ago
Richard Mudgett	739fca6084	res_pjsip.c: Fix crash from corrupt saved SUBSCRIBE message. If the saved SUBSCRIBE message is not parseable for whatever reason then Asterisk could crash when libpjsip tries to parse the message and adds an error message to the parse error list. * Made ast_sip_create_rdata() initialize the parse error rdata list. The list is checked after parsing to see that it remains empty for the function to return successful. ASTERISK-25306 Reported by Mark Michelson Change-Id: Ie0677f69f707503b1a37df18723bd59418085256	10 years ago

1 2 3 4 5 ...

26211 Commits (110927bacc40706a110ad5d9f94e2eb85d8b9710) All Branches Search

26211 Commits (110927bacc40706a110ad5d9f94e2eb85d8b9710)

All Branches