sal.h 29.2 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
/*
linphone
Copyright (C) 2010  Simon MORLAT (simon.morlat@free.fr)

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

20
/**
21
 This header files defines the Signaling Abstraction Layer.
22
 The purpose of this layer is too allow experiment different call signaling
23 24 25 26 27 28
 protocols and implementations under linphone, for example SIP, JINGLE...
**/

#ifndef sal_h
#define sal_h

29 30 31 32
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

jehan's avatar
jehan committed
33
#include "mediastreamer2/mediastream.h"
34
#include "ortp/rtpsession.h"
35
#include "belle-sip/belle-sip.h"
36

jehan's avatar
jehan committed
37 38
#ifndef LINPHONE_PUBLIC
	#define LINPHONE_PUBLIC MS2_PUBLIC
39 40
#endif

Simon Morlat's avatar
Simon Morlat committed
41 42 43 44 45
/*Dirty hack, keep in sync with mediastreamer2/include/mediastream.h */
#ifndef PAYLOAD_TYPE_FLAG_CAN_RECV
#define PAYLOAD_TYPE_FLAG_CAN_RECV	PAYLOAD_TYPE_USER_FLAG_1
#define PAYLOAD_TYPE_FLAG_CAN_SEND	PAYLOAD_TYPE_USER_FLAG_2
#endif
46 47 48 49 50 51 52 53
struct Sal;

typedef struct Sal Sal;

struct SalOp;

typedef struct SalOp SalOp;

54 55 56 57
struct SalAddress;

typedef struct SalAddress SalAddress;

58 59 60 61
struct SalCustomHeader;

typedef struct SalCustomHeader SalCustomHeader;

62 63
struct addrinfo;

64 65 66 67
typedef enum {
	SalTransportUDP, /*UDP*/
	SalTransportTCP, /*TCP*/
	SalTransportTLS, /*TLS*/
68
	SalTransportDTLS, /*DTLS*/
69 70
}SalTransport;

71 72 73 74 75 76 77
#define SAL_MEDIA_DESCRIPTION_UNCHANGED			0x00
#define SAL_MEDIA_DESCRIPTION_NETWORK_CHANGED		(1)
#define SAL_MEDIA_DESCRIPTION_CODEC_CHANGED		(1<<1)
#define SAL_MEDIA_DESCRIPTION_CRYPTO_KEYS_CHANGED	(1<<2)
#define SAL_MEDIA_DESCRIPTION_CRYPTO_POLICY_CHANGED	(1<<3)
#define SAL_MEDIA_DESCRIPTION_STREAMS_CHANGED		(1<<4)

78
#define SAL_MEDIA_DESCRIPTION_CHANGED		(SAL_MEDIA_DESCRIPTION_NETWORK_CHANGED | SAL_MEDIA_DESCRIPTION_CODEC_CHANGED |\
79
						SAL_MEDIA_DESCRIPTION_CRYPTO_KEYS_CHANGED |SAL_MEDIA_DESCRIPTION_CRYPTO_POLICY_CHANGED | SAL_MEDIA_DESCRIPTION_STREAMS_CHANGED)
80

81 82
const char* sal_transport_to_string(SalTransport transport);
SalTransport sal_transport_parse(const char*);
83 84 85
/* Address manipulation API*/
SalAddress * sal_address_new(const char *uri);
SalAddress * sal_address_clone(const SalAddress *addr);
86 87
SalAddress * sal_address_ref(SalAddress *addr);
void sal_address_unref(SalAddress *addr);
88 89
const char *sal_address_get_scheme(const SalAddress *addr);
const char *sal_address_get_display_name(const SalAddress* addr);
jehan's avatar
jehan committed
90
const char *sal_address_get_display_name_unquoted(const SalAddress *addr);
91 92
const char *sal_address_get_username(const SalAddress *addr);
const char *sal_address_get_domain(const SalAddress *addr);
93
int sal_address_get_port(const SalAddress *addr);
94 95
bool_t sal_address_is_secure(const SalAddress *addr);

96
SalTransport sal_address_get_transport(const SalAddress* addr);
97
const char* sal_address_get_transport_name(const SalAddress* addr);
jehan's avatar
jehan committed
98

99 100 101
void sal_address_set_display_name(SalAddress *addr, const char *display_name);
void sal_address_set_username(SalAddress *addr, const char *username);
void sal_address_set_domain(SalAddress *addr, const char *host);
102
void sal_address_set_port(SalAddress *uri, int port);
103 104 105 106
void sal_address_clean(SalAddress *addr);
char *sal_address_as_string(const SalAddress *u);
char *sal_address_as_string_uri_only(const SalAddress *u);
void sal_address_destroy(SalAddress *u);
107 108
void sal_address_set_param(SalAddress *u,const char* name,const char* value);
void sal_address_set_transport(SalAddress* addr,SalTransport transport);
109
void sal_address_set_transport_name(SalAddress* addr,const char* transport);
110 111
void sal_address_set_params(SalAddress *addr, const char *params);
void sal_address_set_uri_params(SalAddress *addr, const char *params);
112
bool_t sal_address_is_ipv6(const SalAddress *addr);
113
bool_t sal_address_is_sip(const SalAddress *addr);
114 115 116
void sal_address_set_password(SalAddress *addr, const char *passwd);
const char *sal_address_get_password(const SalAddress *addr);
void sal_address_set_header(SalAddress *addr, const char *header_name, const char *header_value);
Simon Morlat's avatar
Simon Morlat committed
117

