sal.h 32.4 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;

jehan's avatar
jehan committed
71
72
73
74
75
76
77
78
79
80
#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)
#define SAL_MEDIA_DESCRIPTION_NETWORK_XXXCAST_CHANGED		(1<<5) /* use to notify when switching from multicast to unicast*/
#define SAL_MEDIA_DESCRIPTION_FORCE_STREAM_RECONSTRUCTION	(1<<6) /* use force graph reconstruction*/


81

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

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

101
102
103
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);
104
void sal_address_set_port(SalAddress *uri, int port);
105
106
107
108
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);
109
110
void sal_address_set_param(SalAddress *u,const char* name,const char* value);
void sal_address_set_transport(SalAddress* addr,SalTransport transport);
111
void sal_address_set_transport_name(SalAddress* addr,const char* transport);
112
113
void sal_address_set_params(SalAddress *addr, const char *params);
void sal_address_set_uri_params(SalAddress *addr, const char *params);
114
bool_t sal_address_is_ipv6(const SalAddress *addr);
115
bool_t sal_address_is_sip(const SalAddress *addr);
116
117
118
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
119

Ghislain MARY's avatar
Ghislain MARY committed
120
121
LINPHONE_PUBLIC Sal * sal_init();
LINPHONE_PUBLIC void sal_uninit(Sal* sal);
Simon Morlat's avatar
Simon Morlat committed
122
123
void sal_set_user_pointer(Sal *sal, void *user_data);
void *sal_get_user_pointer(const Sal *sal);
124
125
126


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

Simon Morlat's avatar
Simon Morlat committed
134
typedef enum{
135
	SalProtoRtpAvp,
136
	SalProtoRtpSavp,
137
138
	SalProtoRtpAvpf,
	SalProtoRtpSavpf,
johan's avatar
johan committed
139
140
	SalProtoUdpTlsRtpSavp,
	SalProtoUdpTlsRtpSavpf,
141
	SalProtoOther
Simon Morlat's avatar
Simon Morlat committed
142
}SalMediaProto;
jehan's avatar
jehan committed
143
const char* sal_media_proto_to_string(SalMediaProto type);
Simon Morlat's avatar
Simon Morlat committed
144

Simon Morlat's avatar
Simon Morlat committed
145
146
147
148
149
150
typedef enum{
	SalStreamSendRecv,
	SalStreamSendOnly,
	SalStreamRecvOnly,
	SalStreamInactive
}SalStreamDir;
jehan's avatar
jehan committed
151
const char* sal_stream_dir_to_string(SalStreamDir type);
Simon Morlat's avatar
Simon Morlat committed
152

jehan's avatar
jehan committed
153

154
155
#define SAL_ENDPOINT_CANDIDATE_MAX 2

156
157
158
159
160
161
162
163
164
165
166
#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;
167
	int port;
168
169
	int rport;
} SalIceCandidate;
170

171
#define SAL_MEDIA_DESCRIPTION_MAX_ICE_CANDIDATES 20
172
173
174
175
176
177
178

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

#define SAL_MEDIA_DESCRIPTION_MAX_ICE_REMOTE_CANDIDATES 2
179

180
181
#define SAL_MEDIA_DESCRIPTION_MAX_ICE_UFRAG_LEN 256
#define SAL_MEDIA_DESCRIPTION_MAX_ICE_PWD_LEN 256
182

183
/*sufficient for 256bit keys encoded in base 64*/
184
#define SAL_SRTP_KEY_SIZE 128
185

186
187
typedef struct SalSrtpCryptoAlgo {
	unsigned int tag;
jehan's avatar
jehan committed
188
	MSCryptoSuite algo;
189
	char master_key[SAL_SRTP_KEY_SIZE];
190
191
192
193
} SalSrtpCryptoAlgo;

#define SAL_CRYPTO_ALGO_MAX 4

johan's avatar
johan committed
194
195
196
197
198
199
200
typedef enum {
	SalDtlsRoleInvalid,
	SalDtlsRoleIsServer,
	SalDtlsRoleIsClient,
	SalDtlsRoleUnset
} SalDtlsRole;

jehan's avatar
jehan committed
201
typedef enum {
202
203
204
	SalMulticastInactive=0,
	SalMulticastSender,
	SalMulticastReceiver,
jehan's avatar
jehan committed
205
206
207
	SalMulticastSenderReceiver
} SalMulticastRole;

208
209
210
211
212
typedef enum {
	SalOpSDPNormal = 0, /** No special handling for SDP */
	SalOpSDPSimulateError, /** Will simulate an SDP parsing error */
	SalOpSDPSimulateRemove /** Will simulate no SDP in the op */
} SalOpSDPHandling;
jehan's avatar
jehan committed
213

