1 /* 2 linphone 3 Copyright (C) 2010 Simon MORLAT (simon.morlat@free.fr) 4 5 This program is free software; you can redistribute it and/or 6 modify it under the terms of the GNU General Public License 7 as published by the Free Software Foundation; either version 2 8 of the License, or (at your option) any later version. 9 10 This program is distributed in the hope that it will be useful, 11 but WITHOUT ANY WARRANTY; without even the implied warranty of 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 GNU General Public License for more details. 14 15 You should have received a copy of the GNU General Public License 16 along with this program; if not, write to the Free Software 17 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. 18 */ 19 20 /** 21 This header files defines the Signaling Abstraction Layer. 22 The purpose of this layer is too allow experiment different call signaling 23 protocols and implementations under linphone, for example SIP, JINGLE... 24 **/ 25 26 #ifndef sal_h 27 #define sal_h 28 29 #ifdef HAVE_CONFIG_H 30 #include "config.h" 31 #endif 32 33 #include "mediastreamer2/mediastream.h" 34 #include "ortp/rtpsession.h" 35 #include "belle-sip/belle-sip.h" 36 37 #ifndef LINPHONE_PUBLIC 38 #if defined(_MSC_VER) 39 #ifdef LINPHONE_EXPORTS 40 #define LINPHONE_PUBLIC __declspec(dllexport) 41 #else 42 #define LINPHONE_PUBLIC __declspec(dllimport) 43 #endif 44 #else 45 #define LINPHONE_PUBLIC 46 #endif 47 #endif 48 49 #ifdef __cplusplus 50 extern "C" { 51 #endif 52 53 /*Dirty hack, keep in sync with mediastreamer2/include/mediastream.h */ 54 #ifndef PAYLOAD_TYPE_FLAG_CAN_RECV 55 #define PAYLOAD_TYPE_FLAG_CAN_RECV PAYLOAD_TYPE_USER_FLAG_1 56 #define PAYLOAD_TYPE_FLAG_CAN_SEND PAYLOAD_TYPE_USER_FLAG_2 57 #endif 58 struct Sal; 59 60 typedef struct Sal Sal; 61 62 struct SalOp; 63 64 typedef struct SalOp SalOp; 65 66 struct SalAddress; 67 68 typedef struct SalAddress SalAddress; 69 70 struct SalBodyHandler; 71 72 typedef struct SalBodyHandler SalBodyHandler; 73 74 struct SalCustomHeader; 75 76 typedef struct SalCustomHeader SalCustomHeader; 77 78 struct SalCustomSdpAttribute; 79 80 typedef struct SalCustomSdpAttribute SalCustomSdpAttribute; 81 82 struct addrinfo; 83 84 typedef enum { 85 SalTransportUDP, /*UDP*/ 86 SalTransportTCP, /*TCP*/ 87 SalTransportTLS, /*TLS*/ 88 SalTransportDTLS, /*DTLS*/ 89 }SalTransport; 90 91 #define SAL_MEDIA_DESCRIPTION_UNCHANGED 0x00 92 #define SAL_MEDIA_DESCRIPTION_NETWORK_CHANGED (1) 93 #define SAL_MEDIA_DESCRIPTION_CODEC_CHANGED (1<<1) 94 #define SAL_MEDIA_DESCRIPTION_CRYPTO_KEYS_CHANGED (1<<2) 95 #define SAL_MEDIA_DESCRIPTION_CRYPTO_POLICY_CHANGED (1<<3) 96 #define SAL_MEDIA_DESCRIPTION_STREAMS_CHANGED (1<<4) 97 #define SAL_MEDIA_DESCRIPTION_NETWORK_XXXCAST_CHANGED (1<<5) /* use to notify when switching from multicast to unicast*/ 98 #define SAL_MEDIA_DESCRIPTION_FORCE_STREAM_RECONSTRUCTION (1<<6) /* use force graph reconstruction*/ 99 #define SAL_MEDIA_DESCRIPTION_ICE_RESTART_DETECTED (1<<7) 100 101 102 103 const char* sal_transport_to_string(SalTransport transport); 104 SalTransport sal_transport_parse(const char*); 105 /* Address manipulation API*/ 106 SalAddress * sal_address_new(const char *uri); 107 SalAddress * sal_address_clone(const SalAddress *addr); 108 SalAddress * sal_address_ref(SalAddress *addr); 109 void sal_address_unref(SalAddress *addr); 110 const char *sal_address_get_scheme(const SalAddress *addr); 111 const char *sal_address_get_display_name(const SalAddress* addr); 112 const char *sal_address_get_display_name_unquoted(const SalAddress *addr); 113 const char *sal_address_get_username(const SalAddress *addr); 114 const char *sal_address_get_domain(const SalAddress *addr); 115 int sal_address_get_port(const SalAddress *addr); 116 bool_t sal_address_is_secure(const SalAddress *addr); 117 void sal_address_set_secure(SalAddress *addr, bool_t enabled); 118 119 SalTransport sal_address_get_transport(const SalAddress* addr); 120 const char* sal_address_get_transport_name(const SalAddress* addr); 121 const char *sal_address_get_method_param(const SalAddress *addr); 122 123 void sal_address_set_display_name(SalAddress *addr, const char *display_name); 124 void sal_address_set_username(SalAddress *addr, const char *username); 125 void sal_address_set_domain(SalAddress *addr, const char *host); 126 void sal_address_set_port(SalAddress *uri, int port); 127 void sal_address_clean(SalAddress *addr); 128 char *sal_address_as_string(const SalAddress *u); 129 char *sal_address_as_string_uri_only(const SalAddress *u); 130 void sal_address_destroy(SalAddress *u); 131 void sal_address_set_param(SalAddress *u,const char* name,const char* value); 132 void sal_address_set_transport(SalAddress* addr,SalTransport transport); 133 void sal_address_set_transport_name(SalAddress* addr,const char* transport); 134 void sal_address_set_method_param(SalAddress *addr, const char *method); 135 void sal_address_set_params(SalAddress *addr, const char *params); 136 bool_t sal_address_has_param(const SalAddress *addr, const char *name); 137 const char * sal_address_get_param(const SalAddress *addr, const char *name); 138 void sal_address_set_uri_param(SalAddress *addr, const char *name, const char *value); 139 void sal_address_set_uri_params(SalAddress *addr, const char *params); 140 bool_t sal_address_has_uri_param(const SalAddress *addr, const char *name); 141 const char * sal_address_get_uri_param(const SalAddress *addr, const char *name); 142 bool_t sal_address_is_ipv6(const SalAddress *addr); 143 bool_t sal_address_is_sip(const SalAddress *addr); 144 void sal_address_set_password(SalAddress *addr, const char *passwd); 145 const char *sal_address_get_password(const SalAddress *addr); 146 void sal_address_set_header(SalAddress *addr, const char *header_name, const char *header_value); 147 const char *sal_address_get_header(const SalAddress *addr, const char *name); 148 149 LINPHONE_PUBLIC Sal * sal_init(MSFactory *factory); 150 LINPHONE_PUBLIC void sal_uninit(Sal* sal); 151 void sal_set_user_pointer(Sal *sal, void *user_data); 152 void *sal_get_user_pointer(const Sal *sal); 153 154 155 typedef enum { 156 SalAudio, 157 SalVideo, 158 SalText, 159 SalOther 160 } SalStreamType; 161 const char* sal_stream_type_to_string(SalStreamType type); 162 163 typedef enum{ 164 SalProtoRtpAvp, 165 SalProtoRtpSavp, 166 SalProtoRtpAvpf, 167 SalProtoRtpSavpf, 168 SalProtoUdpTlsRtpSavp, 169 SalProtoUdpTlsRtpSavpf, 170 SalProtoOther 171 }SalMediaProto; 172 const char* sal_media_proto_to_string(SalMediaProto type); 173 174 typedef enum{ 175 SalStreamSendRecv, 176 SalStreamSendOnly, 177 SalStreamRecvOnly, 178 SalStreamInactive 179 }SalStreamDir; 180 const char* sal_stream_dir_to_string(SalStreamDir type); 181 182 183 #define SAL_ENDPOINT_CANDIDATE_MAX 2 184 185 #define SAL_MEDIA_DESCRIPTION_MAX_ICE_ADDR_LEN 64 186 #define SAL_MEDIA_DESCRIPTION_MAX_ICE_FOUNDATION_LEN 32 187 #define SAL_MEDIA_DESCRIPTION_MAX_ICE_TYPE_LEN 6 188 189 typedef struct SalIceCandidate { 190 char addr[SAL_MEDIA_DESCRIPTION_MAX_ICE_ADDR_LEN]; 191 char raddr[SAL_MEDIA_DESCRIPTION_MAX_ICE_ADDR_LEN]; 192 char foundation[SAL_MEDIA_DESCRIPTION_MAX_ICE_FOUNDATION_LEN]; 193 char type[SAL_MEDIA_DESCRIPTION_MAX_ICE_TYPE_LEN]; 194 unsigned int componentID; 195 unsigned int priority; 196 int port; 197 int rport; 198 } SalIceCandidate; 199 200 #define SAL_MEDIA_DESCRIPTION_MAX_ICE_CANDIDATES 20 201 202 typedef struct SalIceRemoteCandidate { 203 char addr[SAL_MEDIA_DESCRIPTION_MAX_ICE_ADDR_LEN]; 204 int port; 205 } SalIceRemoteCandidate; 206 207 #define SAL_MEDIA_DESCRIPTION_MAX_ICE_REMOTE_CANDIDATES 2 208 209 #define SAL_MEDIA_DESCRIPTION_MAX_ICE_UFRAG_LEN 256 210 #define SAL_MEDIA_DESCRIPTION_MAX_ICE_PWD_LEN 256 211 212 /*sufficient for 256bit keys encoded in base 64*/ 213 #define SAL_SRTP_KEY_SIZE 128 214 215 typedef struct SalSrtpCryptoAlgo { 216 unsigned int tag; 217 MSCryptoSuite algo; 218 char master_key[SAL_SRTP_KEY_SIZE]; 219 } SalSrtpCryptoAlgo; 220 221 #define SAL_CRYPTO_ALGO_MAX 4 222 223 typedef enum { 224 SalDtlsRoleInvalid, 225 SalDtlsRoleIsServer, 226 SalDtlsRoleIsClient, 227 SalDtlsRoleUnset 228 } SalDtlsRole; 229 230 typedef enum { 231 SalMulticastInactive=0, 232 SalMulticastSender, 233 SalMulticastReceiver, 234 SalMulticastSenderReceiver 235 } SalMulticastRole; 236 237 typedef enum { 238 SalOpSDPNormal = 0, /** No special handling for SDP */ 239 SalOpSDPSimulateError, /** Will simulate an SDP parsing error */ 240 SalOpSDPSimulateRemove /** Will simulate no SDP in the op */ 241 } SalOpSDPHandling; 242 243 typedef struct SalStreamDescription{ 244 char name[16]; /*unique name of stream, in order to ease offer/answer model algorithm*/ 245 SalMediaProto proto; 246 SalStreamType type; 247 char typeother[32]; 248 char proto_other[32]; 249 char rtp_addr[64]; 250 char rtcp_addr[64]; 251 unsigned int rtp_ssrc; 252 char rtcp_cname[256]; 253 int rtp_port; 254 int rtcp_port; 255 MSList *payloads; /*<list of PayloadType */ 256 MSList *already_assigned_payloads; /*<list of PayloadType offered in the past, used for correct allocation of payload type numbers*/ 257 int bandwidth; 258 int ptime; 259 SalStreamDir dir; 260 SalSrtpCryptoAlgo crypto[SAL_CRYPTO_ALGO_MAX]; 261 unsigned int crypto_local_tag; 262 int max_rate; 263 bool_t implicit_rtcp_fb; 264 OrtpRtcpFbConfiguration rtcp_fb; 265 OrtpRtcpXrConfiguration rtcp_xr; 266 SalCustomSdpAttribute *custom_sdp_attributes; 267 SalIceCandidate ice_candidates[SAL_MEDIA_DESCRIPTION_MAX_ICE_CANDIDATES]; 268 SalIceRemoteCandidate ice_remote_candidates[SAL_MEDIA_DESCRIPTION_MAX_ICE_REMOTE_CANDIDATES]; 269 char ice_ufrag[SAL_MEDIA_DESCRIPTION_MAX_ICE_UFRAG_LEN]; 270 char ice_pwd[SAL_MEDIA_DESCRIPTION_MAX_ICE_PWD_LEN]; 271 bool_t ice_mismatch; 272 bool_t set_nortpproxy; /*Formely set by ICE to indicate to the proxy that it has nothing to do*/ 273 bool_t rtcp_mux; 274 bool_t pad[1]; 275 char dtls_fingerprint[256]; 276 SalDtlsRole dtls_role; 277 uint8_t zrtphash[128]; 278 uint8_t haveZrtpHash; /**< flag for zrtp hash presence */ 279 int ttl; /*for multicast -1 to disable*/ 280 SalMulticastRole multicast_role; 281 } SalStreamDescription; 282 283 const char *sal_multicast_role_to_string(SalMulticastRole role); 284 const char *sal_stream_description_get_type_as_string(const SalStreamDescription *desc); 285 const char *sal_stream_description_get_proto_as_string(const SalStreamDescription *desc); 286 287 #define SAL_MEDIA_DESCRIPTION_MAX_STREAMS 8 288 289 typedef struct SalMediaDescription{ 290 int refcount; 291 char name[64]; 292 char addr[64]; 293 char username[64]; 294 int nb_streams; 295 int bandwidth; 296 unsigned int session_ver; 297 unsigned int session_id; 298 SalStreamDir dir; 299 SalStreamDescription streams[SAL_MEDIA_DESCRIPTION_MAX_STREAMS]; 300 SalCustomSdpAttribute *custom_sdp_attributes; 301 OrtpRtcpXrConfiguration rtcp_xr; 302 char ice_ufrag[SAL_MEDIA_DESCRIPTION_MAX_ICE_UFRAG_LEN]; 303 char ice_pwd[SAL_MEDIA_DESCRIPTION_MAX_ICE_PWD_LEN]; 304 bool_t ice_lite; 305 bool_t set_nortpproxy; 306 bool_t pad[2]; 307 } SalMediaDescription; 308 309 typedef struct SalMessage{ 310 const char *from; 311 const char *text; 312 const char *url; 313 const char *message_id; 314 const char *content_type; 315 time_t time; 316 }SalMessage; 317 318 #define SAL_MEDIA_DESCRIPTION_MAX_MESSAGE_ATTRIBUTES 5 319 320 SalMediaDescription *sal_media_description_new(void); 321 SalMediaDescription * sal_media_description_ref(SalMediaDescription *md); 322 void sal_media_description_unref(SalMediaDescription *md); 323 bool_t sal_media_description_empty(const SalMediaDescription *md); 324 int sal_media_description_equals(const SalMediaDescription *md1, const SalMediaDescription *md2); 325 char * sal_media_description_print_differences(int result); 326 bool_t sal_media_description_has_dir(const SalMediaDescription *md, SalStreamDir dir); 327 LINPHONE_PUBLIC SalStreamDescription *sal_media_description_find_stream(SalMediaDescription *md, SalMediaProto proto, SalStreamType type); 328 unsigned int sal_media_description_nb_active_streams_of_type(SalMediaDescription *md, SalStreamType type); 329 SalStreamDescription * sal_media_description_get_active_stream_of_type(SalMediaDescription *md, SalStreamType type, unsigned int idx); 330 SalStreamDescription * sal_media_description_find_secure_stream_of_type(SalMediaDescription *md, SalStreamType type); 331 SalStreamDescription * sal_media_description_find_best_stream(SalMediaDescription *md, SalStreamType type); 332 void sal_media_description_set_dir(SalMediaDescription *md, SalStreamDir stream_dir); 333 bool_t sal_stream_description_active(const SalStreamDescription *sd); 334 bool_t sal_stream_description_has_avpf(const SalStreamDescription *sd); 335 bool_t sal_stream_description_has_implicit_avpf(const SalStreamDescription *sd); 336 bool_t sal_stream_description_has_srtp(const SalStreamDescription *sd); 337 bool_t sal_stream_description_has_dtls(const SalStreamDescription *sd); 338 bool_t sal_stream_description_has_ipv6(const SalStreamDescription *md); 339 bool_t sal_media_description_has_avpf(const SalMediaDescription *md); 340 bool_t sal_media_description_has_implicit_avpf(const SalMediaDescription *md); 341 bool_t sal_media_description_has_srtp(const SalMediaDescription *md); 342 bool_t sal_media_description_has_dtls(const SalMediaDescription *md); 343 bool_t sal_media_description_has_zrtp(const SalMediaDescription *md); 344 bool_t sal_media_description_has_ipv6(const SalMediaDescription *md); 345 int sal_media_description_get_nb_active_streams(const SalMediaDescription *md); 346 347 struct SalOpBase; 348 typedef void (*SalOpReleaseCb)(struct SalOpBase *op); 349 350 /*this structure must be at the first byte of the SalOp structure defined by implementors*/ 351 typedef struct SalOpBase{ 352 Sal *root; 353 char *route; /*or request-uri for REGISTER*/ 354 MSList* route_addresses; /*list of SalAddress* */ 355 SalAddress* contact_address; 356 char *from; 357 SalAddress* from_address; 358 char *to; 359 SalAddress* to_address; 360 char *origin; 361 SalAddress* origin_address; 362 SalAddress* diversion_address; 363 char *remote_ua; 364 SalAddress* remote_contact_address; 365 char *remote_contact; 366 SalMediaDescription *local_media; 367 SalMediaDescription *remote_media; 368 void *user_pointer; 369 const char* call_id; 370 char* realm; 371 SalAddress* service_route; /*as defined by rfc3608, might be a list*/ 372 SalCustomHeader *sent_custom_headers; 373 SalCustomHeader *recv_custom_headers; 374 char* entity_tag; /*as defined by rfc3903 (I.E publih)*/ 375 SalOpReleaseCb release_cb; 376 } SalOpBase; 377 378 379 typedef enum SalReason{ 380 SalReasonNone, /*no error, please leave first so that it takes 0 value*/ 381 SalReasonDeclined, 382 SalReasonBusy, 383 SalReasonRedirect, 384 SalReasonTemporarilyUnavailable, 385 SalReasonRequestTimeout, 386 SalReasonNotFound, 387 SalReasonDoNotDisturb, 388 SalReasonUnsupportedContent, 389 SalReasonForbidden, 390 SalReasonUnknown, 391 SalReasonServiceUnavailable, 392 SalReasonRequestPending, 393 SalReasonUnauthorized, 394 SalReasonNotAcceptable, 395 SalReasonNoMatch, /*equivalent to 481 Transaction/Call leg does not exist*/ 396 SalReasonMovedPermanently, 397 SalReasonGone, 398 SalReasonAddressIncomplete, 399 SalReasonNotImplemented, 400 SalReasonBadGateway, 401 SalReasonServerTimeout, 402 SalReasonIOError, 403 SalReasonInternalError 404 }SalReason; 405 406 const char* sal_reason_to_string(const SalReason reason); 407 408 typedef struct SalErrorInfo{ 409 SalReason reason; 410 char *status_string; 411 int protocol_code; 412 char *warnings; 413 char *protocol; 414 char *full_string; /*concatenation of status_string + warnings*/ 415 struct SalErrorInfo *sub_sei; 416 }SalErrorInfo; 417 418 typedef enum SalPresenceStatus{ 419 SalPresenceOffline, 420 SalPresenceOnline, 421 SalPresenceBusy, 422 SalPresenceBerightback, 423 SalPresenceAway, 424 SalPresenceOnthephone, 425 SalPresenceOuttolunch, 426 SalPresenceDonotdisturb, 427 SalPresenceMoved, 428 SalPresenceAltService, 429 SalPresenceOnVacation 430 }SalPresenceStatus; 431 432 struct _SalPresenceModel; 433 typedef struct _SalPresenceModel SalPresenceModel; 434 435 const char* sal_presence_status_to_string(const SalPresenceStatus status); 436 437 typedef enum SalReferStatus{ 438 SalReferTrying, 439 SalReferSuccess, 440 SalReferFailed 441 }SalReferStatus; 442 443 typedef enum SalSubscribeStatus{ 444 SalSubscribeNone, 445 SalSubscribePending, 446 SalSubscribeActive, 447 SalSubscribeTerminated 448 }SalSubscribeStatus; 449 450 typedef enum SalMessageDeliveryStatus{ 451 SalMessageDeliveryInProgress, 452 SalMessageDeliveryDone, 453 SalMessageDeliveryFailed 454 }SalMessageDeliveryStatus; 455 456 /** 457 * auth event mode 458 * */ 459 typedef enum SalAuthMode { /*this enum must be same as belle_sip_auth_mode_t*/ 460 SalAuthModeHttpDigest, /** Digest authentication requested*/ 461 SalAuthModeTls /** Client certificate requested*/ 462 }SalAuthMode; 463 464 struct _SalCertificatesChain; 465 typedef struct _SalCertificatesChain SalCertificatesChain; 466 struct _SalSigningKey; 467 typedef struct _SalSigningKey SalSigningKey; 468 469 /** 470 * Format of certificate buffer 471 * */ 472 typedef enum SalCertificateRawFormat {/*this enum must be same as belle_sip_certificate_raw_format_t*/ 473 SAL_CERTIFICATE_RAW_FORMAT_PEM, /** PEM format*/ 474 SAL_CERTIFICATE_RAW_FORMAT_DER /** ASN.1 raw format*/ 475 }SalCertificateRawFormat; 476 477 478 479 typedef struct SalAuthInfo{ 480 char *username; 481 char *userid; 482 char *password; 483 char *realm; 484 char *domain; 485 char *ha1; 486 SalAuthMode mode; 487 SalSigningKey *key; 488 SalCertificatesChain *certificates; 489 }SalAuthInfo; 490 491 typedef void (*SalOnCallReceived)(SalOp *op); 492 typedef void (*SalOnCallRinging)(SalOp *op); 493 typedef void (*SalOnCallAccepted)(SalOp *op); 494 typedef void (*SalOnCallAckReceived)(SalOp *op, SalCustomHeader *ack); 495 typedef void (*SalOnCallAckBeingSent)(SalOp *op, SalCustomHeader *ack); 496 typedef void (*SalOnCallUpdating)(SalOp *op, bool_t is_update);/*< Called when a reINVITE/UPDATE is received*/ 497 typedef void (*SalOnCallTerminated)(SalOp *op, const char *from); 498 typedef void (*SalOnCallFailure)(SalOp *op); 499 typedef void (*SalOnCallReleased)(SalOp *salop); 500 typedef void (*SalOnCallCancelDone)(SalOp *salop); 501 typedef void (*SalOnAuthRequestedLegacy)(SalOp *op, const char *realm, const char *username); 502 typedef bool_t (*SalOnAuthRequested)(Sal *sal,SalAuthInfo* info); 503 typedef void (*SalOnAuthFailure)(SalOp *op, SalAuthInfo* info); 504 typedef void (*SalOnRegisterSuccess)(SalOp *op, bool_t registered); 505 typedef void (*SalOnRegisterFailure)(SalOp *op); 506 typedef void (*SalOnVfuRequest)(SalOp *op); 507 typedef void (*SalOnDtmfReceived)(SalOp *op, char dtmf); 508 typedef void (*SalOnRefer)(Sal *sal, SalOp *op, const char *referto); 509 typedef void (*SalOnMessageReceived)(SalOp *op, const SalMessage *msg); 510 typedef void (*SalOnMessageDeliveryUpdate)(SalOp *op, SalMessageDeliveryStatus); 511 typedef void (*SalOnNotifyRefer)(SalOp *op, SalReferStatus state); 512 typedef void (*SalOnSubscribeResponse)(SalOp *op, SalSubscribeStatus status, int will_retry); 513 typedef void (*SalOnNotify)(SalOp *op, SalSubscribeStatus status, const char *event, SalBodyHandler *body); 514 typedef void (*SalOnSubscribeReceived)(SalOp *salop, const char *event, const SalBodyHandler *body); 515 typedef void (*SalOnIncomingSubscribeClosed)(SalOp *salop); 516 typedef void (*SalOnParsePresenceRequested)(SalOp *salop, const char *content_type, const char *content_subtype, const char *content, SalPresenceModel **result); 517 typedef void (*SalOnConvertPresenceToXMLRequested)(SalOp *salop, SalPresenceModel *presence, const char *contact, char **content); 518 typedef void (*SalOnNotifyPresence)(SalOp *op, SalSubscribeStatus ss, SalPresenceModel *model, const char *msg); 519 typedef void (*SalOnSubscribePresenceReceived)(SalOp *salop, const char *from); 520 typedef void (*SalOnSubscribePresenceClosed)(SalOp *salop, const char *from); 521 typedef void (*SalOnPingReply)(SalOp *salop); 522 typedef void (*SalOnInfoReceived)(SalOp *salop, SalBodyHandler *body); 523 typedef void (*SalOnPublishResponse)(SalOp *salop); 524 typedef void (*SalOnNotifyResponse)(SalOp *salop); 525 typedef void (*SalOnExpire)(SalOp *salop); 526 /*allows sal implementation to access auth info if available, return TRUE if found*/ 527 528 529 530 typedef struct SalCallbacks{ 531 SalOnCallReceived call_received; 532 SalOnCallReceived call_rejected; 533 SalOnCallRinging call_ringing; 534 SalOnCallAccepted call_accepted; 535 SalOnCallAckReceived call_ack_received; 536 SalOnCallAckBeingSent call_ack_being_sent; 537 SalOnCallUpdating call_updating; 538 SalOnCallTerminated call_terminated; 539 SalOnCallFailure call_failure; 540 SalOnCallReleased call_released; 541 SalOnCallCancelDone call_cancel_done; 542 SalOnAuthFailure auth_failure; 543 SalOnRegisterSuccess register_success; 544 SalOnRegisterFailure register_failure; 545 SalOnVfuRequest vfu_request; 546 SalOnDtmfReceived dtmf_received; 547 SalOnRefer refer_received; 548 SalOnMessageReceived message_received; 549 SalOnMessageDeliveryUpdate message_delivery_update; 550 SalOnNotifyRefer notify_refer; 551 SalOnSubscribeReceived subscribe_received; 552 SalOnIncomingSubscribeClosed incoming_subscribe_closed; 553 SalOnSubscribeResponse subscribe_response; 554 SalOnNotify notify; 555 SalOnSubscribePresenceReceived subscribe_presence_received; 556 SalOnSubscribePresenceClosed subscribe_presence_closed; 557 SalOnParsePresenceRequested parse_presence_requested; 558 SalOnConvertPresenceToXMLRequested convert_presence_to_xml_requested; 559 SalOnNotifyPresence notify_presence; 560 SalOnPingReply ping_reply; 561 SalOnAuthRequested auth_requested; 562 SalOnInfoReceived info_received; 563 SalOnPublishResponse on_publish_response; 564 SalOnExpire on_expire; 565 SalOnNotifyResponse on_notify_response; 566 }SalCallbacks; 567 568 569 570 SalAuthInfo* sal_auth_info_new(void); 571 SalAuthInfo* sal_auth_info_clone(const SalAuthInfo* auth_info); 572 void sal_auth_info_delete(SalAuthInfo* auth_info); 573 LINPHONE_PUBLIC int sal_auth_compute_ha1(const char* userid,const char* realm,const char* password, char ha1[33]); 574 SalAuthMode sal_auth_info_get_mode(const SalAuthInfo* auth_info); 575 SalSigningKey *sal_auth_info_get_signing_key(const SalAuthInfo* auth_info); 576 SalCertificatesChain *sal_auth_info_get_certificates_chain(const SalAuthInfo* auth_info); 577 void sal_auth_info_set_mode(SalAuthInfo* auth_info, SalAuthMode mode); 578 579 /** Parse a file containing either a certificate chain order in PEM format or a single DER cert 580 * @param auth_info structure where to store the result of parsing 581 * @param path path to certificate chain file 582 * @param format either PEM or DER 583 */ 584 void sal_certificates_chain_parse_file(SalAuthInfo* auth_info, const char* path, SalCertificateRawFormat format); 585 586 /** 587 * Parse a file containing either a private or public rsa key 588 * @param auth_info structure where to store the result of parsing 589 * @param passwd password (optionnal) 590 */ 591 void sal_signing_key_parse_file(SalAuthInfo* auth_info, const char* path, const char *passwd); 592 593 /** Parse a buffer containing either a certificate chain order in PEM format or a single DER cert 594 * @param auth_info structure where to store the result of parsing 595 * @param buffer the buffer to parse 596 * @param format either PEM or DER 597 */ 598 void sal_certificates_chain_parse(SalAuthInfo* auth_info, const char* buffer, SalCertificateRawFormat format); 599 600 /** 601 * Parse a buffer containing either a private or public rsa key 602 * @param auth_info structure where to store the result of parsing 603 * @param passwd password (optionnal) 604 */ 605 void sal_signing_key_parse(SalAuthInfo* auth_info, const char* buffer, const char *passwd); 606 607 /** 608 * Parse a directory for files containing certificate with the given subject CNAME 609 * @param[out] certificate_pem the address of a string to store the certificate in PEM format. To be freed by caller 610 * @param[out] key_pem the address of a string to store the key in PEM format. To be freed by caller 611 * @param[in] path directory to parse 612 * @param[in] subject subject CNAME 613 * @param[in] format either PEM or DER 614 * @param[in] generate_certificate if true, if matching certificate and key can't be found, generate it and store it into the given dir, filename will be subject.pem 615 * @param[in] generate_dtls_fingerprint if true and we have a certificate, generate the dtls fingerprint as described in rfc4572 616 */ 617 void sal_certificates_chain_parse_directory(char **certificate_pem, char **key_pem, char **fingerprint, const char* path, const char *subject, SalCertificateRawFormat format, bool_t generate_certificate, bool_t generate_dtls_fingerprint); 618 619 void sal_certificates_chain_delete(SalCertificatesChain *chain); 620 void sal_signing_key_delete(SalSigningKey *key); 621 622 623 624 void sal_set_callbacks(Sal *ctx, const SalCallbacks *cbs); 625 int sal_listen_port(Sal *ctx, const char *addr, int port, SalTransport tr, int is_tunneled); 626 int sal_get_listening_port(Sal *ctx, SalTransport tr); 627 int sal_unlisten_ports(Sal *ctx); 628 LINPHONE_PUBLIC int sal_transport_available(Sal *ctx, SalTransport t); 629 LINPHONE_PUBLIC bool_t sal_content_encoding_available(Sal *ctx, const char *content_encoding); 630 void sal_set_dscp(Sal *ctx, int dscp); 631 void sal_set_supported_tags(Sal *ctx, const char* tags); 632 void sal_add_supported_tag(Sal *ctx, const char* tag); 633 void sal_remove_supported_tag(Sal *ctx, const char* tag); 634 const char *sal_get_supported_tags(Sal *ctx); 635 int sal_reset_transports(Sal *ctx); 636 ortp_socket_t sal_get_socket(Sal *ctx); 637 void sal_set_user_agent(Sal *ctx, const char *user_agent); 638 const char* sal_get_user_agent(Sal *ctx); 639 void sal_append_stack_string_to_user_agent(Sal *ctx); 640 /*keepalive period in ms*/ 641 void sal_set_keepalive_period(Sal *ctx,unsigned int value); 642 void sal_use_tcp_tls_keepalive(Sal *ctx, bool_t enabled); 643 int sal_set_tunnel(Sal *ctx, void *tunnelclient); 644 /*Default value is true*/ 645 void sal_enable_sip_update_method(Sal *ctx,bool_t value); 646 bool_t sal_is_content_type_supported(const Sal *sal, const char *content_type); 647 void sal_add_content_type_support(Sal *sal, const char *content_type); 648 649 /** 650 * returns keepalive period in ms 651 * 0 desactiaved 652 * */ 653 unsigned int sal_get_keepalive_period(Sal *ctx); 654 void sal_use_session_timers(Sal *ctx, int expires); 655 void sal_use_dates(Sal *ctx, bool_t enabled); 656 void sal_use_one_matching_codec_policy(Sal *ctx, bool_t one_matching_codec); 657 void sal_use_rport(Sal *ctx, bool_t use_rports); 658 void sal_enable_auto_contacts(Sal *ctx, bool_t enabled); 659 void sal_set_root_ca(Sal* ctx, const char* rootCa); 660 void sal_set_root_ca_data(Sal* ctx, const char* data); 661 const char *sal_get_root_ca(Sal* ctx); 662 void sal_verify_server_certificates(Sal *ctx, bool_t verify); 663 void sal_verify_server_cn(Sal *ctx, bool_t verify); 664 void sal_set_ssl_config(Sal *ctx, void *ssl_config); 665 LINPHONE_PUBLIC void sal_set_uuid(Sal*ctx, const char *uuid); 666 int sal_create_uuid(Sal*ctx, char *uuid, size_t len); 667 int sal_generate_uuid(char *uuid, size_t len); 668 LINPHONE_PUBLIC void sal_enable_test_features(Sal*ctx, bool_t enabled); 669 void sal_use_no_initial_route(Sal *ctx, bool_t enabled); 670 671 int sal_iterate(Sal *sal); 672 MSList * sal_get_pending_auths(Sal *sal); 673 674 /*create an operation */ 675 SalOp * sal_op_new(Sal *sal); 676 677 /*generic SalOp API, working for all operations */ 678 Sal *sal_op_get_sal(const SalOp *op); 679 void sal_op_set_contact_address(SalOp *op, const SalAddress* address); 680 void sal_op_set_route(SalOp *op, const char *route); 681 void sal_op_set_route_address(SalOp *op, const SalAddress* address); 682 void sal_op_add_route_address(SalOp *op, const SalAddress* address); 683 void sal_op_set_realm(SalOp *op, const char *realm); 684 void sal_op_set_from(SalOp *op, const char *from); 685 void sal_op_set_from_address(SalOp *op, const SalAddress *from); 686 void sal_op_set_to(SalOp *op, const char *to); 687 void sal_op_set_to_address(SalOp *op, const SalAddress *to); 688 void sal_op_set_diversion_address(SalOp *op, const SalAddress *diversion); 689 SalOp *sal_op_ref(SalOp* h); 690 void sal_op_stop_refreshing(SalOp *op); 691 int sal_op_refresh(SalOp *op); 692 693 void sal_op_kill_dialog(SalOp *op); 694 void sal_op_release(SalOp *h); 695 /*same as release, but does not stop refresher if any*/ 696 void* sal_op_unref(SalOp* op); 697 698 void sal_op_authenticate(SalOp *h, const SalAuthInfo *info); 699 void sal_op_cancel_authentication(SalOp *h); 700 void sal_op_set_user_pointer(SalOp *h, void *up); 701 SalAuthInfo * sal_op_get_auth_requested(SalOp *h); 702 const char *sal_op_get_from(const SalOp *op); 703 const SalAddress *sal_op_get_from_address(const SalOp *op); 704 const char *sal_op_get_to(const SalOp *op); 705 const SalAddress *sal_op_get_to_address(const SalOp *op); 706 const SalAddress *sal_op_get_diversion_address(const SalOp *op); 707 const SalAddress *sal_op_get_contact_address(const SalOp *op); 708 const MSList* sal_op_get_route_addresses(const SalOp *op); 709 const char *sal_op_get_proxy(const SalOp *op); 710 /*raw contact header value with header params*/ 711 const char *sal_op_get_remote_contact(const SalOp *op); 712 /*contact header address only (I.E without header params*/ 713 const SalAddress* sal_op_get_remote_contact_address(const SalOp *op); 714 /*for incoming requests, returns the origin of the packet as a sip uri*/ 715 const char *sal_op_get_network_origin(const SalOp *op); 716 const SalAddress *sal_op_get_network_origin_address(const SalOp *op); 717 /*returns far-end "User-Agent" string */ 718 const char *sal_op_get_remote_ua(const SalOp *op); 719 void *sal_op_get_user_pointer(const SalOp *op); 720 const char* sal_op_get_call_id(const SalOp *op); 721 char* sal_op_get_dialog_id(const SalOp *op); 722 bool_t sal_op_is_forked_of(const SalOp *op1, const SalOp *op2); 723 724 const SalAddress* sal_op_get_service_route(const SalOp *op); 725 void sal_op_set_service_route(SalOp *op,const SalAddress* service_route); 726 727 void sal_op_set_manual_refresher_mode(SalOp *op, bool_t enabled); 728 int sal_op_get_address_family(SalOp *op); 729 /*returns TRUE if there is no pending request that may block a future one */ 730 bool_t sal_op_is_idle(SalOp *op); 731 732 const SalErrorInfo *sal_error_info_none(void); 733 LINPHONE_PUBLIC const SalErrorInfo *sal_op_get_error_info(const SalOp *op); 734 const SalErrorInfo *sal_op_get_reason_error_info(const SalOp *op); 735 void sal_error_info_reset(SalErrorInfo *ei); 736 void sal_error_info_init_to_null(SalErrorInfo *sei); 737 void sal_error_info_set(SalErrorInfo *ei, SalReason reason, const char *protocol, int code, const char *status_string, const char *warning); 738 739 /*entity tag used for publish (see RFC 3903)*/ 740 const char *sal_op_get_entity_tag(const SalOp* op); 741 void sal_op_set_entity_tag(SalOp *op, const char* entity_tag); 742 /*set the event header, for used with out of dialog SIP notify*/ 743 void sal_op_set_event(SalOp *op, const char *event); 744 745 /*Call API*/ 746 int sal_call_set_local_media_description(SalOp *h, SalMediaDescription *desc); 747 int sal_call(SalOp *h, const char *from, const char *to); 748 int sal_call_notify_ringing(SalOp *h, bool_t early_media); 749 /*accept an incoming call or, during a call accept a reINVITE*/ 750 int sal_call_accept(SalOp*h); 751 int sal_call_decline(SalOp *h, SalReason reason, const char *redirection /*optional*/); 752 int sal_call_decline_with_error_info(SalOp *h, const SalErrorInfo* info, const char *redirection /*optional*/); 753 int sal_call_update(SalOp *h, const char *subject, bool_t no_user_consent); 754 void sal_call_cancel_invite(SalOp *op); 755 void sal_call_cancel_invite_with_info(SalOp* op, const SalErrorInfo *info); 756 SalMediaDescription * sal_call_get_remote_media_description(SalOp *h); 757 LINPHONE_PUBLIC SalMediaDescription * sal_call_get_final_media_description(SalOp *h); 758 int sal_call_refer(SalOp *h, const char *refer_to); 759 int sal_call_refer_with_replaces(SalOp *h, SalOp *other_call_h); 760 int sal_call_accept_refer(SalOp *h); 761 /*informs this call is consecutive to an incoming refer */ 762 int sal_call_set_referer(SalOp *h, SalOp *refered_call); 763 /* returns the SalOp of a call that should be replaced by h, if any */ 764 SalOp *sal_call_get_replaces(SalOp *h); 765 int sal_call_send_dtmf(SalOp *h, char dtmf); 766 int sal_call_terminate(SalOp *h); 767 int sal_call_terminate_with_error(SalOp *op, const SalErrorInfo *info); 768 bool_t sal_call_autoanswer_asked(SalOp *op); 769 void sal_call_send_vfu_request(SalOp *h); 770 int sal_call_is_offerer(const SalOp *h); 771 int sal_call_notify_refer_state(SalOp *h, SalOp *newcall); 772 bool_t sal_call_compare_op(const SalOp *op1, const SalOp *op2); 773 LINPHONE_PUBLIC bool_t sal_call_dialog_request_pending(const SalOp *op); 774 const char * sal_call_get_local_tag(SalOp *op); 775 const char * sal_call_get_remote_tag(SalOp *op); 776 void sal_call_set_replaces(SalOp *op, const char *call_id, const char *from_tag, const char *to_tag); 777 /* Call test API */ 778 779 780 /** 781 * @brief Invoking this on the SAL will modify every subsequent SalOp to have a special handling for SDP. 782 * @details This is especially useful while testing, to simulate some specific behaviors, like missing SDP or an error in parsing. 783 * 784 * @warning Don't forget to reset the handling method to SalOpSDPNormal afterwards. 785 * 786 * @param h the Sal instance 787 * @param handling_method Could be SalOpSDPNormal, SalOpSDPSimulateError, SalOpSDPSimulateRemoval (\ref SalOpSDPHandling) 788 */ 789 LINPHONE_PUBLIC void sal_default_set_sdp_handling(Sal* h, SalOpSDPHandling handling_method) ; 790 /* Second version: for a specific call*/ 791 LINPHONE_PUBLIC void sal_call_set_sdp_handling(SalOp *h, SalOpSDPHandling handling) ; 792 793 /*Registration*/ 794 int sal_register(SalOp *op, const char *proxy, const char *from, int expires,SalAddress* old_contact); 795 /*refresh a register, -1 mean use the last known value*/ 796 int sal_register_refresh(SalOp *op, int expires); 797 int sal_unregister(SalOp *h); 798 799 /*Messaging */ 800 int sal_text_send(SalOp *op, const char *from, const char *to, const char *text); 801 int sal_message_send(SalOp *op, const char *from, const char *to, const char* content_type, const char *msg, const char *peer_uri); 802 int sal_message_reply(SalOp *op, SalReason reason); 803 804 /*presence Subscribe/notify*/ 805 int sal_subscribe_presence(SalOp *op, const char *from, const char *to, int expires); 806 int sal_notify_presence(SalOp *op, SalPresenceModel *presence); 807 int sal_notify_presence_close(SalOp *op); 808 809 /*presence publish */ 810 //int sal_publish_presence(SalOp *op, const char *from, const char *to, int expires, SalPresenceModel *presence); 811 SalBodyHandler *sal_presence_model_create_body_handler(SalPresenceModel *presence); 812 813 814 /*ping: main purpose is to obtain its own contact address behind firewalls*/ 815 int sal_ping(SalOp *op, const char *from, const char *to); 816 817 /*info messages*/ 818 int sal_send_info(SalOp *op, const char *from, const char *to, const SalBodyHandler *body); 819 820 /*generic subscribe/notify/publish api*/ 821 int sal_subscribe(SalOp *op, const char *from, const char *to, const char *eventname, int expires, const SalBodyHandler *body); 822 int sal_unsubscribe(SalOp *op); 823 int sal_subscribe_accept(SalOp *op); 824 int sal_subscribe_decline(SalOp *op, SalReason reason); 825 int sal_notify_pending_state(SalOp *op); 826 int sal_notify(SalOp *op, const SalBodyHandler *body); 827 int sal_notify_close(SalOp *op); 828 int sal_publish(SalOp *op, const char *from, const char *to, const char*event_name, int expires, const SalBodyHandler *body); 829 int sal_op_unpublish(SalOp *op); 830 831 /*privacy, must be in sync with LinphonePrivacyMask*/ 832 typedef enum _SalPrivacy { 833 SalPrivacyNone=0x0, 834 SalPrivacyUser=0x1, 835 SalPrivacyHeader=0x2, 836 SalPrivacySession=0x4, 837 SalPrivacyId=0x8, 838 SalPrivacyCritical=0x10, 839 SalPrivacyDefault=0x8000 840 } SalPrivacy; 841 typedef unsigned int SalPrivacyMask; 842 843 const char* sal_privacy_to_string(SalPrivacy privacy); 844 void sal_op_set_privacy(SalOp* op,SalPrivacy privacy); 845 SalPrivacy sal_op_get_privacy(const SalOp* op); 846 847 848 849 #define payload_type_set_number(pt,n) (pt)->user_data=(void*)((intptr_t)n); 850 #define payload_type_get_number(pt) ((int)(intptr_t)(pt)->user_data) 851 852 /*misc*/ 853 void sal_get_default_local_ip(Sal *sal, int address_family, char *ip, size_t iplen); 854 855 856 LINPHONE_PUBLIC belle_sip_resolver_context_t * sal_resolve_a(Sal* sal, const char *name, int port, int family, belle_sip_resolver_callback_t cb, void *data); 857 LINPHONE_PUBLIC belle_sip_resolver_context_t * sal_resolve(Sal *sal, const char *service, const char *transport, const char *name, int port, int family, belle_sip_resolver_callback_t cb, void *data); 858 859 SalCustomHeader *sal_custom_header_ref(SalCustomHeader *ch); 860 void sal_custom_header_unref(SalCustomHeader *ch); 861 SalCustomHeader *sal_custom_header_append(SalCustomHeader *ch, const char *name, const char *value); 862 const char *sal_custom_header_find(const SalCustomHeader *ch, const char *name); 863 SalCustomHeader *sal_custom_header_remove(SalCustomHeader *ch, const char *name); 864 void sal_custom_header_free(SalCustomHeader *ch); 865 SalCustomHeader *sal_custom_header_clone(const SalCustomHeader *ch); 866 867 const SalCustomHeader *sal_op_get_recv_custom_header(SalOp *op); 868 869 void sal_op_set_sent_custom_header(SalOp *op, SalCustomHeader* ch); 870 871 872 SalCustomSdpAttribute * sal_custom_sdp_attribute_append(SalCustomSdpAttribute *csa, const char *name, const char *value); 873 const char * sal_custom_sdp_attribute_find(const SalCustomSdpAttribute *csa, const char *name); 874 void sal_custom_sdp_attribute_free(SalCustomSdpAttribute *csa); 875 SalCustomSdpAttribute * sal_custom_sdp_attribute_clone(const SalCustomSdpAttribute *csa); 876 877 /** deprecated. use sal_set_log_level instead **/ 878 void sal_enable_log(void); 879 /** deprecated. use sal_set_log_level instead **/ 880 void sal_disable_log(void); 881 void sal_set_log_level(OrtpLogLevel level); 882 883 /*internal API */ 884 void __sal_op_init(SalOp *b, Sal *sal); 885 void __sal_op_set_network_origin(SalOp *op, const char *origin /*a sip uri*/); 886 void __sal_op_set_network_origin_address(SalOp *op, SalAddress *origin); 887 void __sal_op_set_remote_contact(SalOp *op, const char *ct); 888 void __sal_op_free(SalOp *b); 889 890 /*test api*/ 891 /*0 for no error*/ 892 LINPHONE_PUBLIC void sal_set_send_error(Sal *sal,int value); 893 /*1 for no error*/ 894 LINPHONE_PUBLIC void sal_set_recv_error(Sal *sal,int value); 895 896 /*always answer 480 if value=true*/ 897 LINPHONE_PUBLIC void sal_enable_unconditional_answer(Sal *sal,int value); 898 899 LINPHONE_PUBLIC bool_t sal_pending_trans_checking_enabled(const Sal *sal) ; 900 LINPHONE_PUBLIC int sal_enable_pending_trans_checking(Sal *sal, bool_t value) ; 901 902 903 904 /*refresher retry after value in ms*/ 905 LINPHONE_PUBLIC void sal_set_refresher_retry_after(Sal *sal,int value); 906 LINPHONE_PUBLIC int sal_get_refresher_retry_after(const Sal *sal); 907 /*enable contact fixing*/ 908 void sal_nat_helper_enable(Sal *sal,bool_t enable); 909 bool_t sal_nat_helper_enabled(Sal *sal); 910 911 LINPHONE_PUBLIC void sal_set_dns_timeout(Sal* sal,int timeout); 912 LINPHONE_PUBLIC int sal_get_dns_timeout(const Sal* sal); 913 LINPHONE_PUBLIC void sal_set_transport_timeout(Sal* sal,int timeout); 914 LINPHONE_PUBLIC int sal_get_transport_timeout(const Sal* sal); 915 void sal_set_dns_servers(Sal *sal, const MSList *servers); 916 LINPHONE_PUBLIC void sal_enable_dns_srv(Sal *sal, bool_t enable); 917 LINPHONE_PUBLIC bool_t sal_dns_srv_enabled(const Sal *sal); 918 LINPHONE_PUBLIC void sal_enable_dns_search(Sal *sal, bool_t enable); 919 LINPHONE_PUBLIC bool_t sal_dns_search_enabled(const Sal *sal); 920 LINPHONE_PUBLIC void sal_set_dns_user_hosts_file(Sal *sal, const char *hosts_file); 921 LINPHONE_PUBLIC const char *sal_get_dns_user_hosts_file(const Sal *sal); 922 unsigned int sal_get_random(void); 923 LINPHONE_PUBLIC char *sal_get_random_token(int size); 924 unsigned char * sal_get_random_bytes(unsigned char *ret, size_t size); 925 belle_sip_source_t * sal_create_timer(Sal *sal, belle_sip_source_func_t func, void *data, unsigned int timeout_value_ms, const char* timer_name); 926 void sal_cancel_timer(Sal *sal, belle_sip_source_t *timer); 927 928 //SalBodyHandler * sal_body_handler_new(const char *type, const char *subtype, void *data, size_t size, const char *encoding); 929 SalBodyHandler * sal_body_handler_new(void); 930 SalBodyHandler * sal_body_handler_ref(SalBodyHandler *body_handler); 931 void sal_body_handler_unref(SalBodyHandler *body_handler); 932 const char * sal_body_handler_get_type(const SalBodyHandler *body_handler); 933 void sal_body_handler_set_type(SalBodyHandler *body_handler, const char *type); 934 const char * sal_body_handler_get_subtype(const SalBodyHandler *body_handler); 935 void sal_body_handler_set_subtype(SalBodyHandler *body_handler, const char *subtype); 936 const char * sal_body_handler_get_encoding(const SalBodyHandler *body_handler); 937 void sal_body_handler_set_encoding(SalBodyHandler *body_handler, const char *encoding); 938 void * sal_body_handler_get_data(const SalBodyHandler *body_handler); 939 void sal_body_handler_set_data(SalBodyHandler *body_handler, void *data); 940 size_t sal_body_handler_get_size(const SalBodyHandler *body_handler); 941 void sal_body_handler_set_size(SalBodyHandler *body_handler, size_t size); 942 bool_t sal_body_handler_is_multipart(const SalBodyHandler *body_handler); 943 SalBodyHandler * sal_body_handler_get_part(const SalBodyHandler *body_handler, int idx); 944 SalBodyHandler * sal_body_handler_find_part_by_header(const SalBodyHandler *body_handler, const char *header_name, const char *header_value); 945 const char * sal_body_handler_get_header(const SalBodyHandler *body_handler, const char *header_name); 946 947 /*this function parses a document with key=value pairs separated by new lines, and extracts the value for a given key*/ 948 int sal_lines_get_value(const char *data, const char *key, char *value, size_t value_size); 949 950 LINPHONE_PUBLIC void *sal_get_stack_impl(Sal *sal); 951 const char* sal_op_get_public_address(SalOp *sal, int *port); 952 const char* sal_op_get_local_address(SalOp *sal, int *port); 953 954 unsigned long sal_begin_background_task(const char *name, void (*max_time_reached)(void *), void *data); 955 void sal_end_background_task(unsigned long id); 956 957 /*Some old equipment may not only rely on attribute sendonly/recvonly/sendrecv/inative*/ 958 void sal_op_cnx_ip_to_0000_if_sendonly_enable(SalOp *sal,bool_t yesno); 959 bool_t sal_op_cnx_ip_to_0000_if_sendonly_enabled(SalOp *sal); 960 961 void sal_set_http_proxy_host(Sal *sal, const char *host) ; 962 void sal_set_http_proxy_port(Sal *sal, int port) ; 963 const char *sal_get_http_proxy_host(const Sal *sal); 964 int sal_get_http_proxy_port(const Sal *sal); 965 966 #ifdef __cplusplus 967 } 968 #endif 969 970 #endif 971 972 973