118 119
Sal * sal_init();
void sal_uninit(Sal* sal);
Simon Morlat's avatar
Simon Morlat committed
120 121
void sal_set_user_pointer(Sal *sal, void *user_data);
void *sal_get_user_pointer(const Sal *sal);
122 123 124


typedef enum {
125 126 127
	SalAudio,
	SalVideo,
	SalOther
128
} SalStreamType;
jehan's avatar
jehan committed
129
const char* sal_stream_type_to_string(SalStreamType type);
130

Simon Morlat's avatar
Simon Morlat committed
131
typedef enum{
132
	SalProtoRtpAvp,
133
	SalProtoRtpSavp,
134 135
	SalProtoRtpAvpf,
	SalProtoRtpSavpf,
136
	SalProtoOther
Simon Morlat's avatar
Simon Morlat committed
137
}SalMediaProto;
jehan's avatar
jehan committed
138
const char* sal_media_proto_to_string(SalMediaProto type);
Simon Morlat's avatar
Simon Morlat committed
139

Simon Morlat's avatar
Simon Morlat committed
140 141 142 143 144 145
typedef enum{
	SalStreamSendRecv,
	SalStreamSendOnly,
	SalStreamRecvOnly,
	SalStreamInactive
}SalStreamDir;
jehan's avatar
jehan committed
146
const char* sal_stream_dir_to_string(SalStreamDir type);
Simon Morlat's avatar
Simon Morlat committed
147

jehan's avatar
jehan committed
148

149 150
#define SAL_ENDPOINT_CANDIDATE_MAX 2

151 152 153 154 155 156 157 158 159 160 161
#define SAL_MEDIA_DESCRIPTION_MAX_ICE_ADDR_LEN 64
#define SAL_MEDIA_DESCRIPTION_MAX_ICE_FOUNDATION_LEN 32
#define SAL_MEDIA_DESCRIPTION_MAX_ICE_TYPE_LEN 6

typedef struct SalIceCandidate {
	char addr[SAL_MEDIA_DESCRIPTION_MAX_ICE_ADDR_LEN];
	char raddr[SAL_MEDIA_DESCRIPTION_MAX_ICE_ADDR_LEN];
	char foundation[SAL_MEDIA_DESCRIPTION_MAX_ICE_FOUNDATION_LEN];
	char type[SAL_MEDIA_DESCRIPTION_MAX_ICE_TYPE_LEN];
	unsigned int componentID;
	unsigned int priority;
162
	int port;
163 164
	int rport;
} SalIceCandidate;
165

166 167 168 169 170 171 172 173
#define SAL_MEDIA_DESCRIPTION_MAX_ICE_CANDIDATES 10

typedef struct SalIceRemoteCandidate {
	char addr[SAL_MEDIA_DESCRIPTION_MAX_ICE_ADDR_LEN];
	int port;
} SalIceRemoteCandidate;

#define SAL_MEDIA_DESCRIPTION_MAX_ICE_REMOTE_CANDIDATES 2
174

175 176
#define SAL_MEDIA_DESCRIPTION_MAX_ICE_UFRAG_LEN 256
#define SAL_MEDIA_DESCRIPTION_MAX_ICE_PWD_LEN 256
177

178
/*sufficient for 256bit keys encoded in base 64*/
179
#define SAL_SRTP_KEY_SIZE 128
180

181 182
typedef struct SalSrtpCryptoAlgo {
	unsigned int tag;
jehan's avatar
jehan committed
183
	MSCryptoSuite algo;
184
	char master_key[SAL_SRTP_KEY_SIZE];
185 186 187 188
} SalSrtpCryptoAlgo;

#define SAL_CRYPTO_ALGO_MAX 4

189
typedef struct SalStreamDescription{
190
	char name[16]; /*unique name of stream, in order to ease offer/answer model algorithm*/
Simon Morlat's avatar
Simon Morlat committed
191
	SalMediaProto proto;
192
	SalStreamType type;
193
	char typeother[32];
194
	char proto_other[32];
195 196 197 198
	char rtp_addr[64];
	char rtcp_addr[64];
	int rtp_port;
	int rtcp_port;
199 200
	MSList *payloads; /*<list of PayloadType */
	MSList *already_assigned_payloads; /*<list of PayloadType offered in the past, used for correct allocation of payload type numbers*/
201 202
	int bandwidth;
	int ptime;
Simon Morlat's avatar
Simon Morlat committed
203
	SalStreamDir dir;
204
	SalSrtpCryptoAlgo crypto[SAL_CRYPTO_ALGO_MAX];
205
	unsigned int crypto_local_tag;
206
	int max_rate;
207
	OrtpRtcpXrConfiguration rtcp_xr;
208 209 210 211 212
	SalIceCandidate ice_candidates[SAL_MEDIA_DESCRIPTION_MAX_ICE_CANDIDATES];
	SalIceRemoteCandidate ice_remote_candidates[SAL_MEDIA_DESCRIPTION_MAX_ICE_REMOTE_CANDIDATES];
	char ice_ufrag[SAL_MEDIA_DESCRIPTION_MAX_ICE_UFRAG_LEN];
	char ice_pwd[SAL_MEDIA_DESCRIPTION_MAX_ICE_PWD_LEN];
	bool_t ice_mismatch;
213
	bool_t ice_completed;
214
	bool_t pad[2];
215 216
} SalStreamDescription;

217 218 219 220
const char *sal_stream_description_get_type_as_string(const SalStreamDescription *desc);
const char *sal_stream_description_get_proto_as_string(const SalStreamDescription *desc);