214
typedef struct SalStreamDescription{
215
	char name[16]; /*unique name of stream, in order to ease offer/answer model algorithm*/
Simon Morlat's avatar
Simon Morlat committed
216
	SalMediaProto proto;
217
	SalStreamType type;
218
	char typeother[32];
219
	char proto_other[32];
220
221
	char rtp_addr[64];
	char rtcp_addr[64];
222
223
	unsigned int rtp_ssrc;
	char rtcp_cname[255];
224
225
	int rtp_port;
	int rtcp_port;
226
227
	MSList *payloads; /*<list of PayloadType */
	MSList *already_assigned_payloads; /*<list of PayloadType offered in the past, used for correct allocation of payload type numbers*/
228
229
	int bandwidth;
	int ptime;
Simon Morlat's avatar
Simon Morlat committed
230
	SalStreamDir dir;
231
	SalSrtpCryptoAlgo crypto[SAL_CRYPTO_ALGO_MAX];
232
	unsigned int crypto_local_tag;
233
	int max_rate;
234
	OrtpRtcpFbConfiguration rtcp_fb;
235
	OrtpRtcpXrConfiguration rtcp_xr;
236
237
238
239
240
	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;
241
	bool_t ice_completed;
242
	bool_t pad[2];
johan's avatar
johan committed
243
244
	char dtls_fingerprint[256];
	SalDtlsRole dtls_role;
jehan's avatar
jehan committed
245
246
	int ttl; /*for multicast -1 to disable*/
	SalMulticastRole multicast_role;
247
248
} SalStreamDescription;

249
250
251
252
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
253

254
typedef struct SalMediaDescription{
255
	int refcount;
256
	char name[64];
257
258
	char addr[64];
	char username[64];
259
	int nb_streams;
260
	int bandwidth;
261
262
	unsigned int session_ver;
	unsigned int session_id;
263
	SalStreamDir dir;
Simon Morlat's avatar
Simon Morlat committed
264
	SalStreamDescription streams[SAL_MEDIA_DESCRIPTION_MAX_STREAMS];
265
	OrtpRtcpXrConfiguration rtcp_xr;
266
267
268
269
	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;
270
	bool_t pad[2];
271
272
} SalMediaDescription;

273
274
275
276
277
typedef struct SalMessage{
	const char *from;
	const char *text;
	const char *url;
	const char *message_id;
278
	const char *content_type;
279
	time_t time;
280
281
}SalMessage;

282
283
284
285
286
typedef struct SalIsComposing {
	const char *from;
	const char *text;
} SalIsComposing;

287
288
#define SAL_MEDIA_DESCRIPTION_MAX_MESSAGE_ATTRIBUTES 5

Simon Morlat's avatar
Simon Morlat committed
289
SalMediaDescription *sal_media_description_new();
290
SalMediaDescription * sal_media_description_ref(SalMediaDescription *md);
291
void sal_media_description_unref(SalMediaDescription *md);
Simon Morlat's avatar
Simon Morlat committed
292
bool_t sal_media_description_empty(const SalMediaDescription *md);
293
int sal_media_description_equals(const SalMediaDescription *md1, const SalMediaDescription *md2);
Simon Morlat's avatar
Simon Morlat committed
294
bool_t sal_media_description_has_dir(const SalMediaDescription *md, SalStreamDir dir);
295
LINPHONE_PUBLIC SalStreamDescription *sal_media_description_find_stream(SalMediaDescription *md, SalMediaProto proto, SalStreamType type);
296
297
298
299
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
300
void sal_media_description_set_dir(SalMediaDescription *md, SalStreamDir stream_dir);
301
302
303
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);
johan's avatar
johan committed
304
bool_t sal_stream_description_has_dtls(const SalStreamDescription *sd);
305
306
bool_t sal_media_description_has_avpf(const SalMediaDescription *md);
bool_t sal_media_description_has_srtp(const SalMediaDescription *md);
johan's avatar
johan committed
307
bool_t sal_media_description_has_dtls(const SalMediaDescription *md);
308
int sal_media_description_get_nb_active_streams(const SalMediaDescription *md);
Simon Morlat's avatar
Simon Morlat committed
309

310