#define SAL_MEDIA_DESCRIPTION_MAX_STREAMS 8
Simon Morlat's avatar
Simon Morlat committed
221

222
typedef struct SalMediaDescription{
223
	int refcount;
224
	char name[64];
225 226
	char addr[64];
	char username[64];
227
	int nb_streams;
228
	int bandwidth;
229 230
	unsigned int session_ver;
	unsigned int session_id;
231
	SalStreamDir dir;
Simon Morlat's avatar
Simon Morlat committed
232
	SalStreamDescription streams[SAL_MEDIA_DESCRIPTION_MAX_STREAMS];
233
	OrtpRtcpXrConfiguration rtcp_xr;
234 235 236 237
	char ice_ufrag[SAL_MEDIA_DESCRIPTION_MAX_ICE_UFRAG_LEN];
	char ice_pwd[SAL_MEDIA_DESCRIPTION_MAX_ICE_PWD_LEN];
	bool_t ice_lite;
	bool_t ice_completed;
238
	bool_t pad[2];
239 240
} SalMediaDescription;

241 242 243 244 245
typedef struct SalMessage{
	const char *from;
	const char *text;
	const char *url;
	const char *message_id;
246
	const char *content_type;
247
	time_t time;
248 249
}SalMessage;

250 251 252 253 254
typedef struct SalIsComposing {
	const char *from;
	const char *text;
} SalIsComposing;

255 256
#define SAL_MEDIA_DESCRIPTION_MAX_MESSAGE_ATTRIBUTES 5

Simon Morlat's avatar
Simon Morlat committed
257
SalMediaDescription *sal_media_description_new();
258
SalMediaDescription * sal_media_description_ref(SalMediaDescription *md);
259
void sal_media_description_unref(SalMediaDescription *md);
Simon Morlat's avatar
Simon Morlat committed
260
bool_t sal_media_description_empty(const SalMediaDescription *md);
261
int sal_media_description_equals(const SalMediaDescription *md1, const SalMediaDescription *md2);
Simon Morlat's avatar
Simon Morlat committed
262
bool_t sal_media_description_has_dir(const SalMediaDescription *md, SalStreamDir dir);
263
SalStreamDescription *sal_media_description_find_stream(SalMediaDescription *md,
264
    SalMediaProto proto, SalStreamType type);
265 266 267 268
unsigned int sal_media_description_nb_active_streams_of_type(SalMediaDescription *md, SalStreamType type);
SalStreamDescription * sal_media_description_get_active_stream_of_type(SalMediaDescription *md, SalStreamType type, unsigned int idx);
SalStreamDescription * sal_media_description_find_secure_stream_of_type(SalMediaDescription *md, SalStreamType type);
SalStreamDescription * sal_media_description_find_best_stream(SalMediaDescription *md, SalStreamType type);
Simon Morlat's avatar
Simon Morlat committed
269
void sal_media_description_set_dir(SalMediaDescription *md, SalStreamDir stream_dir);
270 271 272 273 274 275
bool_t sal_stream_description_active(const SalStreamDescription *sd);
bool_t sal_stream_description_has_avpf(const SalStreamDescription *sd);
bool_t sal_stream_description_has_srtp(const SalStreamDescription *sd);
bool_t sal_media_description_has_avpf(const SalMediaDescription *md);
bool_t sal_media_description_has_srtp(const SalMediaDescription *md);
int sal_media_description_get_nb_active_streams(const SalMediaDescription *md);
Simon Morlat's avatar
Simon Morlat committed
276

277

Simon Morlat's avatar
Simon Morlat committed
278 279 280
/*this structure must be at the first byte of the SalOp structure defined by implementors*/
typedef struct SalOpBase{
	Sal *root;
281
	char *route; /*or request-uri for REGISTER*/
282
	MSList* route_addresses; /*list of SalAddress* */
jehan's avatar
jehan committed
283
	SalAddress* contact_address;
Simon Morlat's avatar
Simon Morlat committed
284
	char *from;
jehan's avatar
jehan committed
285
	SalAddress* from_address;
Simon Morlat's avatar
Simon Morlat committed
286
	char *to;
jehan's avatar
jehan committed
287
	SalAddress* to_address;
288
	char *origin;
jehan's avatar
jehan committed
289
	SalAddress* origin_address;
290
	char *remote_ua;
291 292
	SalAddress* remote_contact_address;
	char *remote_contact;
Simon Morlat's avatar
Simon Morlat committed
293 294
	SalMediaDescription *local_media;
	SalMediaDescription *remote_media;
Simon Morlat's avatar
Simon Morlat committed
295
	void *user_pointer;
jehan's avatar
jehan committed
296
	const char* call_id;
297
	char* realm;
jehan's avatar
jehan committed
298
	SalAddress* service_route; /*as defined by rfc3608, might be a list*/
Simon Morlat's avatar
Simon Morlat committed
299 300
	SalCustomHeader *sent_custom_headers;
	SalCustomHeader *recv_custom_headers;
Simon Morlat's avatar
Simon Morlat committed
301 302
} SalOpBase;

303