Simon Morlat's avatar
Simon Morlat committed
311
312
313
/*this structure must be at the first byte of the SalOp structure defined by implementors*/
typedef struct SalOpBase{
	Sal *root;
314
	char *route; /*or request-uri for REGISTER*/
315
	MSList* route_addresses; /*list of SalAddress* */
jehan's avatar
jehan committed
316
	SalAddress* contact_address;
Simon Morlat's avatar
Simon Morlat committed
317
	char *from;
jehan's avatar
jehan committed
318
	SalAddress* from_address;
Simon Morlat's avatar
Simon Morlat committed
319
	char *to;
jehan's avatar
jehan committed
320
	SalAddress* to_address;
321
	char *origin;
jehan's avatar
jehan committed
322
	SalAddress* origin_address;
323
	char *remote_ua;
324
325
	SalAddress* remote_contact_address;
	char *remote_contact;
Simon Morlat's avatar
Simon Morlat committed
326
327
	SalMediaDescription *local_media;
	SalMediaDescription *remote_media;
Simon Morlat's avatar
Simon Morlat committed
328
	void *user_pointer;
jehan's avatar
jehan committed
329
	const char* call_id;
330
	char* realm;
jehan's avatar
jehan committed
331
	SalAddress* service_route; /*as defined by rfc3608, might be a list*/
Simon Morlat's avatar
Simon Morlat committed
332
333
	SalCustomHeader *sent_custom_headers;
	SalCustomHeader *recv_custom_headers;
Simon Morlat's avatar
Simon Morlat committed
334
335
} SalOpBase;

336

337
typedef enum SalReason{
338
	SalReasonNone, /*no error, please leave first so that it takes 0 value*/
339
340
341
342
	SalReasonDeclined,
	SalReasonBusy,
	SalReasonRedirect,
	SalReasonTemporarilyUnavailable,
343
	SalReasonRequestTimeout,
344
345
	SalReasonNotFound,
	SalReasonDoNotDisturb,
346
	SalReasonUnsupportedContent,
347
	SalReasonForbidden,
348
	SalReasonUnknown,
349
	SalReasonServiceUnavailable,
jehan's avatar
jehan committed
350
	SalReasonRequestPending,
351
	SalReasonUnauthorized,
352
	SalReasonNotAcceptable,
353
354
355
356
357
358
	SalReasonNoMatch, /*equivalent to 481 Transaction/Call leg does not exist*/
	SalReasonMovedPermanently,
	SalReasonGone,
	SalReasonAddressIncomplete,
	SalReasonNotImplemented,
	SalReasonBadGateway,
359
	SalReasonServerTimeout,
360
361
	SalReasonIOError,
	SalReasonInternalError
362
363
}SalReason;

jehan's avatar
jehan committed
364
365
const char* sal_reason_to_string(const SalReason reason);

366
367
368
369
370
371
372
373
typedef struct SalErrorInfo{
	SalReason reason;
	char *status_string;
	int protocol_code;
	char *warnings;
	char *full_string; /*concatenation of status_string + warnings*/
}SalErrorInfo;

374
375
376
377
378
379
380
381
382
383
384
typedef enum SalPresenceStatus{
	SalPresenceOffline,
	SalPresenceOnline,
	SalPresenceBusy,
	SalPresenceBerightback,
	SalPresenceAway,
	SalPresenceOnthephone,
	SalPresenceOuttolunch,
	SalPresenceDonotdisturb,
	SalPresenceMoved,
	SalPresenceAltService,
385
	SalPresenceOnVacation
386
387
}SalPresenceStatus;

388
389
390
struct _SalPresenceModel;
typedef struct _SalPresenceModel SalPresenceModel;

jehan's avatar
jehan committed
391
392
const char* sal_presence_status_to_string(const SalPresenceStatus status);

393
394
395
396
397
398
399
typedef enum SalReferStatus{
	SalReferTrying,
	SalReferSuccess,
	SalReferFailed
}SalReferStatus;

typedef enum SalSubscribeStatus{
400
401
	SalSubscribeNone,
	SalSubscribePending,
402
403
	SalSubscribeActive,
	SalSubscribeTerminated
404
}SalSubscribeStatus;
405

406
407
408
409
410
typedef enum SalTextDeliveryStatus{
	SalTextDeliveryInProgress,
	SalTextDeliveryDone,
	SalTextDeliveryFailed
}SalTextDeliveryStatus;
411

412
413
414
/**
 * auth event mode
 * */
jehan's avatar
jehan committed
415
typedef enum SalAuthMode { /*this enum must be same as belle_sip_auth_mode_t*/
416
417
418
419
420
421
422
423
424
425
426
427
	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
428
typedef enum SalCertificateRawFormat {/*this enum must be same as belle_sip_certificate_raw_format_t*/
429
430
431
432
433
434
	SAL_CERTIFICATE_RAW_FORMAT_PEM, /** PEM format*/
	SAL_CERTIFICATE_RAW_FORMAT_DER /** ASN.1 raw format*/
}SalCertificateRawFormat;



jehan's avatar
jehan committed
435
436
437
438
439
typedef struct SalAuthInfo{
	char *username;
	char *userid;
	char *password;
	char *realm;
440
	char *domain;
jehan's avatar
jehan committed
441
	char *ha1;
442
443
444
	SalAuthMode mode;
	SalSigningKey *key;
	SalCertificatesChain *certificates;
jehan's avatar
jehan committed
445
446
}SalAuthInfo;

Simon Morlat's avatar
Simon Morlat committed
447
448
449
450
451
typedef struct SalBody{
	const char *type;
	const char *subtype;
	const void *data;
	size_t size;
452
	const char *encoding;
Simon Morlat's avatar
Simon Morlat committed
453
454
}SalBody;

455
456
457
typedef void (*SalOnCallReceived)(SalOp *op);
typedef void (*SalOnCallRinging)(SalOp *op);
typedef void (*SalOnCallAccepted)(SalOp *op);
458
typedef void (*SalOnCallAck)(SalOp *op);
459
typedef void (*SalOnCallUpdating)(SalOp *op, bool_t is_update);/*< Called when a reINVITE/UPDATE is received*/
Simon Morlat's avatar
Simon Morlat committed
460
typedef void (*SalOnCallTerminated)(SalOp *op, const char *from);
461
typedef void (*SalOnCallFailure)(SalOp *op);
462
typedef void (*SalOnCallReleased)(SalOp *salop);
jehan's avatar
jehan committed
463
typedef void (*SalOnAuthRequestedLegacy)(SalOp *op, const char *realm, const char *username);
jehan's avatar
jehan committed
464
typedef bool_t (*SalOnAuthRequested)(Sal *sal,SalAuthInfo* info);
jehan's avatar
jehan committed
465
typedef void (*SalOnAuthFailure)(SalOp *op, SalAuthInfo* info);
466
typedef void (*SalOnRegisterSuccess)(SalOp *op, bool_t registered);
467
typedef void (*SalOnRegisterFailure)(SalOp *op);
468
469
470
typedef void (*SalOnVfuRequest)(SalOp *op);
typedef void (*SalOnDtmfReceived)(SalOp *op, char dtmf);
typedef void (*SalOnRefer)(Sal *sal, SalOp *op, const char *referto);
471
typedef void (*SalOnTextReceived)(SalOp *op, const SalMessage *msg);
472
typedef void (*SalOnTextDeliveryUpdate)(SalOp *op, SalTextDeliveryStatus);
473
typedef void (*SalOnIsComposingReceived)(SalOp *op, const SalIsComposing *is_composing);
474
typedef void (*SalOnNotifyRefer)(SalOp *op, SalReferStatus state);
475
typedef void (*SalOnSubscribeResponse)(SalOp *op, SalSubscribeStatus status);
476
477
478
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);
479
typedef void (*SalOnParsePresenceRequested)(SalOp *salop, const char *content_type, const char *content_subtype, const char *content, SalPresenceModel **result);
480
typedef void (*SalOnConvertPresenceToXMLRequested)(SalOp *salop, SalPresenceModel *presence, const char *contact, char **content);
481
typedef void (*SalOnNotifyPresence)(SalOp *op, SalSubscribeStatus ss, SalPresenceModel *model, const char *msg);
482
483
typedef void (*SalOnSubscribePresenceReceived)(SalOp *salop, const char *from);
typedef void (*SalOnSubscribePresenceClosed)(SalOp *salop, const char *from);
484
typedef void (*SalOnPingReply)(SalOp *salop);
Simon Morlat's avatar
Simon Morlat committed
485
typedef void (*SalOnInfoReceived)(SalOp *salop, const SalBody *body);
486
typedef void (*SalOnPublishResponse)(SalOp *salop);
487
typedef void (*SalOnExpire)(SalOp *salop);
jehan's avatar
jehan committed
488
489
490
/*allows sal implementation to access auth info if available, return TRUE if found*/


491