304
typedef enum SalReason{
305
	SalReasonNone, /*no error, please leave first so that it takes 0 value*/
306 307 308 309
	SalReasonDeclined,
	SalReasonBusy,
	SalReasonRedirect,
	SalReasonTemporarilyUnavailable,
310
	SalReasonRequestTimeout,
311 312
	SalReasonNotFound,
	SalReasonDoNotDisturb,
313
	SalReasonUnsupportedContent,
314
	SalReasonForbidden,
315
	SalReasonUnknown,
316
	SalReasonServiceUnavailable,
jehan's avatar
jehan committed
317
	SalReasonRequestPending,
318
	SalReasonUnauthorized,
319
	SalReasonNotAcceptable,
320 321 322 323 324 325
	SalReasonNoMatch, /*equivalent to 481 Transaction/Call leg does not exist*/
	SalReasonMovedPermanently,
	SalReasonGone,
	SalReasonAddressIncomplete,
	SalReasonNotImplemented,
	SalReasonBadGateway,
326 327
	SalReasonServerTimeout,
	SalReasonIOError
328 329
}SalReason;

jehan's avatar
jehan committed
330 331
const char* sal_reason_to_string(const SalReason reason);

332 333 334 335 336 337 338 339
typedef struct SalErrorInfo{
	SalReason reason;
	char *status_string;
	int protocol_code;
	char *warnings;
	char *full_string; /*concatenation of status_string + warnings*/
}SalErrorInfo;

340 341 342 343 344 345 346 347 348 349 350
typedef enum SalPresenceStatus{
	SalPresenceOffline,
	SalPresenceOnline,
	SalPresenceBusy,
	SalPresenceBerightback,
	SalPresenceAway,
	SalPresenceOnthephone,
	SalPresenceOuttolunch,
	SalPresenceDonotdisturb,
	SalPresenceMoved,
	SalPresenceAltService,
351
	SalPresenceOnVacation
352 353
}SalPresenceStatus;

354 355 356
struct _SalPresenceModel;
typedef struct _SalPresenceModel SalPresenceModel;

jehan's avatar
jehan committed
357 358
const char* sal_presence_status_to_string(const SalPresenceStatus status);

359 360 361 362 363 364 365
typedef enum SalReferStatus{
	SalReferTrying,
	SalReferSuccess,
	SalReferFailed
}SalReferStatus;

typedef enum SalSubscribeStatus{
366 367
	SalSubscribeNone,
	SalSubscribePending,
368 369
	SalSubscribeActive,
	SalSubscribeTerminated
370
}SalSubscribeStatus;
371

372 373 374 375 376
typedef enum SalTextDeliveryStatus{
	SalTextDeliveryInProgress,
	SalTextDeliveryDone,
	SalTextDeliveryFailed
}SalTextDeliveryStatus;
377

378 379 380
/**
 * auth event mode
 * */
jehan's avatar
jehan committed
381
typedef enum SalAuthMode { /*this enum must be same as belle_sip_auth_mode_t*/
382 383 384 385 386 387 388 389 390 391 392 393
	SalAuthModeHttpDigest, /** Digest authentication requested*/
	SalAuthModeTls /** Client certificate requested*/
}SalAuthMode;

struct _SalCertificatesChain;
typedef struct _SalCertificatesChain SalCertificatesChain;
struct _SalSigningKey;
typedef struct _SalSigningKey SalSigningKey;

/**
 * Format of certificate buffer
 * */
jehan's avatar
jehan committed
394
typedef enum SalCertificateRawFormat {/*this enum must be same as belle_sip_certificate_raw_format_t*/
395 396 397 398 399 400
	SAL_CERTIFICATE_RAW_FORMAT_PEM, /** PEM format*/
	SAL_CERTIFICATE_RAW_FORMAT_DER /** ASN.1 raw format*/
}SalCertificateRawFormat;



jehan's avatar
jehan committed
401 402 403 404 405
typedef struct SalAuthInfo{
	char *username;
	char *userid;
	char *password;
	char *realm;
406
	char *domain;
jehan's avatar
jehan committed
407
	char *ha1;
408 409 410
	SalAuthMode mode;
	SalSigningKey *key;
	SalCertificatesChain *certificates;
jehan's avatar
jehan committed
411 412
}SalAuthInfo;

Simon Morlat's avatar
Simon Morlat committed
413 414 415 416 417
typedef struct SalBody{
	const char *type;
	const char *subtype;
	const void *data;
	size_t size;
418
	const char *encoding;
Simon Morlat's avatar
Simon Morlat committed
419 420
}SalBody;