Simon Morlat's avatar
Simon Morlat committed
492
493
494
495
typedef struct SalCallbacks{
	SalOnCallReceived call_received;
	SalOnCallRinging call_ringing;
	SalOnCallAccepted call_accepted;
496
	SalOnCallAck call_ack;
497
	SalOnCallUpdating call_updating;
Simon Morlat's avatar
Simon Morlat committed
498
499
	SalOnCallTerminated call_terminated;
	SalOnCallFailure call_failure;
500
	SalOnCallReleased call_released;
jehan's avatar
jehan committed
501
	SalOnAuthFailure auth_failure;
502
503
504
505
506
507
	SalOnRegisterSuccess register_success;
	SalOnRegisterFailure register_failure;
	SalOnVfuRequest vfu_request;
	SalOnDtmfReceived dtmf_received;
	SalOnRefer refer_received;
	SalOnTextReceived text_received;
508
	SalOnTextDeliveryUpdate text_delivery_update;
509
	SalOnIsComposingReceived is_composing_received;
510
	SalOnNotifyRefer notify_refer;
Simon Morlat's avatar
Simon Morlat committed
511
	SalOnSubscribeReceived subscribe_received;
512
	SalOnSubscribeClosed subscribe_closed;
513
514
515
516
	SalOnSubscribeResponse subscribe_response;
	SalOnNotify notify;
	SalOnSubscribePresenceReceived subscribe_presence_received;
	SalOnSubscribePresenceClosed subscribe_presence_closed;
517
	SalOnParsePresenceRequested parse_presence_requested;
518
	SalOnConvertPresenceToXMLRequested convert_presence_to_xml_requested;
519
	SalOnNotifyPresence notify_presence;
520
	SalOnPingReply ping_reply;
jehan's avatar
jehan committed
521
	SalOnAuthRequested auth_requested;
Simon Morlat's avatar
Simon Morlat committed
522
	SalOnInfoReceived info_received;
523
524
	SalOnPublishResponse on_publish_response;
	SalOnExpire on_expire;
Simon Morlat's avatar
Simon Morlat committed
525
526
}SalCallbacks;

jehan's avatar
jehan committed
527

528

jehan's avatar
jehan committed
529
530
SalAuthInfo* sal_auth_info_new();
SalAuthInfo* sal_auth_info_clone(const SalAuthInfo* auth_info);
531
void sal_auth_info_delete(SalAuthInfo* auth_info);
532
LINPHONE_PUBLIC int sal_auth_compute_ha1(const char* userid,const char* realm,const char* password, char ha1[33]);
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
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);

johan's avatar
johan committed
552
553
554
555
556
557
558
559
560
561
/**
 * Parse a directory for files containing certificate with the given subject CNAME
 * @param[out]	certificate_pem				the address of a string to store the certificate in PEM format. To be freed by caller
 * @param[out]	key_pem						the address of a string to store the key in PEM format. To be freed by caller
 * @param[in]	path						directory to parse
 * @param[in]	subject						subject CNAME
 * @param[in]	format 						either PEM or DER
 * @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
 * @param[in]	generate_dtls_fingerprint	if true and we have a certificate, generate the dtls fingerprint as described in rfc4572
 */
Guillaume BIENKOWSKI's avatar
Guillaume BIENKOWSKI committed
562
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);
johan's avatar
johan committed
563

564
565
566
567
void sal_certificates_chain_delete(SalCertificatesChain *chain);
void sal_signing_key_delete(SalSigningKey *key);


jehan's avatar
jehan committed
568

Simon Morlat's avatar
Simon Morlat committed
569
void sal_set_callbacks(Sal *ctx, const SalCallbacks *cbs);
570
int sal_listen_port(Sal *ctx, const char *addr, int port, SalTransport tr, int is_tunneled);
571
int sal_get_listening_port(Sal *ctx, SalTransport tr);
572
int sal_unlisten_ports(Sal *ctx);
Ghislain MARY's avatar
Ghislain MARY committed
573
LINPHONE_PUBLIC int sal_transport_available(Sal *ctx, SalTransport t);
574
void sal_set_dscp(Sal *ctx, int dscp);
575
576
577
578
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);
579
int sal_reset_transports(Sal *ctx);
580
ortp_socket_t sal_get_socket(Sal *ctx);
581
void sal_set_user_agent(Sal *ctx, const char *user_agent);
582
const char* sal_get_user_agent(Sal *ctx);
583
void sal_append_stack_string_to_user_agent(Sal *ctx);
584
585
/*keepalive period in ms*/
void sal_set_keepalive_period(Sal *ctx,unsigned int value);
586
void sal_use_tcp_tls_keepalive(Sal *ctx, bool_t enabled);
587
int sal_set_tunnel(Sal *ctx, void *tunnelclient);
588
589
590
/*Default value is true*/
void sal_enable_sip_update_method(Sal *ctx,bool_t value);

jehan's avatar
jehan committed
591
592
593
594
595
/**
 * returns keepalive period in ms
 * 0 desactiaved
 * */