421 422 423
typedef void (*SalOnCallReceived)(SalOp *op);
typedef void (*SalOnCallRinging)(SalOp *op);
typedef void (*SalOnCallAccepted)(SalOp *op);
424
typedef void (*SalOnCallAck)(SalOp *op);
425
typedef void (*SalOnCallUpdating)(SalOp *op, bool_t is_update);/*< Called when a reINVITE/UPDATE is received*/
Simon Morlat's avatar
Simon Morlat committed
426
typedef void (*SalOnCallTerminated)(SalOp *op, const char *from);
427
typedef void (*SalOnCallFailure)(SalOp *op);
428
typedef void (*SalOnCallReleased)(SalOp *salop);
jehan's avatar
jehan committed
429
typedef void (*SalOnAuthRequestedLegacy)(SalOp *op, const char *realm, const char *username);
jehan's avatar
jehan committed
430
typedef bool_t (*SalOnAuthRequested)(Sal *sal,SalAuthInfo* info);
jehan's avatar
jehan committed
431
typedef void (*SalOnAuthFailure)(SalOp *op, SalAuthInfo* info);
432
typedef void (*SalOnRegisterSuccess)(SalOp *op, bool_t registered);
433
typedef void (*SalOnRegisterFailure)(SalOp *op);
434 435 436
typedef void (*SalOnVfuRequest)(SalOp *op);
typedef void (*SalOnDtmfReceived)(SalOp *op, char dtmf);
typedef void (*SalOnRefer)(Sal *sal, SalOp *op, const char *referto);
437
typedef void (*SalOnTextReceived)(SalOp *op, const SalMessage *msg);
438
typedef void (*SalOnTextDeliveryUpdate)(SalOp *op, SalTextDeliveryStatus);
439
typedef void (*SalOnIsComposingReceived)(SalOp *op, const SalIsComposing *is_composing);
440
typedef void (*SalOnNotifyRefer)(SalOp *op, SalReferStatus state);
441
typedef void (*SalOnSubscribeResponse)(SalOp *op, SalSubscribeStatus status);
442 443 444
typedef void (*SalOnNotify)(SalOp *op, SalSubscribeStatus status, const char *event, const SalBody *body);
typedef void (*SalOnSubscribeReceived)(SalOp *salop, const char *event, const SalBody *body);
typedef void (*SalOnSubscribeClosed)(SalOp *salop);
445
typedef void (*SalOnParsePresenceRequested)(SalOp *salop, const char *content_type, const char *content_subtype, const char *content, SalPresenceModel **result);
446
typedef void (*SalOnConvertPresenceToXMLRequested)(SalOp *salop, SalPresenceModel *presence, const char *contact, char **content);
447
typedef void (*SalOnNotifyPresence)(SalOp *op, SalSubscribeStatus ss, SalPresenceModel *model, const char *msg);
448 449
typedef void (*SalOnSubscribePresenceReceived)(SalOp *salop, const char *from);
typedef void (*SalOnSubscribePresenceClosed)(SalOp *salop, const char *from);
450
typedef void (*SalOnPingReply)(SalOp *salop);
Simon Morlat's avatar
Simon Morlat committed
451
typedef void (*SalOnInfoReceived)(SalOp *salop, const SalBody *body);
452
typedef void (*SalOnPublishResponse)(SalOp *salop);
453
typedef void (*SalOnExpire)(SalOp *salop);
jehan's avatar
jehan committed
454 455 456
/*allows sal implementation to access auth info if available, return TRUE if found*/


457

Simon Morlat's avatar
Simon Morlat committed
458 459 460 461
typedef struct SalCallbacks{
	SalOnCallReceived call_received;
	SalOnCallRinging call_ringing;
	SalOnCallAccepted call_accepted;
462
	SalOnCallAck call_ack;
463
	SalOnCallUpdating call_updating;
Simon Morlat's avatar
Simon Morlat committed
464 465
	SalOnCallTerminated call_terminated;
	SalOnCallFailure call_failure;
466
	SalOnCallReleased call_released;
jehan's avatar
jehan committed
467
	SalOnAuthFailure auth_failure;
468 469 470 471 472 473
	SalOnRegisterSuccess register_success;
	SalOnRegisterFailure register_failure;
	SalOnVfuRequest vfu_request;
	SalOnDtmfReceived dtmf_received;
	SalOnRefer refer_received;
	SalOnTextReceived text_received;
474
	SalOnTextDeliveryUpdate text_delivery_update;
475
	SalOnIsComposingReceived is_composing_received;
476
	SalOnNotifyRefer notify_refer;
Simon Morlat's avatar
Simon Morlat committed
477
	SalOnSubscribeReceived subscribe_received;
478
	SalOnSubscribeClosed subscribe_closed;
479 480 481 482
	SalOnSubscribeResponse subscribe_response;
	SalOnNotify notify;
	SalOnSubscribePresenceReceived subscribe_presence_received;
	SalOnSubscribePresenceClosed subscribe_presence_closed;
483
	SalOnParsePresenceRequested parse_presence_requested;
484
	SalOnConvertPresenceToXMLRequested convert_presence_to_xml_requested;
485
	SalOnNotifyPresence notify_presence;
486
	SalOnPingReply ping_reply;
jehan's avatar
jehan committed
487
	SalOnAuthRequested auth_requested;
Simon Morlat's avatar
Simon Morlat committed
488
	SalOnInfoReceived info_received;
489 490
	SalOnPublishResponse on_publish_response;
	SalOnExpire on_expire;
Simon Morlat's avatar
Simon Morlat committed
491 492
}SalCallbacks;

jehan's avatar
jehan committed
493

494

jehan's avatar
jehan committed
495 496
SalAuthInfo* sal_auth_info_new();
SalAuthInfo* sal_auth_info_clone(const SalAuthInfo* auth_info);
497
void sal_auth_info_delete(SalAuthInfo* auth_info);
498
LINPHONE_PUBLIC int sal_auth_compute_ha1(const char* userid,const char* realm,const char* password, char ha1[33]);
499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521
SalAuthMode sal_auth_info_get_mode(const SalAuthInfo* auth_info);
SalSigningKey *sal_auth_info_get_signing_key(const SalAuthInfo* auth_info);
SalCertificatesChain *sal_auth_info_get_certificates_chain(const SalAuthInfo* auth_info);
void sal_auth_info_set_mode(SalAuthInfo* auth_info, SalAuthMode mode);

/** Parse a file containing either a certificate chain order in PEM format or a single DER cert
 * @param auth_info structure where to store the result of parsing
 * @param path path to certificate chain file
 * @param format either PEM or DER
 */
void sal_certificates_chain_parse_file(SalAuthInfo* auth_info, const char* path, SalCertificateRawFormat format);

/**
 * Parse a file containing either a private or public rsa key
 * @param auth_info structure where to store the result of parsing
 * @param passwd password (optionnal)
 */
void sal_signing_key_parse_file(SalAuthInfo* auth_info, const char* path, const char *passwd);

void sal_certificates_chain_delete(SalCertificatesChain *chain);
void sal_signing_key_delete(SalSigningKey *key);


jehan's avatar
jehan committed
522

Simon Morlat's avatar
Simon Morlat committed
523
void sal_set_callbacks(Sal *ctx, const SalCallbacks *cbs);
524
int sal_listen_port(Sal *ctx, const char *addr, int port, SalTransport tr, int is_tunneled);
525
int sal_get_listening_port(Sal *ctx, SalTransport tr);
526
int sal_unlisten_ports(Sal *ctx);
527
int sal_transport_available(Sal *ctx, SalTransport t);
528
void sal_set_dscp(Sal *ctx, int dscp);
529 530 531 532
void sal_set_supported_tags(Sal *ctx, const char* tags);
void sal_add_supported_tag(Sal *ctx, const char* tag);
void sal_remove_supported_tag(Sal *ctx, const char* tag);
const char *sal_get_supported_tags(Sal *ctx);
533
int sal_reset_transports(Sal *ctx);
534
ortp_socket_t sal_get_socket(Sal *ctx);
535
void sal_set_user_agent(Sal *ctx, const char *user_agent);
536
const char* sal_get_user_agent(Sal *ctx);
537
void sal_append_stack_string_to_user_agent(Sal *ctx);
538 539
/*keepalive period in ms*/
void sal_set_keepalive_period(Sal *ctx,unsigned int value);
540
void sal_use_tcp_tls_keepalive(Sal *ctx, bool_t enabled);
541
int sal_set_tunnel(Sal *ctx, void *tunnelclient);
542 543 544
/*Default value is true*/
void sal_enable_sip_update_method(Sal *ctx,bool_t value);

jehan's avatar
jehan committed
545 546 547 548 549
/**
 * returns keepalive period in ms
 * 0 desactiaved
 * */
unsigned int sal_get_keepalive_period(Sal *ctx);
550
void sal_use_session_timers(Sal *ctx, int expires);
551
void sal_use_dates(Sal *ctx, bool_t enabled);
Simon Morlat's avatar
Simon Morlat committed
552
void sal_use_one_matching_codec_policy(Sal *ctx, bool_t one_matching_codec);
553
void sal_use_rport(Sal *ctx, bool_t use_rports);
554
void sal_enable_auto_contacts(Sal *ctx, bool_t enabled);
555
void sal_set_root_ca(Sal* ctx, const char* rootCa);
556
const char *sal_get_root_ca(Sal* ctx);
557
void sal_verify_server_certificates(Sal *ctx, bool_t verify);
558
void sal_verify_server_cn(Sal *ctx, bool_t verify);
559 560
void sal_set_uuid(Sal*ctx, const char *uuid);
int sal_create_uuid(Sal*ctx, char *uuid, size_t len);
561
LINPHONE_PUBLIC void sal_enable_test_features(Sal*ctx, bool_t enabled);
562
void sal_use_no_initial_route(Sal *ctx, bool_t enabled);
563

Simon Morlat's avatar
Simon Morlat committed
564
int sal_iterate(Sal *sal);
565
MSList * sal_get_pending_auths(Sal *sal);
Simon Morlat's avatar
Simon Morlat committed
566 567 568 569 570

/*create an operation */
SalOp * sal_op_new(Sal *sal);

/*generic SalOp API, working for all operations */
571
Sal *sal_op_get_sal(const SalOp *op);
jehan's avatar
jehan committed
572
void sal_op_set_contact_address(SalOp *op, const SalAddress* address);
Simon Morlat's avatar
Simon Morlat committed
573
void sal_op_set_route(SalOp *op, const char *route);
jehan's avatar
jehan committed
574
void sal_op_set_route_address(SalOp *op, const SalAddress* address);
575
void sal_op_add_route_address(SalOp *op, const SalAddress* address);
576
void sal_op_set_realm(SalOp *op, const char *realm);
Simon Morlat's avatar
Simon Morlat committed
577
void sal_op_set_from(SalOp *op, const char *from);
jehan's avatar
jehan committed
578
void sal_op_set_from_address(SalOp *op, const SalAddress *from);
Simon Morlat's avatar
Simon Morlat committed
579
void sal_op_set_to(SalOp *op, const char *to);
jehan's avatar
jehan committed
580
void sal_op_set_to_address(SalOp *op, const SalAddress *to);
581
SalOp *sal_op_ref(SalOp* h);
582
void sal_op_stop_refreshing(SalOp *op);
Simon Morlat's avatar
Simon Morlat committed
583
void sal_op_release(SalOp *h);
584 585 586
/*same as release, but does not stop refresher if any*/
void* sal_op_unref(SalOp* op);