unsigned int sal_get_keepalive_period(Sal *ctx);
596
void sal_use_session_timers(Sal *ctx, int expires);
597
void sal_use_dates(Sal *ctx, bool_t enabled);
Simon Morlat's avatar
Simon Morlat committed
598
void sal_use_one_matching_codec_policy(Sal *ctx, bool_t one_matching_codec);
599
void sal_use_rport(Sal *ctx, bool_t use_rports);
600
void sal_enable_auto_contacts(Sal *ctx, bool_t enabled);
601
void sal_set_root_ca(Sal* ctx, const char* rootCa);
602
const char *sal_get_root_ca(Sal* ctx);
603
void sal_verify_server_certificates(Sal *ctx, bool_t verify);
604
void sal_verify_server_cn(Sal *ctx, bool_t verify);
605
606
void sal_set_uuid(Sal*ctx, const char *uuid);
int sal_create_uuid(Sal*ctx, char *uuid, size_t len);
607
LINPHONE_PUBLIC void sal_enable_test_features(Sal*ctx, bool_t enabled);
608
void sal_use_no_initial_route(Sal *ctx, bool_t enabled);
609

Simon Morlat's avatar
Simon Morlat committed
610
int sal_iterate(Sal *sal);
611
MSList * sal_get_pending_auths(Sal *sal);
Simon Morlat's avatar
Simon Morlat committed
612
613
614
615
616

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

/*generic SalOp API, working for all operations */
617
Sal *sal_op_get_sal(const SalOp *op);
jehan's avatar
jehan committed
618
void sal_op_set_contact_address(SalOp *op, const SalAddress* address);
Simon Morlat's avatar
Simon Morlat committed
619
void sal_op_set_route(SalOp *op, const char *route);
jehan's avatar
jehan committed
620
void sal_op_set_route_address(SalOp *op, const SalAddress* address);
621
void sal_op_add_route_address(SalOp *op, const SalAddress* address);
622
void sal_op_set_realm(SalOp *op, const char *realm);
Simon Morlat's avatar
Simon Morlat committed
623
void sal_op_set_from(SalOp *op, const char *from);
jehan's avatar
jehan committed
624
void sal_op_set_from_address(SalOp *op, const SalAddress *from);
Simon Morlat's avatar
Simon Morlat committed
625
void sal_op_set_to(SalOp *op, const char *to);
jehan's avatar
jehan committed
626
void sal_op_set_to_address(SalOp *op, const SalAddress *to);
627
SalOp *sal_op_ref(SalOp* h);
628
void sal_op_stop_refreshing(SalOp *op);
Simon Morlat's avatar
Simon Morlat committed
629
void sal_op_release(SalOp *h);
630
631
632
/*same as release, but does not stop refresher if any*/
void* sal_op_unref(SalOp* op);

633
void sal_op_authenticate(SalOp *h, const SalAuthInfo *info);
jehan's avatar
jehan committed
634
void sal_op_cancel_authentication(SalOp *h);
Simon Morlat's avatar
Simon Morlat committed
635
void sal_op_set_user_pointer(SalOp *h, void *up);
636
SalAuthInfo * sal_op_get_auth_requested(SalOp *h);
637
const char *sal_op_get_from(const SalOp *op);
jehan's avatar
jehan committed
638
const SalAddress *sal_op_get_from_address(const SalOp *op);
639
const char *sal_op_get_to(const SalOp *op);
jehan's avatar
jehan committed
640
const SalAddress *sal_op_get_to_address(const SalOp *op);
jehan's avatar
jehan committed
641
const SalAddress *sal_op_get_contact_address(const SalOp *op);
Simon Morlat's avatar
Simon Morlat committed
642
const char *sal_op_get_route(const SalOp *op);
643
const MSList* sal_op_get_route_addresses(const SalOp *op);
644
const char *sal_op_get_proxy(const SalOp *op);
645
const char *sal_op_get_remote_contact(const SalOp *op);
646
const SalAddress* sal_op_get_remote_contact_address(const SalOp *op);
647
648
/*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
649
const SalAddress *sal_op_get_network_origin_address(const SalOp *op);
650
651
/*returns far-end "User-Agent" string */
const char *sal_op_get_remote_ua(const SalOp *op);
Simon Morlat's avatar
Simon Morlat committed
652
void *sal_op_get_user_pointer(const SalOp *op);
jehan's avatar
jehan committed
653
const char* sal_op_get_call_id(const SalOp *op);
654
char* sal_op_get_dialog_id(const SalOp *op);
655

jehan's avatar
jehan committed
656
657
658
const SalAddress* sal_op_get_service_route(const SalOp *op);
void sal_op_set_service_route(SalOp *op,const SalAddress* service_route);

659
void sal_op_set_manual_refresher_mode(SalOp *op, bool_t enabled);
660
bool_t sal_op_is_ipv6(SalOp *op);
661
662
/*returns TRUE if there is no pending request that may block a future one */
bool_t sal_op_is_idle(SalOp *op);
663