587
void sal_op_authenticate(SalOp *h, const SalAuthInfo *info);
jehan's avatar
jehan committed
588
void sal_op_cancel_authentication(SalOp *h);
Simon Morlat's avatar
Simon Morlat committed
589
void sal_op_set_user_pointer(SalOp *h, void *up);
590
SalAuthInfo * sal_op_get_auth_requested(SalOp *h);
591
const char *sal_op_get_from(const SalOp *op);
jehan's avatar
jehan committed
592
const SalAddress *sal_op_get_from_address(const SalOp *op);
593
const char *sal_op_get_to(const SalOp *op);
jehan's avatar
jehan committed
594
const SalAddress *sal_op_get_to_address(const SalOp *op);
jehan's avatar
jehan committed
595
const SalAddress *sal_op_get_contact_address(const SalOp *op);
Simon Morlat's avatar
Simon Morlat committed
596
const char *sal_op_get_route(const SalOp *op);
597
const MSList* sal_op_get_route_addresses(const SalOp *op);
598
const char *sal_op_get_proxy(const SalOp *op);
599
const char *sal_op_get_remote_contact(const SalOp *op);
600
const SalAddress* sal_op_get_remote_contact_address(const SalOp *op);
601 602
/*for incoming requests, returns the origin of the packet as a sip uri*/
const char *sal_op_get_network_origin(const SalOp *op);
jehan's avatar
jehan committed
603
const SalAddress *sal_op_get_network_origin_address(const SalOp *op);
604 605
/*returns far-end "User-Agent" string */
const char *sal_op_get_remote_ua(const SalOp *op);
Simon Morlat's avatar
Simon Morlat committed
606
void *sal_op_get_user_pointer(const SalOp *op);
jehan's avatar
jehan committed
607
const char* sal_op_get_call_id(const SalOp *op);
608
char* sal_op_get_dialog_id(const SalOp *op);
609

jehan's avatar
jehan committed
610 611 612
const SalAddress* sal_op_get_service_route(const SalOp *op);
void sal_op_set_service_route(SalOp *op,const SalAddress* service_route);

613
void sal_op_set_manual_refresher_mode(SalOp *op, bool_t enabled);
614
bool_t sal_op_is_ipv6(SalOp *op);
615 616
/*returns TRUE if there is no pending request that may block a future one */
bool_t sal_op_is_idle(SalOp *op);
617

618 619 620 621 622
const SalErrorInfo *sal_error_info_none(void);
const SalErrorInfo *sal_op_get_error_info(const SalOp *op);
void sal_error_info_reset(SalErrorInfo *ei);
void sal_error_info_set(SalErrorInfo *ei, SalReason reason, int code, const char *status_string, const char *warning);

Simon Morlat's avatar
Simon Morlat committed
623 624 625
/*Call API*/
int sal_call_set_local_media_description(SalOp *h, SalMediaDescription *desc);
int sal_call(SalOp *h, const char *from, const char *to);
626
int sal_call_notify_ringing(SalOp *h, bool_t early_media);
627
/*accept an incoming call or, during a call accept a reINVITE*/
628
int sal_call_accept(SalOp*h);
629
int sal_call_decline(SalOp *h, SalReason reason, const char *redirection /*optional*/);
630
int sal_call_update(SalOp *h, const char *subject, bool_t no_user_consent);
631
SalMediaDescription * sal_call_get_remote_media_description(SalOp *h);
Simon Morlat's avatar
Simon Morlat committed
632
SalMediaDescription * sal_call_get_final_media_description(SalOp *h);
633 634 635 636 637
int sal_call_refer(SalOp *h, const char *refer_to);
int sal_call_refer_with_replaces(SalOp *h, SalOp *other_call_h);
int sal_call_accept_refer(SalOp *h);
/*informs this call is consecutive to an incoming refer */
int sal_call_set_referer(SalOp *h, SalOp *refered_call);
638 639
/* returns the SalOp of a call that should be replaced by h, if any */
SalOp *sal_call_get_replaces(SalOp *h);
Simon Morlat's avatar
Simon Morlat committed
640
int sal_call_send_dtmf(SalOp *h, char dtmf);
641
int sal_call_terminate(SalOp *h);
642
bool_t sal_call_autoanswer_asked(SalOp *op);
643
void sal_call_send_vfu_request(SalOp *h);
644
int sal_call_is_offerer(const SalOp *h);
645
int sal_call_notify_refer_state(SalOp *h, SalOp *newcall);
646 647 648 649 650 651
/* Call test API */
/*willingly fails to parse SDP from received packets (INVITE and/or ACK) if value=true */
/* First version: for all new SalOp created (eg. each incoming or outgoing call). Do not forget to reset previous value when you are done!*/
void sal_default_enable_sdp_removal(Sal* h, bool_t enable) ;
/* Second version: for a specific call*/
void sal_call_enable_sdp_removal(SalOp *h, bool_t enable) ;
652

Simon Morlat's avatar
Simon Morlat committed
653
/*Registration*/
654
int sal_register(SalOp *op, const char *proxy, const char *from, int expires);
655
/*refresh a register, -1 mean use the last known value*/
656
int sal_register_refresh(SalOp *op, int expires);
657
int sal_unregister(SalOp *h);
658

Simon Morlat's avatar
Simon Morlat committed
659
/*Messaging */
Simon Morlat's avatar
Simon Morlat committed
660 661
int sal_text_send(SalOp *op, const char *from, const char *to, const char *text);
int sal_message_send(SalOp *op, const char *from, const char *to, const char* content_type, const char *msg);
Simon Morlat's avatar
Simon Morlat committed
662
int sal_message_reply(SalOp *op, SalReason reason);
Simon Morlat's avatar
Simon Morlat committed
663 664

/*presence Subscribe/notify*/
Simon Morlat's avatar
Simon Morlat committed
665
int sal_subscribe_presence(SalOp *op, const char *from, const char *to, int expires);
666
int sal_notify_presence(SalOp *op, SalPresenceModel *presence);
667
int sal_notify_presence_close(SalOp *op);
Simon Morlat's avatar
Simon Morlat committed
668