664
665
666
667
668
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
669
670
671
/*Call API*/
int sal_call_set_local_media_description(SalOp *h, SalMediaDescription *desc);
int sal_call(SalOp *h, const char *from, const char *to);
672
int sal_call_notify_ringing(SalOp *h, bool_t early_media);
673
/*accept an incoming call or, during a call accept a reINVITE*/
674
int sal_call_accept(SalOp*h);
675
int sal_call_decline(SalOp *h, SalReason reason, const char *redirection /*optional*/);
676
int sal_call_update(SalOp *h, const char *subject, bool_t no_user_consent);
677
SalMediaDescription * sal_call_get_remote_media_description(SalOp *h);
Simon Morlat's avatar
Simon Morlat committed
678
SalMediaDescription * sal_call_get_final_media_description(SalOp *h);
679
680
681
682
683
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);
684
685
/* 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
686
int sal_call_send_dtmf(SalOp *h, char dtmf);
687
int sal_call_terminate(SalOp *h);
688
bool_t sal_call_autoanswer_asked(SalOp *op);
689
void sal_call_send_vfu_request(SalOp *h);
690
int sal_call_is_offerer(const SalOp *h);
691
int sal_call_notify_refer_state(SalOp *h, SalOp *newcall);
692
/* Call test API */
693
694
695
696
697
698
699
700
701
702
703


/**
 * @brief Invoking this on the SAL will modify every subsequent SalOp to have a special handling for SDP.
 * @details This is especially useful while testing, to simulate some specific behaviors, like missing SDP or an error in parsing.
 *
 * @warning Don't forget to reset the handling method to SalOpSDPNormal afterwards.
 *
 * @param h the Sal instance
 * @param handling_method Could be SalOpSDPNormal, SalOpSDPSimulateError, SalOpSDPSimulateRemoval (\ref SalOpSDPHandling)
 */
704
LINPHONE_PUBLIC void sal_default_set_sdp_handling(Sal* h, SalOpSDPHandling handling_method) ;
705
/* Second version: for a specific call*/
706
LINPHONE_PUBLIC void sal_call_set_sdp_handling(SalOp *h, SalOpSDPHandling handling) ;
707

Simon Morlat's avatar
Simon Morlat committed
708
/*Registration*/
709
int sal_register(SalOp *op, const char *proxy, const char *from, int expires,SalAddress* old_contact);
710
/*refresh a register, -1 mean use the last known value*/
711
int sal_register_refresh(SalOp *op, int expires);
712
int sal_unregister(SalOp *h);
713

Simon Morlat's avatar
Simon Morlat committed
714
/*Messaging */
Simon Morlat's avatar
Simon Morlat committed
715
int sal_text_send(SalOp *op, const char *from, const char *to, const char *text);
716
int sal_message_send(SalOp *op, const char *from, const char *to, const char* content_type, const char *msg, const char *peer_uri);
Simon Morlat's avatar
Simon Morlat committed
717
int sal_message_reply(SalOp *op, SalReason reason);
Simon Morlat's avatar
Simon Morlat committed
718
719

/*presence Subscribe/notify*/
Simon Morlat's avatar
Simon Morlat committed
720
int sal_subscribe_presence(SalOp *op, const char *from, const char *to, int expires);
721
int sal_notify_presence(SalOp *op, SalPresenceModel *presence);
722
int sal_notify_presence_close(SalOp *op);
Simon Morlat's avatar
Simon Morlat committed
723

724
/*presence publish */
725
int sal_publish_presence(SalOp *op, const char *from, const char *to, int expires, SalPresenceModel *presence);
726

727
728
729
730

/*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
731
732
733
/*info messages*/
int sal_send_info(SalOp *op, const char *from, const char *to, const SalBody *body);

734
735
736
737
738
739
740
741
/*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
742

jehan's avatar
jehan committed
743
744
/*privacy, must be in sync with LinphonePrivacyMask*/
typedef enum _SalPrivacy {
Simon Morlat's avatar
Simon Morlat committed
745
	SalPrivacyNone=0x0,
jehan's avatar
jehan committed
746
747
748
749
	SalPrivacyUser=0x1,
	SalPrivacyHeader=0x2,
	SalPrivacySession=0x4,
	SalPrivacyId=0x8,
Simon Morlat's avatar
Simon Morlat committed
750
751
	SalPrivacyCritical=0x10,
	SalPrivacyDefault=0x8000
jehan's avatar
jehan committed
752
753
754
755
756
757
758
759
} 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);


760

761
#define payload_type_set_number(pt,n)		(pt)->user_data=(void*)((long)n);
762
763
#define payload_type_get_number(pt)		((int)(long)(pt)->user_data)

764
765
766
/*misc*/
void sal_get_default_local_ip(Sal *sal, int address_family, char *ip, size_t iplen);