669
/*presence publish */
670
int sal_publish_presence(SalOp *op, const char *from, const char *to, int expires, SalPresenceModel *presence);
671

672 673 674 675

/*ping: main purpose is to obtain its own contact address behind firewalls*/
int sal_ping(SalOp *op, const char *from, const char *to);

Simon Morlat's avatar
Simon Morlat committed
676 677 678
/*info messages*/
int sal_send_info(SalOp *op, const char *from, const char *to, const SalBody *body);

679 680 681 682 683 684 685 686
/*generic subscribe/notify/publish api*/
int sal_subscribe(SalOp *op, const char *from, const char *to, const char *eventname, int expires, const SalBody *body);
int sal_unsubscribe(SalOp *op);
int sal_subscribe_accept(SalOp *op);
int sal_subscribe_decline(SalOp *op, SalReason reason);
int sal_notify(SalOp *op, const SalBody *body);
int sal_notify_close(SalOp *op);
int sal_publish(SalOp *op, const char *from, const char *to, const char*event_name, int expires, const SalBody *body);
Simon Morlat's avatar
Simon Morlat committed
687

jehan's avatar
jehan committed
688 689
/*privacy, must be in sync with LinphonePrivacyMask*/
typedef enum _SalPrivacy {
Simon Morlat's avatar
Simon Morlat committed
690
	SalPrivacyNone=0x0,
jehan's avatar
jehan committed
691 692 693 694
	SalPrivacyUser=0x1,
	SalPrivacyHeader=0x2,
	SalPrivacySession=0x4,
	SalPrivacyId=0x8,
Simon Morlat's avatar
Simon Morlat committed
695 696
	SalPrivacyCritical=0x10,
	SalPrivacyDefault=0x8000
jehan's avatar
jehan committed
697 698 699 700 701 702 703 704
} SalPrivacy;
typedef  unsigned int SalPrivacyMask;

const char* sal_privacy_to_string(SalPrivacy  privacy);
void sal_op_set_privacy(SalOp* op,SalPrivacy privacy);
SalPrivacy sal_op_get_privacy(const SalOp* op);


705

706
#define payload_type_set_number(pt,n)		(pt)->user_data=(void*)((long)n);
707 708
#define payload_type_get_number(pt)		((int)(long)(pt)->user_data)

709 710 711
/*misc*/
void sal_get_default_local_ip(Sal *sal, int address_family, char *ip, size_t iplen);

712 713
typedef void (*SalResolverCallback)(void *data, const char *name, struct addrinfo *ai_list);

Simon Morlat's avatar
Simon Morlat committed
714 715 716 717
typedef struct SalResolverContext SalResolverContext;

SalResolverContext * sal_resolve_a(Sal* sal, const char *name, int port, int family, SalResolverCallback cb, void *data);
//void sal_resolve_cancel(Sal *sal, SalResolverContext *ctx);
718 719 720 721

SalCustomHeader *sal_custom_header_append(SalCustomHeader *ch, const char *name, const char *value);
const char *sal_custom_header_find(const SalCustomHeader *ch, const char *name);
void sal_custom_header_free(SalCustomHeader *ch);
Simon Morlat's avatar
Simon Morlat committed
722
SalCustomHeader *sal_custom_header_clone(const SalCustomHeader *ch);
Simon Morlat's avatar
Simon Morlat committed
723 724 725 726

const SalCustomHeader *sal_op_get_recv_custom_header(SalOp *op);

void sal_op_set_sent_custom_header(SalOp *op, SalCustomHeader* ch);
727

jehan's avatar
jehan committed
728 729
void sal_enable_logs();
void sal_disable_logs();
Simon Morlat's avatar
Simon Morlat committed
730 731 732

/*internal API */
void __sal_op_init(SalOp *b, Sal *sal);
733
void __sal_op_set_network_origin(SalOp *op, const char *origin /*a sip uri*/);
jehan's avatar
jehan committed
734
void __sal_op_set_network_origin_address(SalOp *op, SalAddress *origin);
735
void __sal_op_set_remote_contact(SalOp *op, const char *ct);
Simon Morlat's avatar
Simon Morlat committed
736 737
void __sal_op_free(SalOp *b);

738 739
/*test api*/
/*0 for no error*/
740
LINPHONE_PUBLIC	void sal_set_send_error(Sal *sal,int value);
jehan's avatar
jehan committed
741
/*1 for no error*/
742
LINPHONE_PUBLIC	void sal_set_recv_error(Sal *sal,int value);
743 744 745 746

/*always answer 480 if value=true*/
LINPHONE_PUBLIC	void sal_enable_unconditional_answer(Sal *sal,int value);

jehan's avatar
jehan committed
747 748 749
/*refresher retry after value in ms*/
LINPHONE_PUBLIC	void sal_set_refresher_retry_after(Sal *sal,int value);
LINPHONE_PUBLIC	int sal_get_refresher_retry_after(const Sal *sal);
jehan's avatar
jehan committed
750 751 752
/*enable contact fixing*/
void sal_nat_helper_enable(Sal *sal,bool_t enable);
bool_t sal_nat_helper_enabled(Sal *sal);
jehan's avatar
jehan committed
753

Sylvain Berfini's avatar
Sylvain Berfini committed
754
LINPHONE_PUBLIC	void sal_set_dns_timeout(Sal* sal,int timeout);
755
LINPHONE_PUBLIC int sal_get_dns_timeout(const Sal* sal);