767
768
typedef void (*SalResolverCallback)(void *data, const char *name, struct addrinfo *ai_list);

Simon Morlat's avatar
Simon Morlat committed
769
770
771
772
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);
773
774
775
776

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
777
SalCustomHeader *sal_custom_header_clone(const SalCustomHeader *ch);
Simon Morlat's avatar
Simon Morlat committed
778
779
780
781

const SalCustomHeader *sal_op_get_recv_custom_header(SalOp *op);

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

783
784
785
786
787
/** deprecated. use sal_set_log_level instead **/
void sal_enable_log();
/** deprecated. use sal_set_log_level instead **/
void sal_disable_log();
void sal_set_log_level(OrtpLogLevel level);
Simon Morlat's avatar
Simon Morlat committed
788
789
790

/*internal API */
void __sal_op_init(SalOp *b, Sal *sal);
791
void __sal_op_set_network_origin(SalOp *op, const char *origin /*a sip uri*/);
jehan's avatar
jehan committed
792
void __sal_op_set_network_origin_address(SalOp *op, SalAddress *origin);
793
void __sal_op_set_remote_contact(SalOp *op, const char *ct);
Simon Morlat's avatar
Simon Morlat committed
794
795
void __sal_op_free(SalOp *b);

796
797
/*test api*/
/*0 for no error*/
798
LINPHONE_PUBLIC	void sal_set_send_error(Sal *sal,int value);
jehan's avatar
jehan committed
799
/*1 for no error*/
800
LINPHONE_PUBLIC	void sal_set_recv_error(Sal *sal,int value);
801
802
803
804

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

805
806
807
808
809
LINPHONE_PUBLIC bool_t sal_pending_trans_checking_enabled(const Sal *sal) ;
LINPHONE_PUBLIC int sal_enable_pending_trans_checking(Sal *sal, bool_t value) ;



jehan's avatar
jehan committed
810
811
812
/*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
813
814
815
/*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
816

Sylvain Berfini's avatar
Sylvain Berfini committed
817
LINPHONE_PUBLIC	void sal_set_dns_timeout(Sal* sal,int timeout);
818
LINPHONE_PUBLIC int sal_get_dns_timeout(const Sal* sal);
819
820
LINPHONE_PUBLIC	void sal_set_transport_timeout(Sal* sal,int timeout);
LINPHONE_PUBLIC int sal_get_transport_timeout(const Sal* sal);
821
822
LINPHONE_PUBLIC void sal_enable_dns_srv(Sal *sal, bool_t enable);
LINPHONE_PUBLIC bool_t sal_dns_srv_enabled(const Sal *sal);
823
824
LINPHONE_PUBLIC void sal_set_dns_user_hosts_file(Sal *sal, const char *hosts_file);
LINPHONE_PUBLIC const char *sal_get_dns_user_hosts_file(const Sal *sal);
825
unsigned int sal_get_random(void);
826
LINPHONE_PUBLIC char *sal_get_random_token(int size);
827
unsigned char * sal_get_random_bytes(unsigned char *ret, size_t size);
828
829
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);
void sal_cancel_timer(Sal *sal, belle_sip_source_t *timer);
830

831
832
833
834
int sal_body_has_type(const SalBody *body, const char *type, const char *subtype);
/*this function parses a document with key=value pairs separated by new lines, and extracts the value for a given key*/
int sal_lines_get_value(const char *data, const char *key, char *value, size_t value_size);

835
LINPHONE_PUBLIC belle_sip_stack_t *sal_get_belle_sip_stack(Sal *sal);
836
char* sal_op_get_public_uri(SalOp *sal);
Simon Morlat's avatar
Simon Morlat committed
837

Guillaume BIENKOWSKI's avatar
Guillaume BIENKOWSKI committed
838
unsigned long sal_begin_background_task(const char *name, void (*max_time_reached)(void *), void *data);
Simon Morlat's avatar
Simon Morlat committed
839
840
void sal_end_background_task(unsigned long id);

841
842
843
844
/*Some old equipment may not only rely on attribute sendonly/recvonly/sendrecv/inative*/
void sal_op_cnx_ip_to_0000_if_sendonly_enable(SalOp *sal,bool_t yesno);
bool_t sal_op_cnx_ip_to_0000_if_sendonly_enabled(SalOp *sal);

jehan's avatar
jehan committed
845
846
847
848
849
850
void sal_set_http_proxy_host(Sal *sal, const char *host) ;
void sal_set_http_proxy_port(Sal *sal, int port) ;
const char *sal_get_http_proxy_host(const Sal *sal);
int sal_get_http_proxy_port(const Sal *sal);


851
#endif
Simon Morlat's avatar
Simon Morlat committed
852
853