Asterisk - The Open Source Telephony Project GIT-master-2de1a68
chan_unistim.c
Go to the documentation of this file.
1/*
2 * Asterisk -- An open source telephony toolkit.
3 *
4 * UNISTIM channel driver for asterisk
5 *
6 * Copyright (C) 2005 - 2007, Cedric Hans
7 *
8 * Cedric Hans <cedric.hans@mlkj.net>
9 *
10 * Asterisk 1.4 patch by Peter Be
11 *
12 * See http://www.asterisk.org for more information about
13 * the Asterisk project. Please do not directly contact
14 * any of the maintainers of this project for assistance;
15 * the project provides a web site, mailing lists and IRC
16 * channels for your use.
17 *
18 * This program is free software, distributed under the terms of
19 * the GNU General Public License Version 2. See the LICENSE file
20 * at the top of the source tree.
21 */
22
23/*!
24 * \file
25 *
26 * \brief chan_unistim channel driver for Asterisk
27 * \author Cedric Hans <cedric.hans@mlkj.net>
28 *
29 * Unistim (Unified Networks IP Stimulus) channel driver
30 * for Nortel i2002, i2004 and i2050
31 *
32 * \ingroup channel_drivers
33 */
34
35/*** MODULEINFO
36 <support_level>extended</support_level>
37 ***/
38
39#include "asterisk.h"
40
41#include <sys/stat.h>
42#include <signal.h>
43
44#if defined(__CYGWIN__) || defined(__NetBSD__)
45/*
46 * cygwin headers are partly inconsistent. struct iovec is defined in sys/uio.h
47 * which is not included by default by sys/socket.h - in_pktinfo is defined in
48 * w32api/ws2tcpip.h but this probably has compatibility problems with sys/socket.h
49 * So for the time being we simply disable HAVE_PKTINFO when building under cygwin.
50 * This should be done in some common header, but for now this is the only file
51 * using iovec and in_pktinfo so it suffices to apply the fix here.
52 */
53#ifdef HAVE_PKTINFO
54#undef HAVE_PKTINFO
55#endif
56#endif /* __CYGWIN__ || __NetBSD__ */
57
58#include "asterisk/paths.h" /* ast_config_AST_LOG_DIR used in (too ?) many places */
59#include "asterisk/network.h"
60#include "asterisk/channel.h"
61#include "asterisk/config.h"
62#include "asterisk/module.h"
63#include "asterisk/pbx.h"
64#include "asterisk/rtp_engine.h"
65#include "asterisk/unaligned.h"
66#include "asterisk/netsock2.h"
67#include "asterisk/acl.h"
68#include "asterisk/callerid.h"
69#include "asterisk/cli.h"
70#include "asterisk/app.h"
71#include "asterisk/mwi.h"
73#include "asterisk/causes.h"
75#include "asterisk/pickup.h"
76#include "asterisk/astobj2.h"
77#include "asterisk/astdb.h"
79#include "asterisk/bridge.h"
82
83#define DEFAULTCONTEXT "default"
84#define DEFAULTCALLERID "Unknown"
85#define DEFAULTCALLERNAME " "
86#define DEFAULTHEIGHT 3
87#define USTM_LOG_DIR "unistimHistory"
88#define USTM_LANG_DIR "unistimLang"
89
90/*! Size of the transmit buffer */
91#define MAX_BUF_SIZE 64
92/*! Number of slots for the transmit queue */
93#define MAX_BUF_NUMBER 150
94/*! Number of digits displayed on screen */
95#define MAX_SCREEN_NUMBER 15
96/*! Length of month label size */
97#define MONTH_LABEL_SIZE 3
98/*! Try x times before removing the phone */
99#define NB_MAX_RETRANSMIT 8
100/*! Nb of milliseconds waited when no events are scheduled */
101#define IDLE_WAIT 1000
102/*! Wait x milliseconds before resending a packet */
103#define RETRANSMIT_TIMER 2000
104/*! How often the mailbox is checked for new messages */
105#define TIMER_MWI 5000
106/*! Timeout value for entered number being dialed */
107#define DEFAULT_INTERDIGIT_TIMER 4000
108
109/*! Not used */
110#define DEFAULT_CODEC 0x00
111#define SIZE_PAGE 4096
112#define DEVICE_NAME_LEN 16
113#define AST_CONFIG_MAX_PATH 255
114#define MAX_ENTRY_LOG 30
115
116#define SUB_REAL 0
117#define SUB_RING 1
118#define SUB_THREEWAY 2
119
121
127
129 /*! Do not create an extension into the default dialplan */
131 /*! Prompt user for an extension number and register it */
133 /*! Register an extension with the line=> value */
135 /*! Used with AUTOPROVISIONING_TN */
138#define OUTPUT_HANDSET 0xC0
139#define OUTPUT_HEADPHONE 0xC1
140#define OUTPUT_SPEAKER 0xC2
141
142#define VOLUME_LOW 0x01
143#define VOLUME_LOW_SPEAKER 0x03
144#define VOLUME_NORMAL 0x02
145#define VOLUME_INSANELY_LOUD 0x07
146
147#define MUTE_OFF 0x00
148#define MUTE_ON 0xFF
149#define MUTE_ON_DISCRET 0xCE
150
151#define LED_BAR_OFF 0x00 /* bar off */
152#define LED_BAR_ON 0x01 /* bar on */
153#define LED_BAR_P2 0x02 /* bar 1s on/1s */
154#define LED_BAR_P3 0x03 /* bar 2.5s on/0.5s off */
155#define LED_BAR_P4 0x04 /* bar 0.6s on/0.3s off */
156#define LED_BAR_P5 0x05 /* bar 0.5s on/0.5s off */
157#define LED_BAR_P6 0x06 /* bar 2s on/0.5s off */
158#define LED_BAR_P7 0x07 /* bar off */
159#define LED_SPEAKER_OFF 0x08
160#define LED_SPEAKER_ON 0x09
161#define LED_HEADPHONE_OFF 0x010
162#define LED_HEADPHONE_ON 0x011
163#define LED_MUTE_OFF 0x018
164#define LED_MUTE_ON 0x019
165#define LED_MUTE_BLINK 0x1A
166
167#define SIZE_HEADER 6
168#define SIZE_MAC_ADDR 17
169#define TEXT_LENGTH_MAX 24
170#define TEXT_LINE0 0x00
171#define TEXT_LINE1 0x20
172#define TEXT_LINE2 0x40
173#define TEXT_NORMAL 0x05
174#define TEXT_INVERSE 0x25
175#define STATUS_LENGTH_MAX 28
176
177#define FAV_ICON_NONE 0x00
178#define FAV_ICON_ONHOOK_BLACK 0x20
179#define FAV_ICON_ONHOOK_WHITE 0x21
180#define FAV_ICON_SPEAKER_ONHOOK_BLACK 0x22
181#define FAV_ICON_SPEAKER_ONHOOK_WHITE 0x23
182#define FAV_ICON_OFFHOOK_BLACK 0x24
183#define FAV_ICON_OFFHOOK_WHITE 0x25
184#define FAV_ICON_ONHOLD_BLACK 0x26
185#define FAV_ICON_ONHOLD_WHITE 0x27
186#define FAV_ICON_SPEAKER_OFFHOOK_BLACK 0x28
187#define FAV_ICON_SPEAKER_OFFHOOK_WHITE 0x29
188#define FAV_ICON_PHONE_BLACK 0x2A
189#define FAV_ICON_PHONE_WHITE 0x2B
190#define FAV_ICON_SPEAKER_ONHOLD_BLACK 0x2C
191#define FAV_ICON_SPEAKER_ONHOLD_WHITE 0x2D
192#define FAV_ICON_HEADPHONES 0x2E
193#define FAV_ICON_HEADPHONES_ONHOLD 0x2F
194#define FAV_ICON_HOME 0x30
195#define FAV_ICON_CITY 0x31
196#define FAV_ICON_SHARP 0x32
197#define FAV_ICON_PAGER 0x33
198#define FAV_ICON_CALL_CENTER 0x34
199#define FAV_ICON_FAX 0x35
200#define FAV_ICON_MAILBOX 0x36
201#define FAV_ICON_REFLECT 0x37
202#define FAV_ICON_COMPUTER 0x38
203#define FAV_ICON_FORWARD 0x39
204#define FAV_ICON_LOCKED 0x3A
205#define FAV_ICON_TRASH 0x3B
206#define FAV_ICON_INBOX 0x3C
207#define FAV_ICON_OUTBOX 0x3D
208#define FAV_ICON_MEETING 0x3E
209#define FAV_ICON_BOX 0x3F
210
211#define FAV_BLINK_FAST 0x20
212#define FAV_BLINK_SLOW 0x40
213
214#define FAV_MAX_LENGTH 0x0A
215
216#define FAVNUM 6
217#define EXPNUM 24
218#define FAV_LINE_ICON FAV_ICON_ONHOOK_BLACK
219
220static void dummy(char *unused, ...)
221{
222 return;
223}
224
225/*! \brief Global jitterbuffer configuration - by default, jb is disabled
226 * \note Values shown here match the defaults shown in unistim.conf.sample */
228{
229 .flags = 0,
230 .max_size = 200,
231 .resync_threshold = 1000,
232 .impl = "fixed",
233 .target_extra = 40,
234};
236
237
238/* #define DUMP_PACKET 1 */
239/* #define DEBUG_TIMER ast_verbose */
240
241#define DEBUG_TIMER dummy
242/*! Enable verbose output. can also be set with the CLI */
243static int unistimdebug = 0;
244static int unistim_port;
247static int unistimsock = -1;
248
249static struct {
250 unsigned int tos;
251 unsigned int tos_audio;
252 unsigned int cos;
253 unsigned int cos_audio;
254} qos = { 0, 0, 0, 0 };
255
256static struct io_context *io;
258static struct sockaddr_in public_ip = { 0, };
259static unsigned char *buff; /*! Receive buffer address */
260static int unistim_reloading = 0;
262
263/*! This is the thread for the monitor which checks for input on the channels
264 * which are not currently in use. */
266
267/*! Protect the monitoring thread, so only one process can kill or start it, and not
268 * when it's doing something critical. */
270/*! Protect the session list */
272/*! Protect the device list */
274
289
293};
294
296 KEY_0 = 0x40,
297 KEY_1 = 0x41,
298 KEY_2 = 0x42,
299 KEY_3 = 0x43,
300 KEY_4 = 0x44,
301 KEY_5 = 0x45,
302 KEY_6 = 0x46,
303 KEY_7 = 0x47,
304 KEY_8 = 0x48,
305 KEY_9 = 0x49,
306 KEY_STAR = 0x4a,
307 KEY_SHARP = 0x4b,
308 KEY_UP = 0x4c,
309 KEY_DOWN = 0x4d,
310 KEY_RIGHT = 0x4e,
311 KEY_LEFT = 0x4f,
312 KEY_QUIT = 0x50,
313 KEY_COPY = 0x51,
314 KEY_FUNC1 = 0x54,
315 KEY_FUNC2 = 0x55,
316 KEY_FUNC3 = 0x56,
317 KEY_FUNC4 = 0x57,
320 KEY_MUTE = 0x5d,
323 KEY_FAV0 = 0x60,
324 KEY_FAV1 = 0x61,
325 KEY_FAV2 = 0x62,
326 KEY_FAV3 = 0x63,
327 KEY_FAV4 = 0x64,
328 KEY_FAV5 = 0x65,
330 KEY_CONF = 0x7c,
333 KEY_INDEX = 0x7f
335
343};
344
345static const int dtmf_row[] = { 697, 770, 852, 941 };
346static const float dtmf_col[] = { 1209, 1336, 1477, 1633 };
347
348struct wsabuf {
349 u_long len;
350 unsigned char *buf;
351};
352
355 unsigned int subtype; /*! SUB_REAL, SUB_RING or SUB_THREEWAY */
356 struct ast_channel *owner; /*! Asterisk channel used by the subchannel */
357 struct unistim_line *parent; /*! Unistim line */
358 struct ast_rtp_instance *rtp; /*! RTP handle */
359 int softkey; /*! Softkey assigned */
360 pthread_t ss_thread; /*! unistim_ss thread handle */
362 int holding; /*! this subchannel holds someone */
363 signed char ringvolume;
364 signed char ringstyle;
365 int moh; /*!< Music on hold in progress */
367};
368
369/*!
370 * \todo Convert to stringfields
371 */
374 char name[80]; /*! Like 200 */
375 char fullname[101]; /*! Like USTM/200\@black */
376 char exten[AST_MAX_EXTENSION]; /*! Extension where to start */
377 char cid_num[AST_MAX_EXTENSION]; /*! CallerID Number */
378 char mailbox[AST_MAX_EXTENSION]; /*! Mailbox for MWI */
379 char musicclass[MAX_MUSICCLASS]; /*! MusicOnHold class */
380 ast_group_t callgroup; /*! Call group */
381 ast_group_t pickupgroup; /*! Pickup group */
382 char accountcode[AST_MAX_ACCOUNT_CODE]; /*! Account code (for billing) */
383 int amaflags; /*! AMA flags (for billing) */
384 struct ast_format_cap *cap; /*! Codec supported */
385 char parkinglot[AST_MAX_CONTEXT]; /*! Parkinglot */
389};
390
391/*!
392 * \brief A device containing one or more lines
393 */
394static struct unistim_device {
396 int receiver_state; /*!< state of the receiver (see ReceiverState) */
397 int size_phone_number; /*!< size of the phone number */
398 char context[AST_MAX_EXTENSION]; /*!< Context to start in */
399 char phone_number[AST_MAX_EXTENSION]; /*!< the phone number entered by the user */
400 char redial_number[AST_MAX_EXTENSION]; /*!< the last phone number entered by the user */
401 char id[18]; /*!< mac address of the current phone in ascii */
402 char name[DEVICE_NAME_LEN]; /*!< name of the device */
403 int hasexp; /*!< if device have expansion connected */
404 char expsoftkeylabel[EXPNUM][11]; /*!< soft key label */
405 char softkeylabel[FAVNUM][11]; /*!< soft key label */
406 char softkeynumber[FAVNUM][AST_MAX_EXTENSION]; /*!< number dialed when the soft key is pressed */
407 char softkeyicon[FAVNUM]; /*!< icon number */
408 char softkeydevice[FAVNUM][16]; /*!< name of the device monitored */
411 struct unistim_device *sp[FAVNUM]; /*!< pointer to the device monitored by this soft key */
412 char language[MAX_LANGUAGE]; /*!< Language for asterisk sounds */
413 int height; /*!< The number of lines the phone can display */
414 char maintext0[25]; /*!< when the phone is idle, display this string on line 0 */
415 char maintext1[25]; /*!< when the phone is idle, display this string on line 1 */
416 char maintext2[25]; /*!< when the phone is idle, display this string on line 2 */
417 char titledefault[13]; /*!< title (text before date/time) */
418 char datetimeformat; /*!< format used for displaying time/date */
419 signed char contrast; /*!< contrast */
420 char country[3]; /*!< country used for dial tone frequency */
421 struct ast_tone_zone *tz; /*!< Tone zone for res_indications (ring, busy, congestion) */
422 signed char ringvolume; /*!< Ring volume */
423 signed char ringstyle; /*!< Ring melody */
424 signed char cwvolume; /*!< Ring volume on call waiting */
425 signed char cwstyle; /*!< Ring melody on call waiting */
426 int interdigit_timer; /*!< Interdigit timer for dialing number by timeout */
427 int dtmfduration; /*!< DTMF playback duration */
428 time_t nextdial; /*!< Timer used for dial by timeout */
429 int rtp_port; /*!< RTP port used by the phone */
430 int rtp_method; /*!< Select the unistim data used to establish a RTP session */
431 int status_method; /*!< Select the unistim packet used for sending status text */
432 char codec_number; /*!< The current codec used to make calls */
433 int missed_call; /*!< Number of call unanswered */
434 int callhistory; /*!< Allowed to record call history */
435 int sharp_dial; /*!< Execute Dial on '#' or not */
436 char lst_cid[TEXT_LENGTH_MAX]; /*!< Last callerID received */
437 char lst_cnm[TEXT_LENGTH_MAX]; /*!< Last callername recevied */
438 char call_forward[AST_MAX_EXTENSION]; /*!< Forward number */
439 int output; /*!< Handset, headphone or speaker */
440 int previous_output; /*!< Previous output */
441 int volume; /*!< Default volume */
442 int selected; /*!< softkey selected */
443 int microphone; /*!< Microphone mode (audio tx) */
444 int lastmsgssent; /*! Used by MWI */
445 time_t nextmsgcheck; /*! Used by MWI */
446 int nat; /*!< Used by the obscure ast_rtp_setnat */
447 enum autoprov_extn extension; /*!< See ifdef EXTENSION for valid values */
448 char extension_number[11]; /*!< Extension number entered by the user */
449 signed char to_delete; /*!< Used in reload */
451 AST_LIST_HEAD(,unistim_subchannel) subs; /*!< pointer to our current connection, channel... */
453 struct ast_ha *ha;
457
458static struct unistimsession {
460 struct sockaddr_in sin; /*!< IP address of the phone */
461 struct sockaddr_in sout; /*!< IP address of server */
462 int timeout; /*!< time-out in ticks : resend packet if no ack was received before the timeout occured */
463 unsigned short seq_phone; /*!< sequence number for the next packet (when we receive a request) */
464 unsigned short seq_server; /*!< sequence number for the next packet (when we send a request) */
465 unsigned short last_seq_ack; /*!< sequence number of the last ACK received */
466 unsigned long tick_next_ping; /*!< time for the next ping */
467 int last_buf_available; /*!< number of a free slot */
468 int nb_retransmit; /*!< number of retransmission */
469 int state; /*!< state of the phone (see phone_state) */
470 int size_buff_entry; /*!< size of the buffer used to enter datas */
471 char buff_entry[16]; /*!< Buffer for temporary datas */
472 char macaddr[18]; /*!< mac address of the phone (not always available) */
473 char firmware[8]; /*!< firmware of the phone (not always available) */
474 struct wsabuf wsabufsend[MAX_BUF_NUMBER]; /*!< Size of each paquet stored in the buffer array & pointer to this buffer */
475 unsigned char buf[MAX_BUF_NUMBER][MAX_BUF_SIZE]; /*!< Buffer array used to keep the lastest non-acked paquets */
479
480/*! Store on screen phone menu item (label and handler function) */
482 char *label;
483 int state;
484 void (*handle_option)(struct unistimsession *);
485};
486
487/*! Language item for currently existed translations */
489 char *label;
493};
494
495/*!
496 * \page Unistim datagram formats
497 *
498 * Format of datagrams :
499 * bytes 0 & 1 : ffff for discovery packet, 0000 for everything else
500 * byte 2 : sequence number (high part)
501 * byte 3 : sequence number (low part)
502 * byte 4 : 2 = ask question or send info, 1 = answer or ACK, 0 = retransmit request
503 * byte 5 : direction, 1 = server to phone, 2 = phone to server arguments
504 */
505
506static const unsigned char packet_rcv_discovery[] =
507 { 0xff, 0xff, 0xff, 0xff, 0x02, 0x02, 0xff, 0xff, 0xff, 0xff, 0x9e, 0x03, 0x08 };
508static const unsigned char packet_send_discovery_ack[] =
509 { 0x00, 0x00, /*Initial Seq (2 bytes) */ 0x00, 0x00, 0x00, 0x01 };
510
511static const unsigned char packet_recv_firm_version[] =
512 { 0x00, 0x00, 0x00, 0x13, 0x9a, 0x0a, 0x02 };
513static const unsigned char packet_recv_it_type[] =
514 { 0x00, 0x00, 0x00, 0x13, 0x9a, 0x04, 0x03 };
515static const unsigned char packet_recv_pressed_key[] =
516 { 0x00, 0x00, 0x00, 0x13, 0x99, 0x04, 0x00 };
517static const unsigned char packet_recv_pick_up[] =
518 { 0x00, 0x00, 0x00, 0x13, 0x99, 0x03, 0x04 };
519static const unsigned char packet_recv_hangup[] =
520 { 0x00, 0x00, 0x00, 0x13, 0x99, 0x03, 0x03 };
521static const unsigned char packet_recv_r2[] = { 0x00, 0x00, 0x00, 0x13, 0x96, 0x03, 0x03 };
522
523/*! Expansion module (i2004 KEM) */
524static const unsigned char packet_recv_expansion_pressed_key[] =
525 { 0x00, 0x00, 0x00, 0x13, 0x89, 0x04, 0x59 };
526static const unsigned char packet_send_expansion_next[] = { 0x09, 0x03, 0x17 };
527static const unsigned char packet_send_expansion_icon[] = { 0x09, 0x06, 0x59, 0x05, /*pos */ 0x47, /*icon */ 0x20 }; /* display an icon in front of the text zone */
528static const unsigned char packet_send_expansion_text[] = { 0x09, 0x0f, 0x57, 0x19, /*pos */ 0x47, /*text */ 0x20,
529 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20 /*end_text */ };
530
531
532/*! TransportAdapter */
533static const unsigned char packet_recv_resume_connection_with_server[] =
534 { 0xff, 0xff, 0xff, 0xff, 0x9e, 0x03, 0x08 };
535static const unsigned char packet_recv_mac_addr[] =
536 { 0xff, 0xff, 0xff, 0xff, 0x9a, 0x0d, 0x07 /*MacAddr */ };
537
538static const unsigned char packet_send_date_time3[] =
539 { 0x11, 0x09, 0x02, 0x02, /*Month */ 0x05, /*Day */ 0x06, /*Hour */ 0x07,
540/*Minutes */ 0x08, 0x32
541};
542static const unsigned char packet_send_date_time[] =
543 { 0x11, 0x09, 0x02, 0x0a, /*Month */ 0x05, /*Day */ 0x06, /*Hour */ 0x07, /*Minutes */
5440x08, 0x32, 0x17, 0x04, 0x24, 0x07, 0x19,
545 0x04, 0x07, 0x00, 0x19, 0x05, 0x09, 0x3e, 0x0f, 0x16, 0x05, 0x00, 0x80, 0x00, 0x1e,
546 0x05, 0x12, 0x00, 0x78
547};
548
549static const unsigned char packet_send_no_ring[] =
550 { 0x16, 0x04, 0x1a, 0x00, 0x16, 0x04, 0x11, 0x00 };
551static const unsigned char packet_send_s4[] =
552 { 0x16, 0x04, 0x1a, 0x00, 0x16, 0x04, 0x11, 0x00, 0x16, 0x06, 0x32, 0xdf, 0x00, 0xff,
5530x16, 0x05, 0x1c, 0x00, 0x00, 0x17, 0x05,
554 0x0b, 0x00, 0x00, 0x19, 0x04, 0x00, 0x00, 0x19, 0x04, 0x00, 0x08, 0x19, 0x04, 0x00,
555 0x10, 0x19, 0x04, 0x00, 0x18, 0x16, 0x05,
556 0x31, 0x00, 0x00, 0x16, 0x05, 0x04, 0x00, 0x00
557};
558static const unsigned char packet_send_call[] =
559 { 0x16, 0x04, 0x1a, 0x00, 0x16, 0x04, 0x11, 0x00, 0x16, 0x06, 0x32, 0xdf,
560 0x00, 0xff, 0x16, 0x05, 0x1c, 0x00, 0x00, 0x16, 0x0a, 0x38, 0x00, 0x12, 0xca, 0x03,
561 0xc0, 0xc3, 0xc5, 0x16, 0x16, 0x30, 0x00,
562 0x00, /*codec */ 0x12, 0x12, /* frames per packet */ 0x01, 0x5c, 0x00, /*port RTP */
563 0x0f, 0xa0, /* port RTCP */ 0x9c, 0x41,
564 /*port RTP */ 0x0f, 0xa0, /* port RTCP */ 0x9c, 0x41, /* IP Address */ 0x0a, 0x01,
565 0x16, 0x66
566};
567static const unsigned char packet_send_stream_based_tone_off[] =
568 { 0x16, 0x05, 0x1c, 0x00, 0x00 };
569
570static const unsigned char packet_send_mute[] = { 0x16, 0x05, 0x04, 0x00, 0x00 };
571#ifdef NOT_USED
572static const unsigned char packet_send_CloseAudioStreamRX[] = { 0x16, 0x05, 0x31, 0x00, 0xff };
573static const unsigned char packet_send_CloseAudioStreamTX[] = { 0x16, 0x05, 0x31, 0xff, 0x00 };
574#endif
575static const unsigned char packet_send_stream_based_tone_on[] =
576 { 0x16, 0x06, 0x1b, 0x00, 0x00, 0x05 };
577static const unsigned char packet_send_stream_based_tone_single_freq[] =
578 { 0x16, 0x06, 0x1d, 0x00, 0x01, 0xb8 };
579static const unsigned char packet_send_stream_based_tone_dual_freq[] =
580 { 0x16, 0x08, 0x1d, 0x00, 0x01, 0xb8, 0x01, 0x5e };
581static const unsigned char packet_send_select_output[] =
582 { 0x16, 0x06, 0x32, 0xc0, 0x01, 0x00 };
583
584static const unsigned char packet_send_ring[] =
585 { 0x16, 0x06, 0x32, 0xdf, 0x00, 0xff, 0x16, 0x05, 0x1c, 0x00, 0x00, 0x16,
586 0x04, 0x1a, 0x01, 0x16, 0x05, 0x12, 0x13 /* Ring type 10 to 17 */ , 0x18, 0x16, 0x04, 0x18, /* volume 00, 10, 20... */
587 0x20, 0x16, 0x04, 0x10, 0x00
588};
589//static const unsigned char packet_send_end_call[] =
590// { 0x16, 0x06, 0x32, 0xdf, 0x00, 0xff, 0x16, 0x05, 0x31, 0x00, 0x00, /* Headset LED off */ 0x19, 0x04, 0x00,
591//0x10, /* Mute LED off */ 0x19, 0x04, 0x00, 0x18,/* Stream unmute */ 0x16, 0x05, 0x04, 0x00, 0x00, /* Query RTCP */ 0x16, 0x04, 0x37, 0x10 };
592static const unsigned char packet_send_end_call[] =
593 { 0x16, 0x06, 0x32, 0xdf, 0x00, 0xff, 0x16, 0x05, 0x31, 0x00, 0x00, /* Query RTCP */ 0x16, 0x04, 0x37, 0x10 };
594static const unsigned char packet_send_s9[] =
595 { 0x16, 0x06, 0x32, 0xdf, 0x00, 0xff, 0x19, 0x04, 0x00, 0x10, 0x16, 0x05, 0x1c, 0x00,
5960x00 };
597static const unsigned char packet_send_rtp_packet_size[] =
598 { 0x16, 0x08, 0x38, 0x00, 0x00, 0xe0, 0x00, 0xa0 };
599static const unsigned char packet_send_jitter_buffer_conf[] =
600 { 0x16, 0x0e, 0x3a, 0x00, /* jitter */ 0x02, /* high water mark */ 0x04, 0x00, 0x00,
601/* early packet resync 2 bytes */ 0x3e, 0x80,
602 0x00, 0x00, /* late packet resync 2 bytes */ 0x3e, 0x80
603};
604
605/* Duration in ms div 2 (0x20 = 64ms, 0x08 = 16ms)
606static unsigned char packet_send_StreamBasedToneCad[] =
607 { 0x16, 0x0a, 0x1e, 0x00, duration on 0x0a, duration off 0x0d, duration on 0x0a, duration off 0x0d, duration on 0x0a, duration off 0x2b }; */
608static const unsigned char packet_send_open_audio_stream_rx[] =
609 { 0x16, 0x1a, 0x30, 0x00, 0xff, /* Codec */ 0x00, 0x00, 0x01, 0x00, 0xb8, 0xb8, 0x0e,
6100x0e, 0x01, /* Port */ 0x14, 0x50, 0x00,
611 0x00, /* Port */ 0x14, 0x50, 0x00, 0x00, /* Dest IP */ 0x0a, 0x93, 0x69, 0x05
612};
613static const unsigned char packet_send_open_audio_stream_tx[] =
614 { 0x16, 0x1a, 0x30, 0xff, 0x00, 0x00, /* Codec */ 0x00, 0x01, 0x00, 0xb8, 0xb8, 0x0e,
6150x0e, 0x01, /* Local port */ 0x14, 0x50,
616 0x00, 0x00, /* Rmt Port */ 0x14, 0x50, 0x00, 0x00, /* Dest IP */ 0x0a, 0x93, 0x69, 0x05
617};
618
619static const unsigned char packet_send_open_audio_stream_rx3[] =
620 { 0x16, 0x1a, 0x30, 0x00, 0xff, /* Codec */ 0x00, 0x00, 0x02, 0x01, 0xb8, 0xb8, 0x06,
6210x06, 0x81, /* RTP Port */ 0x14, 0x50,
622/* RTCP Port */ 0x14,
623 0x51, /* RTP Port */ 0x14, 0x50, /* RTCP Port */ 0x00, 0x00, /* Dest IP */ 0x0a, 0x93,
624 0x69, 0x05
625};
626static const unsigned char packet_send_open_audio_stream_tx3[] =
627 { 0x16, 0x1a, 0x30, 0xff, 0x00, 0x00, /* Codec */ 0x00, 0x02, 0x01, 0xb8, 0xb8, 0x06,
6280x06, 0x81, /* RTP Local port */ 0x14, 0x50,
629 /* RTCP Port */ 0x00, 0x00, /* RTP Rmt Port */ 0x14, 0x50, /* RTCP Port */ 0x00, 0x00,
630 /* Dest IP */ 0x0a, 0x93, 0x69, 0x05
631};
632
633static const unsigned char packet_send_arrow[] = { 0x17, 0x04, 0x04, 0x00 };
634static const unsigned char packet_send_blink_cursor[] = { 0x17, 0x04, 0x10, 0x86 };
635static const unsigned char packet_send_date_time2[] = { 0x17, 0x04, 0x17, 0x3d, 0x11, 0x09, 0x02, 0x0a, /*Month */ 0x05, /*Day */
636 0x06, /*Hour */ 0x07, /*Minutes */ 0x08, 0x32
637};
638static const unsigned char packet_send_Contrast[] =
639 { 0x17, 0x04, 0x24, /*Contrast */ 0x08 };
640static const unsigned char packet_send_start_timer[] =
641 { 0x17, 0x05, 0x0b, /*Timer option*/0x05, /* Timer ID */0x00, 0x17, 0x08, 0x16,
642 /* Text */ 'T', 'i', 'm', 'e', 'r' };
643static const unsigned char packet_send_stop_timer[] = { 0x17, 0x05, 0x0b, 0x02, 0x00 };
644static const unsigned char packet_send_icon[] = { 0x17, 0x05, 0x14, /*pos */ 0x00, /*icon */ 0x25 }; /* display an icon in front of the text zone */
645static const unsigned char packet_send_S7[] = { 0x17, 0x06, 0x0f, 0x30, 0x07, 0x07 };
646static const unsigned char packet_send_set_pos_cursor[] =
647 { 0x17, 0x06, 0x10, 0x81, 0x04, /*pos */ 0x20 };
648
649static unsigned char monthlabels[] =
650 { 'J', 'a', 'n', 'F', 'e', 'b', 'M', 'a', 'r', 'A', 'p', 'r', 'M', 'a', 'y', 'J', 'u', 'n',
651 'J', 'u', 'l', 'A', 'u', 'g', 'S', 'e', 'p', 'O', 'c', 't', 'N', 'o', 'v', 'D', 'e', 'c' };
652static unsigned char packet_send_monthlabels_download[] =
653 { 0x17, 0x0a, 0x15, /* Month (3 char) */ '-', '-', '-', '-', '-', '-', 0x20 };
654static const unsigned char packet_send_favorite[] =
655 { 0x17, 0x0f, 0x19, 0x10, /*pos */ 0x01, /*name */ 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
6560x20, 0x20, 0x20, 0x20, /*end_name */ 0x19,
657 0x05, 0x0f, /*pos */ 0x01, /*icone */ 0x00
658};
659static const unsigned char packet_send_title[] =
660 { 0x17, 0x10, 0x19, 0x02, /*text */ 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
6610x20, 0x20, 0x20, 0x20 /*end_text */ };
662static const unsigned char packet_send_text[] =
663 { 0x17, 0x1e, 0x1b, 0x04, /*pos */ 0x00, /*inverse */ 0x25, /*text */ 0x20, 0x20,
6640x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
665 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
666 /*end_text */ 0x17, 0x04, 0x10, 0x87
667};
668static const unsigned char packet_send_status[] =
669 { 0x17, 0x20, 0x19, 0x08, /*text */ 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
6700x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
671 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20 /*end_text */
672};
673static const unsigned char packet_send_status2[] =
674 { 0x17, 0x0b, 0x19, /* pos [08|28|48|68] */ 0x00, /* text */ 0x20, 0x20, 0x20, 0x20,
6750x20, 0x20, 0x20 /* end_text */ };
676
677/* Multiple character set support */
678/* ISO-8859-1 - Western European) */
679static const unsigned char packet_send_charset_iso_8859_1[] =
680 { 0x17, 0x08, 0x21, 0x1b, 0x2d, 0x41, 0x1b, 0x00 };
681/* ISO-8859-2 - Central European) */
682static const unsigned char packet_send_charset_iso_8859_2[] =
683 { 0x17, 0x08, 0x21, 0x1b, 0x2d, 0x42, 0x1b, 0x00 };
684/* ISO-8859-4 - Baltic) */
685static const unsigned char packet_send_charset_iso_8859_4[] =
686 { 0x17, 0x08, 0x21, 0x1b, 0x2d, 0x44, 0x1b, 0x00 };
687/* ISO 8859-5 - cyrillic */
688static const unsigned char packet_send_charset_iso_8859_5[] =
689 { 0x17, 0x08, 0x21, 0x1b, 0x2d, 0x4c, 0x1b, 0x00 };
690/* Japanese (ISO-2022-JP ?) */
691static const unsigned char packet_send_charset_iso_2022_jp[] =
692 { 0x17, 0x08, 0x21, 0x1b, 0x29, 0x49, 0x1b, 0x7e };
693
694static const unsigned char packet_send_led_update[] = { 0x19, 0x04, 0x00, 0x00 };
695
696static const unsigned char packet_send_query_basic_manager_04[] = { 0x1a, 0x04, 0x01, 0x04 };
697static const unsigned char packet_send_query_mac_address[] = { 0x1a, 0x04, 0x01, 0x08 };
698static const unsigned char packet_send_query_basic_manager_10[] = { 0x1a, 0x04, 0x01, 0x10 };
699static const unsigned char packet_send_S1[] = { 0x1a, 0x07, 0x07, 0x00, 0x00, 0x00, 0x13 };
700
701static unsigned char packet_send_ping[] =
702 { 0x1e, 0x05, 0x12, 0x00, /*Watchdog timer */ 0x78 };
703
704#define BUFFSEND unsigned char buffsend[64] = { 0x00, 0x00, 0xaa, 0xbb, 0x02, 0x01 }
705
706static const char tdesc[] = "UNISTIM Channel Driver";
707static const char channel_type[] = "USTM";
708
709/*! Protos */
710static struct ast_channel *unistim_new(struct unistim_subchannel *sub, int state, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor);
711static int load_module(void);
712static int reload(void);
713static int unload_module(void);
714static int reload_config(void);
715static void unistim_set_owner(struct unistim_subchannel *sub, struct ast_channel *chan);
716static void show_main_page(struct unistimsession *pte);
717static struct ast_channel *unistim_request(const char *type, struct ast_format_cap *cap, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor,
718 const char *dest, int *cause);
719static int unistim_call(struct ast_channel *ast, const char *dest, int timeout);
720static int unistim_hangup(struct ast_channel *ast);
721static int unistim_answer(struct ast_channel *ast);
722static struct ast_frame *unistim_read(struct ast_channel *ast);
723static int unistim_write(struct ast_channel *ast, struct ast_frame *frame);
724static int unistim_indicate(struct ast_channel *ast, int ind, const void *data,
725 size_t datalen);
726static int unistim_fixup(struct ast_channel *oldchan, struct ast_channel *newchan);
727static int unistim_senddigit_begin(struct ast_channel *ast, char digit);
728static int unistim_senddigit_end(struct ast_channel *ast, char digit,
729 unsigned int duration);
730static int unistim_sendtext(struct ast_channel *ast, const char *text);
731
732static int write_entry_history(struct unistimsession *pte, FILE * f, char c,
733 char *line1);
734static void change_callerid(struct unistimsession *pte, int type, char *callerid);
735
738 .description = tdesc,
740 .requester = unistim_request,
741 .call = unistim_call,
742 .hangup = unistim_hangup,
743 .answer = unistim_answer,
744 .read = unistim_read,
745 .write = unistim_write,
746 .indicate = unistim_indicate,
747 .fixup = unistim_fixup,
748 .send_digit_begin = unistim_senddigit_begin,
749 .send_digit_end = unistim_senddigit_end,
750 .send_text = unistim_sendtext,
751};
752
753static void send_start_rtp(struct unistim_subchannel *);
754
755static void send_callerid_screen(struct unistimsession *, struct unistim_subchannel *);
756static void key_favorite(struct unistimsession *, char);
757
758static void handle_select_codec(struct unistimsession *);
759static void handle_select_language(struct unistimsession *);
760static int find_language(const char*);
761
762static int unistim_free_sub(struct unistim_subchannel *);
763
765{
766 {"Change codec", STATE_SELECTCODEC, handle_select_codec},
768 {NULL, 0, NULL}
769};
770
772{
773 {"English", "en", ISO_8859_1, NULL},
774 {"French", "fr", ISO_8859_1, NULL},
775 {"Russian", "ru", ISO_8859_5, NULL},
776 {NULL, NULL, 0, NULL}
777};
778
779static char ustm_strcopy[1024];
780
782 const char *str_orig;
783 const char *str_trans;
784};
785
786static int lang_hash_fn(const void *obj, const int flags)
787{
788 const struct ustm_lang_entry *entry = obj;
789 return ast_str_hash(entry->str_orig);
790}
791
792static int lang_cmp_fn(void *obj, void *arg, int flags)
793{
794 struct ustm_lang_entry *entry1 = obj;
795 struct ustm_lang_entry *entry2 = arg;
796
797 return (!strcmp(entry1->str_orig, entry2->str_orig)) ? (CMP_MATCH | CMP_STOP) : 0;
798}
799
800static const char *ustmtext(const char *str, struct unistimsession *pte)
801{
802 struct ustm_lang_entry *lang_entry;
803 struct ustm_lang_entry le_search;
804 struct unistim_languages *lang = NULL;
805 int size;
806
807 if (pte->device) {
809 }
810 if (!lang) {
811 return str;
812 }
813 /* Check if specified language exists */
814 if (!lang->trans) {
815 char tmp[1024], *p, *p_orig = NULL, *p_trans = NULL;
816 FILE *f;
817
820 if (!lang->trans) {
821 ast_log(LOG_ERROR, "Unable to allocate container for translation!\n");
822 return str;
823 }
824 snprintf(tmp, sizeof(tmp), "%s/%s/%s.po", ast_config_AST_VAR_DIR,
826 f = fopen(tmp, "r");
827 if (!f) {
828 ast_log(LOG_WARNING, "There is no translation file for '%s'\n", lang->lang_short);
829 return str;
830 }
831 while (fgets(tmp, sizeof(tmp), f)) {
832 if (!(p = strchr(tmp, '\n'))) {
833 ast_log(LOG_ERROR, "Too long line found in language file - truncated!\n");
834 continue;
835 }
836 *p = '\0';
837 if (!(p = strchr(tmp, '"'))) {
838 continue;
839 }
840 if (tmp == strstr(tmp, "msgid")) {
841 p_orig = ast_strdup(p + 1);
842 p = strchr(p_orig, '"');
843 } else if (tmp == strstr(tmp, "msgstr")) {
844 p_trans = ast_strdup(p + 1);
845 p = strchr(p_trans, '"');
846 } else {
847 continue;
848 }
849 *p = '\0';
850 if (!p_trans || !p_orig) {
851 continue;
852 }
853 if (ast_strlen_zero(p_trans)) {
854 ast_free(p_trans);
855 ast_free(p_orig);
856 p_trans = NULL;
857 p_orig = NULL;
858 continue;
859 }
860 if (!(lang_entry = ao2_alloc(sizeof(*lang_entry), NULL))) {
861 fclose(f);
862 return str;
863 }
864
865 lang_entry->str_trans = p_trans;
866 lang_entry->str_orig = p_orig;
867 ao2_link(lang->trans, lang_entry);
868 p_trans = NULL;
869 p_orig = NULL;
870 }
871
872 fclose(f);
873 }
874
875 le_search.str_orig = str;
876 if ((lang_entry = ao2_find(lang->trans, &le_search, OBJ_POINTER))) {
877 size = strlen(lang_entry->str_trans)+1;
878 if (size > 1024) {
879 size = 1024;
880 }
881 memcpy(ustm_strcopy, lang_entry->str_trans, size);
882 ao2_ref(lang_entry, -1);
883 return ustm_strcopy;
884 }
885
886 return str;
887}
888
889static void display_last_error(const char *sz_msg)
890{
891 /* Display the error message */
892 ast_log(LOG_WARNING, "%s : (%d) %s\n", sz_msg, errno, strerror(errno));
893}
894
895static unsigned int get_tick_count(void)
896{
897 struct timeval now = ast_tvnow();
898
899 return (now.tv_sec * 1000) + (now.tv_usec / 1000);
900}
901
902/* Send data to a phone without retransmit nor buffering */
903static void send_raw_client(int size, const unsigned char *data, struct sockaddr_in *addr_to,
904 const struct sockaddr_in *addr_ourip)
905{
906#ifdef HAVE_PKTINFO
907 struct iovec msg_iov;
908 struct msghdr msg;
909 char buffer[CMSG_SPACE(sizeof(struct in_pktinfo))];
910 struct cmsghdr *ip_msg = (struct cmsghdr *) buffer;
911 struct in_pktinfo *pki = (struct in_pktinfo *) CMSG_DATA(ip_msg);
912
913 /* cast this to a non-const pointer, since the sendmsg() API
914 * does not provide read-only and write-only flavors of the
915 * structures used for its arguments, but in this case we know
916 * the data will not be modified
917 */
918 msg_iov.iov_base = (char *) data;
919 msg_iov.iov_len = size;
920
921 msg.msg_name = addr_to; /* optional address */
922 msg.msg_namelen = sizeof(struct sockaddr_in); /* size of address */
923 msg.msg_iov = &msg_iov; /* scatter/gather array */
924 msg.msg_iovlen = 1; /* # elements in msg_iov */
925 msg.msg_control = ip_msg; /* ancillary data */
926 msg.msg_controllen = sizeof(buffer); /* ancillary data buffer len */
927 msg.msg_flags = 0; /* flags on received message */
928
929 ip_msg->cmsg_len = CMSG_LEN(sizeof(*pki));
930 ip_msg->cmsg_level = IPPROTO_IP;
931 ip_msg->cmsg_type = IP_PKTINFO;
932 pki->ipi_ifindex = 0; /* Interface index, 0 = use interface specified in routing table */
933 pki->ipi_spec_dst.s_addr = addr_ourip->sin_addr.s_addr; /* Local address */
934 /* pki->ipi_addr = ; Header Destination address - ignored by kernel */
935
936#ifdef DUMP_PACKET
937 if (unistimdebug) {
938 int tmp;
939 ast_verb(0, "\n**> From %s sending %d bytes to %s ***\n",
940 ast_inet_ntoa(addr_ourip->sin_addr), (int) size,
941 ast_inet_ntoa(addr_to->sin_addr));
942 for (tmp = 0; tmp < size; tmp++)
943 ast_verb(0, "%02hhx ", data[tmp]);
944 ast_verb(0, "\n******************************************\n");
945
946 }
947#endif
948
949 if (sendmsg(unistimsock, &msg, 0) == -1) {
950 display_last_error("Error sending datas");
951 }
952#else
953 if (sendto(unistimsock, data, size, 0, (struct sockaddr *) addr_to, sizeof(*addr_to))
954 == -1)
955 display_last_error("Error sending datas");
956#endif
957}
958
959static void send_client(int size, const unsigned char *data, struct unistimsession *pte)
960{
961 unsigned int tick;
962 int buf_pos;
963 unsigned short seq = ntohs(++pte->seq_server);
964
965 ast_mutex_lock(&pte->lock);
966 buf_pos = pte->last_buf_available;
967
968 if (buf_pos >= MAX_BUF_NUMBER) {
969 ast_log(LOG_WARNING, "Error : send queue overflow\n");
970 ast_mutex_unlock(&pte->lock);
971 return;
972 }
973 memcpy((void *)data + sizeof(unsigned short), (void *)&seq, sizeof(unsigned short));
974 pte->wsabufsend[buf_pos].len = size;
975 memcpy(pte->wsabufsend[buf_pos].buf, data, size);
976
977 tick = get_tick_count();
978 pte->timeout = tick + RETRANSMIT_TIMER;
979
980/*#ifdef DUMP_PACKET */
981 if (unistimdebug) {
982 ast_verb(0, "Sending datas with seq #0x%04x Using slot #%d :\n", (unsigned)pte->seq_server, buf_pos);
983 }
984/*#endif */
985 send_raw_client(pte->wsabufsend[buf_pos].len, pte->wsabufsend[buf_pos].buf, &(pte->sin),
986 &(pte->sout));
987 pte->last_buf_available++;
988 ast_mutex_unlock(&pte->lock);
989}
990
991static void send_ping(struct unistimsession *pte)
992{
993 BUFFSEND;
994 if (unistimdebug) {
995 ast_verb(0, "Sending ping\n");
996 }
998 memcpy(buffsend + SIZE_HEADER, packet_send_ping, sizeof(packet_send_ping));
999 send_client(SIZE_HEADER + sizeof(packet_send_ping), buffsend, pte);
1000}
1001
1002static int get_to_address(int fd, struct sockaddr_in *toAddr)
1003{
1004#ifdef HAVE_PKTINFO
1005 int err;
1006 char cmbuf[0x100];
1007 struct cmsghdr *cmsg;
1008 struct sockaddr_in peeraddr;
1009 struct in_addr addr;
1010 struct msghdr mh = {
1011 .msg_name = &peeraddr,
1012 .msg_namelen = sizeof(peeraddr),
1013 .msg_control = cmbuf,
1014 .msg_controllen = sizeof(cmbuf),
1015 };
1016 memset(&addr, 0, sizeof(addr));
1017 /* Get info about the incoming packet */
1018 err = recvmsg(fd, &mh, MSG_PEEK);
1019 if (err == -1) {
1020 ast_log(LOG_WARNING, "recvmsg returned an error: %s\n", strerror(errno));
1021 return err;
1022 }
1023 for(cmsg = CMSG_FIRSTHDR(&mh);
1024 cmsg != NULL;
1025 cmsg = CMSG_NXTHDR(&mh, cmsg))
1026 {
1027 if (cmsg->cmsg_level == IPPROTO_IP && cmsg->cmsg_type == IP_PKTINFO) {
1028 struct in_pktinfo *pkt = (struct in_pktinfo*)CMSG_DATA(cmsg);
1029 addr = pkt->ipi_addr;
1030 if (unistimdebug) {
1031 ast_verb(0, "message received on address %s\n", ast_inet_ntoa(addr));
1032 }
1033 }
1034 }
1035 memcpy(&toAddr->sin_addr, &addr, sizeof(struct in_addr));
1036 return err;
1037#else
1038 memcpy(toAddr, &public_ip, sizeof(*toAddr));
1039 return 0;
1040#endif
1041}
1042
1043
1044/* Allocate memory & initialize structures for a new phone */
1045/* addr_from : ip address of the phone */
1046static struct unistimsession *create_client(const struct sockaddr_in *addr_from)
1047{
1048 int tmp;
1049 struct unistimsession *s;
1050
1051 if (!(s = ast_calloc(1, sizeof(*s))))
1052 return NULL;
1053
1054 memcpy(&s->sin, addr_from, sizeof(struct sockaddr_in));
1055 if (get_to_address(unistimsock, &s->sout) < 0) {
1056 ast_free(s);
1057 return NULL;
1058 }
1059 s->sout.sin_family = AF_INET;
1060 if (unistimdebug) {
1061 ast_verb(0, "Creating a new entry for the phone from %s received via server ip %s\n",
1062 ast_inet_ntoa(addr_from->sin_addr), ast_inet_ntoa(s->sout.sin_addr));
1063 }
1064 ast_mutex_init(&s->lock);
1066 s->next = sessions;
1067 sessions = s;
1068
1070 s->state = STATE_INIT;
1072 /* Initialize struct wsabuf */
1073 for (tmp = 0; tmp < MAX_BUF_NUMBER; tmp++) {
1074 s->wsabufsend[tmp].buf = s->buf[tmp];
1075 }
1077 return s;
1078}
1079
1080static void send_end_call(struct unistimsession *pte)
1081{
1082 BUFFSEND;
1083 if (unistimdebug) {
1084 ast_verb(0, "Sending end call\n");
1085 }
1086 memcpy(buffsend + SIZE_HEADER, packet_send_end_call, sizeof(packet_send_end_call));
1087 send_client(SIZE_HEADER + sizeof(packet_send_end_call), buffsend, pte);
1088}
1089
1090static void set_ping_timer(struct unistimsession *pte)
1091{
1092 unsigned int tick = 0; /* XXX what is this for, anyways */
1093
1094 pte->timeout = pte->tick_next_ping;
1095 DEBUG_TIMER("tick = %u next ping at %u tick\n", tick, pte->timeout);
1096 return;
1097}
1098
1099/* Checking if our send queue is empty,
1100 * if true, setting up a timer for keepalive */
1101static void check_send_queue(struct unistimsession *pte)
1102{
1103 /* Check if our send queue contained only one element */
1104 if (pte->last_buf_available == 1) {
1105 if (unistimdebug) {
1106 ast_verb(0, "Our single packet was ACKed.\n");
1107 }
1108 pte->last_buf_available--;
1109 set_ping_timer(pte);
1110 return;
1111 }
1112 /* Check if this ACK catch up our latest packet */
1113 else if (pte->last_seq_ack + 1 == pte->seq_server + 1) {
1114 if (unistimdebug) {
1115 ast_verb(0, "Our send queue is completely ACKed.\n");
1116 }
1117 pte->last_buf_available = 0; /* Purge the send queue */
1118 set_ping_timer(pte);
1119 return;
1120 }
1121 if (unistimdebug) {
1122 ast_verb(0, "We still have packets in our send queue\n");
1123 }
1124 return;
1125}
1126
1127static void send_start_timer(struct unistimsession *pte)
1128{
1129 BUFFSEND;
1130 if (unistimdebug) {
1131 ast_verb(0, "Sending start timer\n");
1132 }
1133 memcpy(buffsend + SIZE_HEADER, packet_send_start_timer, sizeof(packet_send_start_timer));
1134 send_client(SIZE_HEADER + sizeof(packet_send_start_timer), buffsend, pte);
1135}
1136
1137static void send_stop_timer(struct unistimsession *pte)
1138{
1139 BUFFSEND;
1140 if (unistimdebug) {
1141 ast_verb(0, "Sending stop timer\n");
1142 }
1143 memcpy(buffsend + SIZE_HEADER, packet_send_stop_timer, sizeof(packet_send_stop_timer));
1144 send_client(SIZE_HEADER + sizeof(packet_send_stop_timer), buffsend, pte);
1145}
1146
1147static void send_icon(unsigned char pos, unsigned char status, struct unistimsession *pte)
1148{
1149 BUFFSEND;
1150 if (unistimdebug) {
1151 ast_verb(0, "Sending icon pos %d with status 0x%02hhx\n", pos, status);
1152 }
1153 memcpy(buffsend + SIZE_HEADER, packet_send_icon, sizeof(packet_send_icon));
1154 buffsend[9] = pos;
1155 buffsend[10] = status;
1156 send_client(SIZE_HEADER + sizeof(packet_send_icon), buffsend, pte);
1157}
1158
1159static void send_expansion_next(struct unistimsession *pte)
1160{
1161 BUFFSEND;
1163 send_client(SIZE_HEADER + sizeof(packet_send_expansion_next), buffsend, pte);
1164}
1165
1166
1167static void send_expansion_icon(unsigned char pos, unsigned char status, struct unistimsession *pte)
1168{
1169 BUFFSEND;
1170 if (unistimdebug) {
1171 ast_verb(0, "Sending expansion icon pos %d with status 0x%02hhx\n", pos, status);
1172 }
1174 buffsend[10] = pos;
1175 buffsend[11] = status;
1176 send_client(SIZE_HEADER + sizeof(packet_send_expansion_icon), buffsend, pte);
1177}
1178
1179/* inverse : TEXT_INVERSE : yes, TEXT_NORMAL : no */
1180static void send_expansion_text(unsigned char pos, struct unistimsession *pte, const char *text)
1181{
1182 int i;
1183 BUFFSEND;
1184 if (!text) {
1185 ast_log(LOG_ERROR, "[expansion] Asked to display NULL text (pos %d)\n", pos);
1186 return;
1187 }
1188 if (unistimdebug) {
1189 ast_verb(0, "[expansion] Sending text at pos %d\n", pos);
1190 }
1192 buffsend[10] = pos;
1193 i = strlen(text);
1194 if (i > TEXT_LENGTH_MAX) {
1195 i = TEXT_LENGTH_MAX;
1196 }
1197 memcpy(buffsend + 11, text, i);
1198 send_client(SIZE_HEADER + sizeof(packet_send_expansion_text), buffsend, pte);
1199}
1200
1201static void send_tone(struct unistimsession *pte, uint16_t tone1, uint16_t tone2)
1202{
1203 BUFFSEND;
1204 if (!tone1) {
1205 if (unistimdebug) {
1206 ast_verb(0, "Sending Stream Based Tone Off\n");
1207 }
1211 return;
1212 }
1213 /* Since most of the world use a continuous tone, it's useless
1214 if (unistimdebug)
1215 ast_verb(0, "Sending Stream Based Tone Cadence Download\n");
1216 memcpy (buffsend + SIZE_HEADER, packet_send_StreamBasedToneCad, sizeof (packet_send_StreamBasedToneCad));
1217 send_client (SIZE_HEADER + sizeof (packet_send_StreamBasedToneCad), buffsend, pte); */
1218 if (unistimdebug) {
1219 ast_verb(0, "Sending Stream Based Tone Frequency Component List Download %d %d\n", tone1, tone2);
1220 }
1221 tone1 *= 8;
1222 if (!tone2) {
1225 put_unaligned_uint16(&buffsend[10], htons(tone1));
1227 pte);
1228 } else {
1229 tone2 *= 8;
1232 put_unaligned_uint16(&buffsend[10], htons(tone1));
1233 put_unaligned_uint16(&buffsend[12], htons(tone2));
1235 pte);
1236 }
1237
1238 if (unistimdebug) {
1239 ast_verb(0, "Sending Stream Based Tone On\n");
1240 }
1244}
1245
1246/* Positions for favorites
1247 |--------------------|
1248 | 5 2 | <-- not on screen in i2002
1249 | 4 1 |
1250 | 3 0 |
1251
1252
1253 KEM Positions
1254
1255 |--------------------|
1256 | 12 24 |
1257 | 11 23 |
1258 | 10 22 |
1259 | 9 21 |
1260 | 8 20 |
1261 | 7 19 |
1262 | 6 18 |
1263 | 5 17 |
1264 | 4 16 |
1265 | 3 15 |
1266 | 2 14 |
1267 | 1 13 |
1268
1269*/
1270
1271/* status (icons) : 00 = nothing, 2x/3x = see parser.h, 4x/5x = blink fast, 6x/7x = blink slow */
1272static void
1273send_favorite(unsigned char pos, unsigned char status, struct unistimsession *pte,
1274 const char *text)
1275{
1276 BUFFSEND;
1277 int i;
1278
1279 if (unistimdebug) {
1280 ast_verb(0, "Sending favorite pos %d with status 0x%02hhx\n", pos, status);
1281 }
1282 memcpy(buffsend + SIZE_HEADER, packet_send_favorite, sizeof(packet_send_favorite));
1283 buffsend[10] = pos;
1284 buffsend[24] = pos;
1285 buffsend[25] = status;
1286 i = strlen(ustmtext(text, pte));
1287 if (i > FAV_MAX_LENGTH) {
1288 i = FAV_MAX_LENGTH;
1289 }
1290 memcpy(buffsend + FAV_MAX_LENGTH + 1, ustmtext(text, pte), i);
1291 send_client(SIZE_HEADER + sizeof(packet_send_favorite), buffsend, pte);
1292}
1293
1294static void send_favorite_short(unsigned char pos, unsigned char status, struct unistimsession *pte) {
1295 send_favorite(pos, status, pte, pte->device->softkeylabel[pos]);
1296 return;
1297}
1298
1299static void send_favorite_selected(unsigned char status, struct unistimsession *pte) {
1300 if (pte->device->selected != -1) {
1302 }
1303 return;
1304}
1305
1306static void send_expansion_short(unsigned char pos, unsigned char status, struct unistimsession *pte) {
1307 send_expansion_icon(pos, status, pte);
1308 send_expansion_text(pos, pte, ustmtext(pte->device->expsoftkeylabel[pos], pte));
1310 return;
1311}
1312
1313static int soft_key_visible(struct unistim_device* d, unsigned char num)
1314{
1315 if(d->height == 1 && num % 3 == 2) {
1316 return 0;
1317 }
1318 return 1;
1319}
1320
1321static void refresh_all_favorite(struct unistimsession *pte)
1322{
1323 unsigned char i = 0;
1324 char data[256];
1325 struct unistim_line *line;
1326 line = AST_LIST_FIRST(&pte->device->lines);
1327
1328 if (unistimdebug) {
1329 ast_verb(0, "Refreshing all favorite\n");
1330 }
1331 for (i = 0; i < FAVNUM; i++) {
1332 unsigned char status = pte->device->softkeyicon[i];
1333
1334 if (!soft_key_visible(pte->device, i)) {
1335 continue;
1336 }
1337 if (!strcasecmp(pte->device->softkeylabel[i], "DND") && line) {
1338 if (!ast_db_get("DND", line->name, data, sizeof(data))) {
1340 }
1341 }
1342
1343 send_favorite_short(i, status, pte);
1344 }
1345 if (pte->device->hasexp) {
1346 for (i = 0; i < EXPNUM; i++) {
1348 }
1349 }
1350}
1351
1352static int is_key_favorite(struct unistim_device *d, int fav)
1353{
1354 if ((fav < 0) || (fav >= FAVNUM)) {
1355 return 0;
1356 }
1357 if (d->sline[fav]) {
1358 return 0;
1359 }
1360 if (d->softkeynumber[fav][0] == '\0') {
1361 return 0;
1362 }
1363 return 1;
1364}
1365
1366static int is_key_line(struct unistim_device *d, int fav)
1367{
1368 if ((fav < 0) || (fav >= FAVNUM)) {
1369 return 0;
1370 }
1371 if (!d->sline[fav]) {
1372 return 0;
1373 }
1374 if (is_key_favorite(d, fav)) {
1375 return 0;
1376 }
1377 return 1;
1378}
1379
1380static int get_active_softkey(struct unistimsession *pte)
1381{
1382 return pte->device->selected;
1383}
1384
1385static int get_avail_softkey(struct unistimsession *pte, const char* name)
1386{
1387 int i;
1388
1389 if (!is_key_line(pte->device, pte->device->selected)) {
1390 pte->device->selected = -1;
1391 }
1392 for (i = 0; i < FAVNUM; i++) {
1393 if (pte->device->selected != -1 && pte->device->selected != i) {
1394 continue;
1395 }
1396 if (!soft_key_visible(pte->device, i)) {
1397 continue;
1398 }
1399 if (pte->device->ssub[i]) {
1400 continue;
1401 }
1402 if (is_key_line(pte->device, i)) {
1403 if (name && strcmp(name, pte->device->sline[i]->name)) {
1404 continue;
1405 }
1406 if (unistimdebug) {
1407 ast_verb(0, "Found softkey %d for device %s\n", i, name);
1408 }
1409 return i;
1410 }
1411 }
1412 return -1;
1413}
1414
1415
1416/* Change the status for this phone (pte) and update for each phones where pte is bookmarked
1417 * use FAV_ICON_*_BLACK constant in status parameters */
1418static void change_favorite_icon(struct unistimsession *pte, unsigned char status)
1419{
1420 struct unistim_device *d = devices;
1421 int i;
1422 /* Update the current phone line softkey icon */
1423 if (pte->state != STATE_CLEANING) {
1424 int softkeylinepos = get_active_softkey(pte);
1425 if (softkeylinepos != -1) {
1426 send_favorite_short(softkeylinepos, status, pte);
1427 }
1428 }
1429 /* Notify other phones if we're in their bookmark */
1430 while (d) {
1431 for (i = 0; i < FAVNUM; i++) {
1432 if (d->sp[i] == pte->device) { /* It's us ? */
1433 if (d->softkeyicon[i] != status) { /* Avoid resending the same icon */
1434 d->softkeyicon[i] = status;
1435 if (d->session) {
1436 send_favorite(i, status + 1, d->session, d->softkeylabel[i]);
1437 }
1438 }
1439 }
1440 }
1441 d = d->next;
1442 }
1443}
1444
1445static int register_extension(const struct unistimsession *pte)
1446{
1447 struct unistim_line *line;
1448 line = AST_LIST_FIRST(&pte->device->lines);
1449 if (unistimdebug) {
1450 ast_verb(0, "Trying to register extension '%s' into context '%s' to %s\n",
1452 line->fullname);
1453 }
1454 return ast_add_extension(pte->device->context, 0,
1455 pte->device->extension_number, 1, NULL, NULL, "Dial",
1456 line->fullname, 0, "Unistim");
1457}
1458
1459static int unregister_extension(const struct unistimsession *pte)
1460{
1461 if (unistimdebug) {
1462 ast_verb(0, "Trying to unregister extension '%s' context '%s'\n",
1463 pte->device->extension_number, pte->device->context);
1464 }
1466 pte->device->extension_number, 1, "Unistim");
1467}
1468
1469/* Free memory allocated for a phone */
1470static void close_client(struct unistimsession *s)
1471{
1472 struct unistim_subchannel *sub = NULL;
1473 struct unistimsession *cur, *prev = NULL;
1475 cur = sessions;
1476 /* Looking for the session in the linked chain */
1477 while (cur) {
1478 if (cur == s) {
1479 break;
1480 }
1481 prev = cur;
1482 cur = cur->next;
1483 }
1484 if (cur) { /* Session found ? */
1485 if (cur->device) { /* This session was registered ? */
1486 s->state = STATE_CLEANING;
1487 if (unistimdebug) {
1488 ast_verb(0, "close_client session %p device %p\n", s, s->device);
1489 }
1494 if (!sub) {
1495 continue;
1496 }
1497 if (sub->owner) { /* Call in progress ? */
1498 if (unistimdebug) {
1499 ast_verb(0, "Aborting call\n");
1500 }
1502 } else {
1503 if (unistimdebug) {
1504 ast_debug(1, "Released sub %u of channel %s@%s\n", sub->subtype, sub->parent->name, s->device->name);
1505 }
1508 }
1509 }
1512
1515 }
1516 cur->device->session = NULL;
1518 } else {
1519 if (unistimdebug) {
1520 ast_verb(0, "Freeing an unregistered client\n");
1521 }
1522 }
1523 if (prev) {
1524 prev->next = cur->next;
1525 } else {
1526 sessions = cur->next;
1527 }
1529 ast_free(s);
1530 } else {
1531 ast_log(LOG_WARNING, "Trying to delete non-existent session %p?\n", s);
1532 }
1534 return;
1535}
1536
1537/* Return 1 if the session chained link was modified */
1538static int send_retransmit(struct unistimsession *pte)
1539{
1540 int i;
1541
1542 ast_mutex_lock(&pte->lock);
1543 if (++pte->nb_retransmit >= NB_MAX_RETRANSMIT) {
1544 if (unistimdebug) {
1545 ast_verb(0, "Too many retransmit - freeing client\n");
1546 }
1547 ast_mutex_unlock(&pte->lock);
1548 close_client(pte);
1549 return 1;
1550 }
1552
1553 for (i = pte->last_buf_available - (pte->seq_server - pte->last_seq_ack);
1554 i < pte->last_buf_available; i++) {
1555 if (i < 0) {
1557 "Asked to retransmit an ACKed slot ! last_buf_available=%d, seq_server = #0x%04x last_seq_ack = #0x%04x\n",
1558 pte->last_buf_available, (unsigned)pte->seq_server, (unsigned)pte->last_seq_ack);
1559 continue;
1560 }
1561
1562 if (unistimdebug) {
1563 unsigned short *sbuf = (unsigned short *) pte->wsabufsend[i].buf;
1564 unsigned short seq;
1565
1566 seq = ntohs(sbuf[1]);
1567 ast_verb(0, "Retransmit slot #%d (seq=#0x%04x), last ack was #0x%04x\n", i,
1568 (unsigned)seq, (unsigned)pte->last_seq_ack);
1569 }
1570 send_raw_client(pte->wsabufsend[i].len, pte->wsabufsend[i].buf, &pte->sin,
1571 &pte->sout);
1572 }
1573 ast_mutex_unlock(&pte->lock);
1574 return 0;
1575}
1576
1577/* inverse : TEXT_INVERSE : yes, TEXT_NORMAL : no */
1578static void send_text(unsigned char pos, unsigned char inverse, struct unistimsession *pte,
1579 const char *text)
1580{
1581 int i;
1582 BUFFSEND;
1583 if (!text) {
1584 ast_log(LOG_ERROR, "Asked to display NULL text (pos %d, inverse flag %d)\n", pos, inverse);
1585 return;
1586 }
1587 if (pte->device && pte->device->height == 1 && pos != TEXT_LINE0) {
1588 return;
1589 }
1590 if (unistimdebug) {
1591 ast_verb(0, "Sending text at pos %d, inverse flag %d\n", pos, inverse);
1592 }
1593 memcpy(buffsend + SIZE_HEADER, packet_send_text, sizeof(packet_send_text));
1594 buffsend[10] = pos;
1595 buffsend[11] = inverse;
1596 i = strlen(text);
1597 if (i > TEXT_LENGTH_MAX) {
1598 i = TEXT_LENGTH_MAX;
1599 }
1600 memcpy(buffsend + 12, text, i);
1601 send_client(SIZE_HEADER + sizeof(packet_send_text), buffsend, pte);
1602}
1603
1604static void send_text_status(struct unistimsession *pte, const char *text)
1605{
1606 BUFFSEND;
1607 int i;
1608 if (unistimdebug) {
1609 ast_verb(0, "Sending status text\n");
1610 }
1611 if (pte->device) {
1612 if (pte->device->status_method == 1) { /* For new firmware and i2050 soft phone */
1613 int n = strlen(text);
1614 /* Must send individual button separately */
1615 int j;
1616 for (i = 0, j = 0; i < 4; i++, j += 7) {
1617 int pos = 0x08 + (i * 0x20);
1618 memcpy(buffsend + SIZE_HEADER, packet_send_status2,
1619 sizeof(packet_send_status2));
1620
1621 buffsend[9] = pos;
1622 memcpy(buffsend + 10, (j < n) ? (text + j) : " ", 7);
1623 send_client(SIZE_HEADER + sizeof(packet_send_status2), buffsend, pte);
1624 }
1625 return;
1626 }
1627 }
1628
1629 memcpy(buffsend + SIZE_HEADER, packet_send_status, sizeof(packet_send_status));
1630 i = strlen(text);
1631 if (i > STATUS_LENGTH_MAX) {
1633 }
1634 memcpy(buffsend + 10, text, i);
1635 send_client(SIZE_HEADER + sizeof(packet_send_status), buffsend, pte);
1636
1637}
1638
1639static void send_led_update(struct unistimsession *pte, unsigned char led)
1640{
1641 BUFFSEND;
1642 if (unistimdebug) {
1643 ast_verb(0, "Sending led_update (%x)\n", (unsigned)led);
1644 }
1645 memcpy(buffsend + SIZE_HEADER, packet_send_led_update, sizeof(packet_send_led_update));
1646 buffsend[9] = led;
1647 send_client(SIZE_HEADER + sizeof(packet_send_led_update), buffsend, pte);
1648}
1649
1650static void send_mute(struct unistimsession *pte, unsigned char mute)
1651{
1652/*
1653 0x00 = unmute TX, 0x01 = mute TX
1654 0x20 = unmute RX, 0x21 = mute RX
1655*/
1656 BUFFSEND;
1657 if (unistimdebug) {
1658 ast_verb(0, "Sending mute packet (%x)\n", (unsigned)mute);
1659 }
1660 memcpy(buffsend + SIZE_HEADER, packet_send_mute, sizeof(packet_send_mute));
1661 buffsend[9] = mute;
1662 send_client(SIZE_HEADER + sizeof(packet_send_mute), buffsend, pte);
1663}
1664
1665
1666/* output = OUTPUT_HANDSET, OUTPUT_HEADPHONE or OUTPUT_SPEAKER
1667 * volume = VOLUME_LOW, VOLUME_NORMAL, VOLUME_INSANELY_LOUD
1668 * mute = MUTE_OFF, MUTE_ON */
1669static void
1670send_select_output(struct unistimsession *pte, unsigned char output, unsigned char volume,
1671 unsigned char mute)
1672{
1673 BUFFSEND;
1674 int mute_icon = -1;
1675 if (unistimdebug) {
1676 ast_verb(0, "Sending select output packet output=%x volume=%x mute=%x\n",
1677 (unsigned)output, (unsigned)volume, (unsigned)mute);
1678 }
1679 memcpy(buffsend + SIZE_HEADER, packet_send_select_output,
1681 buffsend[9] = output;
1682 if (output == OUTPUT_SPEAKER && volume == VOLUME_LOW) {
1684 }
1685 buffsend[10] = volume;
1686 if (mute == MUTE_ON_DISCRET) {
1687 buffsend[11] = MUTE_ON;
1688 } else {
1689 buffsend[11] = mute;
1690 }
1691 send_client(SIZE_HEADER + sizeof(packet_send_select_output), buffsend, pte);
1692 if (output == OUTPUT_HANDSET) {
1693 mute_icon = (mute == MUTE_ON) ? FAV_ICON_ONHOLD_BLACK : FAV_ICON_OFFHOOK_BLACK;
1696 } else if (output == OUTPUT_HEADPHONE) {
1700 } else if (output == OUTPUT_SPEAKER) {
1703 if (pte->device->receiver_state == STATE_OFFHOOK) {
1705 } else {
1707 }
1708 } else {
1709 ast_log(LOG_WARNING, "Invalid output (%d)\n", output);
1710 }
1711 if (mute_icon != -1) {
1712 change_favorite_icon(pte, mute_icon);
1713 }
1714 if (output != pte->device->output) {
1715 pte->device->previous_output = pte->device->output;
1716 }
1717 pte->device->output = output;
1718}
1719static void send_ring(struct unistimsession *pte, signed char volume, signed char style)
1720{
1721 BUFFSEND;
1722 if (unistimdebug) {
1723 ast_verb(0, "Sending ring packet\n");
1724 }
1725 memcpy(buffsend + SIZE_HEADER, packet_send_ring, sizeof(packet_send_ring));
1726 buffsend[24] = style + 0x10;
1727 buffsend[29] = volume * 0x10;
1728 send_client(SIZE_HEADER + sizeof(packet_send_ring), buffsend, pte);
1729}
1730
1731static void send_no_ring(struct unistimsession *pte)
1732{
1733 BUFFSEND;
1734 if (unistimdebug) {
1735 ast_verb(0, "Sending no ring packet\n");
1736 }
1737 memcpy(buffsend + SIZE_HEADER, packet_send_no_ring, sizeof(packet_send_no_ring));
1738 send_client(SIZE_HEADER + sizeof(packet_send_no_ring), buffsend, pte);
1739}
1740
1741static void send_texttitle(struct unistimsession *pte, const char *text)
1742{
1743 BUFFSEND;
1744 int i;
1745 if (unistimdebug) {
1746 ast_verb(0, "Sending title text\n");
1747 }
1748 memcpy(buffsend + SIZE_HEADER, packet_send_title, sizeof(packet_send_title));
1749 i = strlen(text);
1750 if (i > 12) {
1751 i = 12;
1752 }
1753 memcpy(buffsend + 10, text, i);
1754 send_client(SIZE_HEADER + sizeof(packet_send_title), buffsend, pte);
1755}
1756
1757static void send_idle_clock(struct unistimsession *pte)
1758{
1759 send_text(TEXT_LINE0, TEXT_NORMAL, pte, "");
1760}
1761
1762static void send_month_labels(struct unistimsession *pte, int month)
1763{
1764 BUFFSEND;
1765 char month_name[MONTH_LABEL_SIZE + 1];
1766 int i = 0;
1767 if (unistimdebug) {
1768 ast_verb(0, "Sending Month Labels\n");
1769 }
1770 month_name[MONTH_LABEL_SIZE] = '\0';
1772 while (i < 2) {
1773 memcpy(month_name, &monthlabels[month * MONTH_LABEL_SIZE], MONTH_LABEL_SIZE);
1774 memcpy(buffsend + SIZE_HEADER + 3 + i*MONTH_LABEL_SIZE, ustmtext(month_name, pte), MONTH_LABEL_SIZE);
1775 ast_log(LOG_WARNING,"%s\n", month_name);
1776 ast_log(LOG_WARNING,"%s\n", ustmtext(month_name, pte));
1777 month = (month + 1)%12;
1778 i++;
1779 }
1781}
1782
1783
1784static void send_date_time(struct unistimsession *pte)
1785{
1786 BUFFSEND;
1787 struct timeval now = ast_tvnow();
1788 struct ast_tm atm = { 0, };
1789
1790 if (unistimdebug) {
1791 ast_verb(0, "Sending Time & Date\n");
1792 }
1793 memcpy(buffsend + SIZE_HEADER, packet_send_date_time, sizeof(packet_send_date_time));
1794 ast_localtime(&now, &atm, NULL);
1795 buffsend[10] = (unsigned char) atm.tm_mon + 1;
1796 buffsend[11] = (unsigned char) atm.tm_mday;
1797 buffsend[12] = (unsigned char) atm.tm_hour;
1798 buffsend[13] = (unsigned char) atm.tm_min;
1799 send_client(SIZE_HEADER + sizeof(packet_send_date_time), buffsend, pte);
1800 send_month_labels(pte, atm.tm_mon);
1801}
1802
1803static void send_date_time2(struct unistimsession *pte)
1804{
1805 BUFFSEND;
1806 struct timeval now = ast_tvnow();
1807 struct ast_tm atm = { 0, };
1808
1809 if (unistimdebug) {
1810 ast_verb(0, "Sending Time & Date #2\n");
1811 }
1812 memcpy(buffsend + SIZE_HEADER, packet_send_date_time2, sizeof(packet_send_date_time2));
1813 ast_localtime(&now, &atm, NULL);
1814 if (pte->device) {
1815 buffsend[9] = pte->device->datetimeformat;
1816 } else {
1817 buffsend[9] = 61;
1818 }
1819 buffsend[14] = (unsigned char) atm.tm_mon + 1;
1820 buffsend[15] = (unsigned char) atm.tm_mday;
1821 buffsend[16] = (unsigned char) atm.tm_hour;
1822 buffsend[17] = (unsigned char) atm.tm_min;
1823 send_client(SIZE_HEADER + sizeof(packet_send_date_time2), buffsend, pte);
1824}
1825
1826static void send_date_time3(struct unistimsession *pte)
1827{
1828 BUFFSEND;
1829 struct timeval now = ast_tvnow();
1830 struct ast_tm atm = { 0, };
1831
1832 if (unistimdebug) {
1833 ast_verb(0, "Sending Time & Date #3\n");
1834 }
1835 memcpy(buffsend + SIZE_HEADER, packet_send_date_time3, sizeof(packet_send_date_time3));
1836 ast_localtime(&now, &atm, NULL);
1837 buffsend[10] = (unsigned char) atm.tm_mon + 1;
1838 buffsend[11] = (unsigned char) atm.tm_mday;
1839 buffsend[12] = (unsigned char) atm.tm_hour;
1840 buffsend[13] = (unsigned char) atm.tm_min;
1841 send_client(SIZE_HEADER + sizeof(packet_send_date_time3), buffsend, pte);
1842}
1843
1844static void send_blink_cursor(struct unistimsession *pte)
1845{
1846 BUFFSEND;
1847 if (unistimdebug) {
1848 ast_verb(0, "Sending set blink\n");
1849 }
1851 send_client(SIZE_HEADER + sizeof(packet_send_blink_cursor), buffsend, pte);
1852 return;
1853}
1854
1855/* pos : 0xab (a=0/2/4 = line ; b = row) */
1856static void send_cursor_pos(struct unistimsession *pte, unsigned char pos)
1857{
1858 BUFFSEND;
1859 if (unistimdebug) {
1860 ast_verb(0, "Sending set cursor position\n");
1861 }
1862 memcpy(buffsend + SIZE_HEADER, packet_send_set_pos_cursor,
1864 buffsend[11] = pos;
1865 send_client(SIZE_HEADER + sizeof(packet_send_set_pos_cursor), buffsend, pte);
1866 return;
1867}
1868
1869static void send_charset_update(struct unistimsession *pte, int charset)
1870{
1871 const unsigned char* packet_send_charset;
1872 int packet_size;
1873 BUFFSEND;
1874 if (unistimdebug) {
1875 ast_verb(0, "Sending set default charset\n");
1876 }
1877 if (charset == LANG_DEFAULT) {
1879 }
1880 switch (charset) {
1881 case ISO_8859_2:
1882 packet_send_charset = packet_send_charset_iso_8859_2;
1883 packet_size = sizeof(packet_send_charset_iso_8859_2);
1884 break;
1885 case ISO_8859_4:
1886 packet_send_charset = packet_send_charset_iso_8859_4;
1887 packet_size = sizeof(packet_send_charset_iso_8859_4);
1888 break;
1889 case ISO_8859_5:
1890 packet_send_charset = packet_send_charset_iso_8859_5;
1891 packet_size = sizeof(packet_send_charset_iso_8859_5);
1892 break;
1893 case ISO_2022_JP:
1894 packet_send_charset = packet_send_charset_iso_2022_jp;
1895 packet_size = sizeof(packet_send_charset_iso_2022_jp);
1896 break;
1897 case ISO_8859_1:
1898 default:
1899 packet_send_charset = packet_send_charset_iso_8859_1;
1900 packet_size = sizeof(packet_send_charset_iso_8859_1);
1901 }
1902 memcpy(buffsend + SIZE_HEADER, packet_send_charset, packet_size);
1903 send_client(SIZE_HEADER + packet_size, buffsend, pte);
1904 return;
1905}
1906
1908{
1909 BUFFSEND;
1910 if (unistimdebug) {
1911 ast_verb(0, "ResumeConnectionWithServer received\n");
1912 ast_verb(0, "Sending packet_send_query_mac_address\n");
1913 }
1914 memcpy(buffsend + SIZE_HEADER, packet_send_query_mac_address,
1916 send_client(SIZE_HEADER + sizeof(packet_send_query_mac_address), buffsend, pte);
1917 return;
1918}
1919
1921{
1922 struct unistim_device *d;
1923
1925 d = devices;
1926 while (d) {
1927 if (!strcasecmp(s->macaddr, d->id)) {
1928 /* XXX Deal with IP authentication */
1929 s->device = d;
1930 d->session = s;
1931 d->codec_number = DEFAULT_CODEC;
1932 d->missed_call = 0;
1933 d->receiver_state = STATE_ONHOOK;
1934 break;
1935 }
1936 d = d->next;
1937 }
1939
1940 if (!d) {
1941 return 0;
1942 }
1943
1944 return 1;
1945}
1946
1947static void unistim_line_copy(struct unistim_line *dst, struct unistim_line *src)
1948{
1949 struct ast_format_cap *tmp = src->cap;
1950 memcpy(dst, src, sizeof(*dst)); /* this over writes the cap ptr, so we have to reset it */
1951 src->cap = tmp;
1953}
1954
1956{
1957 if (!l) {
1958 return NULL;
1959 }
1960 ao2_ref(l->cap, -1);
1961 ast_free(l);
1962 return NULL;
1963}
1964
1966{
1967 struct unistim_line *l;
1968 if (!(l = ast_calloc(1, sizeof(*l)))) {
1969 return NULL;
1970 }
1971
1973 ast_free(l);
1974 return NULL;
1975 }
1976 return l;
1977}
1978
1980 if (unistimdebug) {
1981 ast_debug(1, "Released sub %u of channel %s@%s\n", sub->subtype, sub->parent->name, sub->parent->parent->name);
1982 }
1983 ast_mutex_destroy(&sub->lock);
1984 ast_free(sub);
1985 return 0;
1986}
1987
1989{
1990 struct unistim_subchannel *sub;
1991 if (!(sub = ast_calloc(1, sizeof(*sub)))) {
1992 return NULL;
1993 }
1994
1995 if (unistimdebug) {
1996 ast_verb(3, "Allocating UNISTIM subchannel #%d on %s ptr=%p\n", x, d->name, sub);
1997 }
1998 sub->ss_thread = AST_PTHREADT_NULL;
1999 sub->subtype = x;
2000 AST_LIST_LOCK(&d->subs);
2001 AST_LIST_INSERT_TAIL(&d->subs, sub, list);
2002 AST_LIST_UNLOCK(&d->subs);
2003 ast_mutex_init(&sub->lock);
2004 return sub;
2005}
2006
2008{
2009 struct unistim_subchannel *s;
2010
2011 AST_LIST_LOCK(&d->subs);
2012 AST_LIST_TRAVERSE_SAFE_BEGIN(&d->subs, s, list) {
2013 if (!s) {
2014 continue;
2015 }
2016 if (s != sub) {
2017 continue;
2018 }
2021 }
2023 AST_LIST_UNLOCK(&d->subs);
2024 return 0;
2025}
2026
2027static const char *subtype_tostr(const int type)
2028{
2029 switch (type) {
2030 case SUB_REAL:
2031 return "REAL";
2032 case SUB_RING:
2033 return "RINGING";
2034 case SUB_THREEWAY:
2035 return "THREEWAY";
2036 }
2037 return "UNKNOWN";
2038}
2039
2040static const char *ptestate_tostr(const int type)
2041{
2042 switch (type) {
2043 case STATE_INIT:
2044 return "INIT";
2045 case STATE_AUTHDENY:
2046 return "AUTHDENY";
2047 case STATE_MAINPAGE:
2048 return "MAINPAGE";
2049 case STATE_EXTENSION:
2050 return "EXTENSION";
2051 case STATE_DIALPAGE:
2052 return "DIALPAGE";
2053 case STATE_RINGING:
2054 return "RINGING";
2055 case STATE_CALL:
2056 return "CALL";
2057 case STATE_SELECTOPTION:
2058 return "SELECTOPTION";
2059 case STATE_SELECTCODEC:
2060 return "SELECTCODEC";
2062 return "SELECTLANGUAGE";
2063 case STATE_CLEANING:
2064 return "CLEARING";
2065 case STATE_HISTORY:
2066 return "HISTORY";
2067 }
2068 return "UNKNOWN";
2069}
2070
2071static void rcv_mac_addr(struct unistimsession *pte, const unsigned char *buf)
2072{
2073 BUFFSEND;
2074 int tmp, i = 0;
2075 char addrmac[19];
2076 int res = 0;
2077 for (tmp = 15; tmp < 15 + SIZE_HEADER; tmp++) {
2078 sprintf(&addrmac[i], "%02hhx", buf[tmp]);
2079 i += 2;
2080 }
2081 if (unistimdebug) {
2082 ast_verb(0, "MAC Address received: %s\n", addrmac);
2083 }
2084 strcpy(pte->macaddr, addrmac);
2085 res = unistim_register(pte);
2086 if (!res) {
2087 switch (autoprovisioning) {
2089 ast_log(LOG_WARNING, "No entry found for this phone : %s\n", addrmac);
2090 pte->state = STATE_AUTHDENY;
2091 break;
2093 {
2094 struct unistim_device *d = NULL, *newd = NULL;
2095 struct unistim_line *newl = NULL, *l = NULL;
2096 if (unistimdebug) {
2097 ast_verb(0, "New phone, autoprovisioning on\n");
2098 }
2099 /* First : locate the [template] section */
2101 d = devices;
2102 while (d) {
2103 if (strcasecmp(d->name, "template")) {
2104 d = d->next;
2105 continue;
2106 }
2107 /* Found, cloning this entry */
2108 if (!(newd = ast_malloc(sizeof(*newd)))) {
2110 return;
2111 }
2112 memcpy(newd, d, sizeof(*newd));
2113 ast_mutex_init(&newd->lock);
2114 newd->lines.first = NULL;
2115 newd->lines.last = NULL;
2116 AST_LIST_LOCK(&d->lines);
2117 AST_LIST_TRAVERSE(&d->lines, l, list) {
2118 if (!(newl = unistim_line_alloc())) {
2119 break;
2120 }
2121 unistim_line_copy(l, newl);
2122 newl->parent = newd;
2123 ast_copy_string(newl->name, l->name, sizeof(newl->name));
2124 snprintf(newl->fullname, sizeof(newl->fullname), "USTM/%s@%s",
2125 newl->name, newd->name);
2126 snprintf(l->name, sizeof(l->name), "%d", atoi(l->name) + 1);
2127
2128 AST_LIST_LOCK(&newd->lines);
2129 AST_LIST_INSERT_TAIL(&newd->lines, newl, list);
2130 AST_LIST_UNLOCK(&newd->lines);
2131 }
2132 AST_LIST_UNLOCK(&d->lines);
2133 if (!newl) {
2134 ast_free(newd);
2136 }
2137
2138 /* Ok, now updating some fields */
2139 ast_copy_string(newd->id, addrmac, sizeof(newd->id));
2140 ast_copy_string(newd->name, addrmac, sizeof(newd->name));
2141 if (newd->extension == EXTENSION_NONE) {
2142 newd->extension = EXTENSION_ASK;
2143 }
2144
2145 newd->receiver_state = STATE_ONHOOK;
2146 newd->session = pte;
2147 newd->language[0] = '\0';
2148 newd->to_delete = -1;
2149 newd->next = NULL;
2150 pte->device = newd;
2151
2152 /* Go to the end of the linked chain */
2153 while (d->next) {
2154 d = d->next;
2155 }
2156 d->next = newd;
2157 d = newd;
2158 break;
2159 }
2161 if (!d) {
2162 ast_log(LOG_WARNING, "No entry [template] found in unistim.conf\n");
2163 pte->state = STATE_AUTHDENY;
2164 }
2165 }
2166 break;
2168 pte->state = STATE_AUTHDENY;
2169 break;
2170 default:
2171 ast_log(LOG_WARNING, "Internal error : unknown autoprovisioning value = %u\n",
2173 }
2174 }
2175 if (pte->state != STATE_AUTHDENY) {
2176 struct unistim_line *line;
2177 struct unistim_subchannel *sub;
2178
2179 ast_verb(3, "Device '%s' successfuly registered\n", pte->device->name);
2180
2181 AST_LIST_LOCK(&pte->device->subs);
2183 if (sub) {
2184 ast_log(LOG_ERROR, "Subchannel lost sice reboot. Hanged channel may apear!\n");
2186 ast_free(sub);
2187 }
2188 }
2190 AST_LIST_UNLOCK(&pte->device->subs);
2191
2192 switch (pte->device->extension) {
2193 case EXTENSION_NONE:
2194 pte->state = STATE_MAINPAGE;
2195 break;
2196 case EXTENSION_ASK:
2197 /* Checking if we already have an extension number */
2199 pte->state = STATE_EXTENSION;
2200 } else {
2201 /* Yes, because of a phone reboot. We don't ask again for the TN */
2202 if (register_extension(pte)) {
2203 pte->state = STATE_EXTENSION;
2204 } else {
2205 pte->state = STATE_MAINPAGE;
2206 }
2207 }
2208 break;
2209 case EXTENSION_LINE:
2210 line = AST_LIST_FIRST(&pte->device->lines);
2212 sizeof(pte->device->extension_number));
2213 if (register_extension(pte)) {
2214 pte->state = STATE_EXTENSION;
2215 } else {
2216 pte->state = STATE_MAINPAGE;
2217 }
2218 break;
2219 case EXTENSION_TN:
2220 /* If we are here, it's because of a phone reboot */
2221 pte->state = STATE_MAINPAGE;
2222 break;
2223 default:
2224 ast_log(LOG_WARNING, "Internal error, extension value unknown : %u\n",
2225 pte->device->extension);
2226 pte->state = STATE_AUTHDENY;
2227 break;
2228 }
2229 }
2230 if (pte->state == STATE_EXTENSION) {
2231 if (pte->device->extension != EXTENSION_TN) {
2233 }
2234 pte->device->extension_number[0] = '\0';
2235 }
2236 if (unistimdebug) {
2237 ast_verb(0, "\nSending S1\n");
2238 }
2239 memcpy(buffsend + SIZE_HEADER, packet_send_S1, sizeof(packet_send_S1));
2240 send_client(SIZE_HEADER + sizeof(packet_send_S1), buffsend, pte);
2241
2242 if (unistimdebug) {
2243 ast_verb(0, "Sending query_basic_manager_04\n");
2244 }
2248
2249 if (unistimdebug) {
2250 ast_verb(0, "Sending query_basic_manager_10\n");
2251 }
2255
2256 send_date_time(pte);
2257 return;
2258}
2259
2260static int write_entry_history(struct unistimsession *pte, FILE * f, char c, char *line1)
2261{
2262 if (fwrite(&c, 1, 1, f) != 1) {
2263 display_last_error("Unable to write history log header.");
2264 return -1;
2265 }
2266 if (fwrite(line1, TEXT_LENGTH_MAX, 1, f) != 1) {
2267 display_last_error("Unable to write history entry - date.");
2268 return -1;
2269 }
2270 if (fwrite(pte->device->lst_cid, TEXT_LENGTH_MAX, 1, f) != 1) {
2271 display_last_error("Unable to write history entry - callerid.");
2272 return -1;
2273 }
2274 if (fwrite(pte->device->lst_cnm, TEXT_LENGTH_MAX, 1, f) != 1) {
2275 display_last_error("Unable to write history entry - callername.");
2276 return -1;
2277 }
2278 return 0;
2279}
2280
2281static int write_history(struct unistimsession *pte, char way, char ismissed)
2282{
2284 char line1[TEXT_LENGTH_MAX + 1];
2285 char count = 0, *histbuf;
2286 int size;
2287 FILE *f, *f2;
2288 struct timeval now = ast_tvnow();
2289 struct ast_tm atm = { 0, };
2290
2291 if (!pte->device) {
2292 return -1;
2293 }
2294 if (!pte->device->callhistory) {
2295 return 0;
2296 }
2297 if (strchr(pte->device->name, '/') || (pte->device->name[0] == '.')) {
2298 ast_log(LOG_WARNING, "Account code '%s' insecure for writing file\n",
2299 pte->device->name);
2300 return -1;
2301 }
2302
2303 snprintf(tmp, sizeof(tmp), "%s/%s", ast_config_AST_LOG_DIR, USTM_LOG_DIR);
2304 if (ast_mkdir(tmp, 0770)) {
2305 ast_log(LOG_WARNING, "Unable to create directory for history\n");
2306 return -1;
2307 }
2308
2309 ast_localtime(&now, &atm, NULL);
2310 if (ismissed) {
2311 if (way == 'i') {
2312 ast_copy_string(tmp2, ustmtext("Miss", pte), sizeof(tmp2));
2313 } else {
2314 ast_copy_string(tmp2, ustmtext("Fail", pte), sizeof(tmp2));
2315 }
2316 } else {
2317 ast_copy_string(tmp2, ustmtext("Answ", pte), sizeof(tmp2));
2318 }
2319 snprintf(line1, sizeof(line1), "%04d/%02d/%02d %02d:%02d:%02d %s",
2320 atm.tm_year + 1900, atm.tm_mon + 1, atm.tm_mday, atm.tm_hour,
2321 atm.tm_min, atm.tm_sec, tmp2);
2322
2323 snprintf(tmp, sizeof(tmp), "%s/%s/%s-%c.csv", ast_config_AST_LOG_DIR,
2324 USTM_LOG_DIR, pte->device->name, way);
2325 if ((f = fopen(tmp, "r"))) {
2326 struct stat bufstat;
2327
2328 if (stat(tmp, &bufstat)) {
2329 display_last_error("Unable to stat history log.");
2330 fclose(f);
2331 return -1;
2332 }
2333 size = 1 + (MAX_ENTRY_LOG * TEXT_LENGTH_MAX * 3);
2334 if (bufstat.st_size != size) {
2336 "History file %s has an incorrect size (%d instead of %d). It will be replaced by a new one.",
2337 tmp, (int) bufstat.st_size, size);
2338 fclose(f);
2339 f = NULL;
2340 count = 1;
2341 }
2342 }
2343
2344 /* If we can't open the log file, we create a brand new one */
2345 if (!f) {
2346 char c = 1;
2347 int i;
2348
2349 if ((errno != ENOENT) && (count == 0)) {
2350 display_last_error("Unable to open history log.");
2351 return -1;
2352 }
2353 f = fopen(tmp, "w");
2354 if (!f) {
2355 display_last_error("Unable to create history log.");
2356 return -1;
2357 }
2358 if (write_entry_history(pte, f, c, line1)) {
2359 fclose(f);
2360 return -1;
2361 }
2362 memset(line1, ' ', TEXT_LENGTH_MAX);
2363 for (i = 3; i < MAX_ENTRY_LOG * 3; i++) {
2364 if (fwrite(line1, TEXT_LENGTH_MAX, 1, f) != 1) {
2365 display_last_error("Unable to write history entry - stuffing.");
2366 fclose(f);
2367 return -1;
2368 }
2369 }
2370 if (fclose(f)) {
2371 display_last_error("Unable to close history - creation.");
2372 }
2373 return 0;
2374 }
2375 /* We can open the log file, we create a temporary one, we add our entry and copy the rest */
2376 if (fread(&count, 1, 1, f) != 1) {
2377 display_last_error("Unable to read history header.");
2378 fclose(f);
2379 return -1;
2380 }
2381 if (count > MAX_ENTRY_LOG) {
2382 ast_log(LOG_WARNING, "Invalid count in history header of %s (%d max %d)\n", tmp,
2383 count, MAX_ENTRY_LOG);
2384 fclose(f);
2385 return -1;
2386 }
2387 snprintf(tmp2, sizeof(tmp2), "%s/%s/%s-%c.csv.tmp", ast_config_AST_LOG_DIR,
2388 USTM_LOG_DIR, pte->device->name, way);
2389 if (!(f2 = fopen(tmp2, "w"))) {
2390 display_last_error("Unable to create temporary history log.");
2391 fclose(f);
2392 return -1;
2393 }
2394
2395 if (++count > MAX_ENTRY_LOG) {
2396 count = MAX_ENTRY_LOG;
2397 }
2398 if (write_entry_history(pte, f2, count, line1)) {
2399 fclose(f);
2400 fclose(f2);
2401 return -1;
2402 }
2403 size = (MAX_ENTRY_LOG - 1) * TEXT_LENGTH_MAX * 3;
2404 if (!(histbuf = ast_malloc(size))) {
2405 fclose(f);
2406 fclose(f2);
2407 return -1;
2408 }
2409
2410 if (fread(histbuf, size, 1, f) != 1) {
2411 ast_free(histbuf);
2412 fclose(f);
2413 fclose(f2);
2414 display_last_error("Unable to read previous history entries.");
2415 return -1;
2416 }
2417 if (fwrite(histbuf, size, 1, f2) != 1) {
2418 ast_free(histbuf);
2419 fclose(f);
2420 fclose(f2);
2421 display_last_error("Unable to write previous history entries.");
2422 return -1;
2423 }
2424 ast_free(histbuf);
2425 if (fclose(f)) {
2426 display_last_error("Unable to close history log.");
2427 }
2428 if (fclose(f2)) {
2429 display_last_error("Unable to close temporary history log.");
2430 }
2431 if (unlink(tmp)) {
2432 display_last_error("Unable to remove old history log.");
2433 }
2434 if (rename(tmp2, tmp)) {
2435 display_last_error("Unable to rename new history log.");
2436 }
2437 return 0;
2438}
2439
2441{
2442 RAII_VAR(struct ast_channel *, chana, NULL, ast_channel_unref);
2443 RAII_VAR(struct ast_channel *, chanb, NULL, ast_channel_unref);
2444
2445 if (!p1->owner || !p2->owner) {
2446 ast_log(LOG_WARNING, "Transfer attempted without dual ownership?\n");
2447 return -1;
2448 }
2449 chana = ast_channel_ref(p1->owner);
2450 chanb = ast_channel_ref(p2->owner);
2451
2452 switch (ast_bridge_transfer_attended(chana, chanb)) {
2454 ast_log(LOG_WARNING, "Transfer failed. Invalid bridge setup\n");
2455 break;
2457 ast_log(LOG_WARNING, "Transfer not permitted\n");
2458 break;
2460 ast_log(LOG_WARNING, "Transfer encountered internal error\n");
2461 break;
2463 return 0;
2464 }
2465
2466 /* Control only reaches this point if transfer has failed */
2469 return -1;
2470}
2471
2472void change_callerid(struct unistimsession *pte, int type, char *callerid)
2473{
2474 char *data;
2475 int size;
2476
2477 if (type) {
2478 data = pte->device->lst_cnm;
2479 } else {
2480 data = pte->device->lst_cid;
2481 }
2482
2483 /* This is very nearly strncpy(), except that the remaining buffer
2484 * is padded with ' ', instead of '\0' */
2485 memset(data, ' ', TEXT_LENGTH_MAX);
2486 size = strlen(callerid);
2487 if (size > TEXT_LENGTH_MAX) {
2488 size = TEXT_LENGTH_MAX;
2489 }
2490 memcpy(data, callerid, size);
2491}
2492
2493static struct unistim_subchannel* get_sub(struct unistim_device *device, int type)
2494{
2495 struct unistim_subchannel *sub = NULL;
2496
2497 AST_LIST_LOCK(&device->subs);
2498 AST_LIST_TRAVERSE(&device->subs, sub, list) {
2499 if (!sub) {
2500 continue;
2501 }
2502 if (sub->subtype == type) {
2503 break;
2504 }
2505 }
2506 AST_LIST_UNLOCK(&device->subs);
2507
2508 return sub;
2509}
2510
2511static struct unistim_subchannel* get_sub_holding(struct unistim_device *device, int type, int holding)
2512{
2513 struct unistim_subchannel *sub = NULL;
2514
2515 AST_LIST_LOCK(&device->subs);
2516 AST_LIST_TRAVERSE(&device->subs, sub, list) {
2517 if (!sub) {
2518 continue;
2519 }
2520 if (sub->subtype == type && sub->holding == holding) {
2521 break;
2522 }
2523 }
2524 AST_LIST_UNLOCK(&device->subs);
2525
2526 return sub;
2527}
2528
2530{
2531 /* Silence our channel */
2532 if (!pte->device->silence_generator) {
2535 if (pte->device->silence_generator == NULL) {
2536 ast_log(LOG_WARNING, "Unable to start a silence generator.\n");
2537 } else if (unistimdebug) {
2538 ast_verb(0, "Starting silence generator\n");
2539 }
2540 }
2541
2542}
2543
2545{
2546 /* Stop the silence generator */
2547 if (pte->device->silence_generator) {
2548 if (unistimdebug) {
2549 ast_verb(0, "Stopping silence generator\n");
2550 }
2551 if (sub->owner) {
2553 } else {
2554 ast_log(LOG_WARNING, "Trying to stop silence generator on a null channel!\n");
2555 }
2557 }
2558}
2559
2560static void sub_hold(struct unistimsession *pte, struct unistim_subchannel *sub)
2561{
2562 if (!sub) {
2563 return;
2564 }
2565 sub->moh = 1;
2566 sub->holding = 1;
2569 send_stop_timer(pte);
2570 if (sub->owner) {
2571 ast_queue_hold(sub->owner, NULL);
2572 }
2573 return;
2574}
2575
2576static void sub_unhold(struct unistimsession *pte, struct unistim_subchannel *sub)
2577{
2578 struct unistim_subchannel *sub_real;
2579
2580 sub_real = get_sub(pte->device, SUB_REAL);
2581 if (sub_real) {
2582 sub_hold(pte, sub_real);
2583 }
2584
2585 sub->moh = 0;
2586 sub->holding = 0;
2589 send_start_timer(pte);
2590 if (sub->owner) {
2591 ast_queue_unhold(sub->owner);
2592 if (sub->rtp) {
2594 }
2595 }
2596 return;
2597}
2598
2599static void close_call(struct unistimsession *pte)
2600{
2601 struct unistim_subchannel *sub, *sub_transf;
2602
2603 sub = get_sub(pte->device, SUB_REAL);
2604 sub_transf = get_sub(pte->device, SUB_THREEWAY);
2605 send_stop_timer(pte);
2606 if (!sub) {
2607 ast_log(LOG_WARNING, "Close call without sub\n");
2608 return;
2609 }
2610 send_favorite_short(sub->softkey, FAV_LINE_ICON, pte);
2611 if (sub->owner) {
2612 sub->alreadygone = 1;
2613 if (sub_transf) {
2614 sub_transf->alreadygone = 1;
2615 if (attempt_transfer(sub, sub_transf) < 0) {
2616 ast_verb(0, "attempt_transfer failed.\n");
2617 }
2618 } else {
2619 ast_queue_hangup(sub->owner);
2620 }
2621 } else {
2622 if (sub_transf) {
2623 if (sub_transf->owner) {
2625 } else {
2626 ast_log(LOG_WARNING, "threeway sub without owner\n");
2627 }
2628 } else {
2629 ast_verb(0, "USTM(%s@%s-%d) channel already destroyed\n", sub->parent->name,
2630 pte->device->name, sub->softkey);
2631 }
2632 }
2633 change_callerid(pte, 0, pte->device->redial_number);
2634 change_callerid(pte, 1, "");
2635 write_history(pte, 'o', pte->device->missed_call);
2636 pte->device->missed_call = 0;
2637 show_main_page(pte);
2638 return;
2639}
2640
2641static void ignore_call(struct unistimsession *pte)
2642{
2643 send_no_ring(pte);
2644 return;
2645}
2646
2647static void discard_call(struct unistimsession *pte)
2648{
2649 struct unistim_subchannel* sub;
2650 sub = get_sub(pte->device, SUB_RING);
2651 if (!sub) {
2652 return;
2653 }
2654
2656 return;
2657}
2658
2659static void *unistim_ss(void *data)
2660{
2661 struct ast_channel *chan = data;
2663 struct unistim_line *l = sub->parent;
2664 struct unistimsession *s = l->parent->session;
2665 int res;
2666
2667 if (!s) {
2668 return NULL;
2669 }
2670 ast_verb(3, "Starting switch on '%s@%s-%d' to %s\n", l->name, l->parent->name, sub->softkey, s->device->phone_number);
2671 ast_channel_lock(chan);
2674 ast_channel_unlock(chan);
2676 sizeof(s->device->redial_number));
2677 res = ast_pbx_run(chan);
2678 if (res) {
2679 ast_log(LOG_WARNING, "PBX exited non-zero\n");
2680 send_tone(s, 1000, 0);
2681 }
2682 return NULL;
2683}
2684
2686{
2687 struct unistim_subchannel *sub = NULL;
2688 int rtp_start = s->parent->parent->rtp_port;
2689 struct ast_sockaddr us_tmp;
2690 struct sockaddr_in us = { 0, };
2691
2693 AST_LIST_TRAVERSE(&s->parent->parent->subs, sub, list) {
2694 if (!sub) {
2695 continue;
2696 }
2697 if (sub->rtp) {
2699 ast_sockaddr_to_sin(&us_tmp, &us);
2700 if (htons(us.sin_port)) {
2701 rtp_start = htons(us.sin_port) + 1;
2702 break;
2703 }
2704 }
2705 }
2707 return rtp_start;
2708}
2709
2711{
2712 BUFFSEND;
2713
2714 int codec;
2715 struct sockaddr_in public = { 0, };
2716 struct sockaddr_in us = { 0, };
2717 struct sockaddr_in sin = { 0, };
2718 struct ast_sockaddr us_tmp;
2719 struct ast_sockaddr sin_tmp;
2720 struct unistimsession *pte;
2721
2723 ast_sockaddr_to_sin(&us_tmp, &us);
2725 ast_sockaddr_to_sin(&sin_tmp, &sin);
2726
2727 /* Setting up RTP of the phone */
2728 if (public_ip.sin_family == 0) { /* NAT IP override ? */
2729 memcpy(&public, &us, sizeof(public)); /* No defined, using IP from recvmsg */
2730 } else {
2731 memcpy(&public, &public_ip, sizeof(public)); /* override */
2732 }
2733 if (unistimdebug) {
2734 ast_verb(0, "RTP started : Our IP/port is : %s:%hd with codec %s\n",
2735 ast_inet_ntoa(us.sin_addr),
2736 htons(us.sin_port), ast_format_get_name(ast_channel_readformat(sub->owner)));
2737 ast_verb(0, "Starting phone RTP stack. Our public IP is %s\n",
2738 ast_inet_ntoa(public.sin_addr));
2739 }
2740
2741 pte = sub->parent->parent->session;
2743 1, ast_channel_readformat(sub->owner), 0);
2746 if (unistimdebug) {
2747 ast_verb(0, "Sending packet_send_rtp_packet_size for codec %d\n", codec);
2748 }
2749 memcpy(buffsend + SIZE_HEADER, packet_send_rtp_packet_size,
2751 buffsend[10] = (int) codec & 0xffffffffLL;
2752 send_client(SIZE_HEADER + sizeof(packet_send_rtp_packet_size), buffsend, pte);
2753 }
2754 if (unistimdebug) {
2755 ast_verb(0, "Sending Jitter Buffer Parameters Configuration\n");
2756 }
2759 send_client(SIZE_HEADER + sizeof(packet_send_jitter_buffer_conf), buffsend, pte);
2760 if (pte->device->rtp_method != 0) {
2761 uint16_t rtcpsin_port = ntohs(us.sin_port) + 1; /* RTCP port is RTP + 1 */
2762
2763 if (unistimdebug) {
2764 ast_verb(0, "Sending OpenAudioStreamTX using method #%d\n", pte->device->rtp_method);
2765 }
2766 if (pte->device->rtp_method == 3) {
2769 } else {
2772 }
2773 if (pte->device->rtp_method != 2) {
2774 memcpy(buffsend + 28, &public.sin_addr, sizeof(public.sin_addr));
2775 put_unaligned_uint16(&buffsend[20], sin.sin_port);
2776 put_unaligned_uint16(&buffsend[22], htons(rtcpsin_port));
2777 put_unaligned_uint16(&buffsend[24], us.sin_port);
2778 put_unaligned_uint16(&buffsend[26], htons(rtcpsin_port));
2779 } else {
2780 memcpy(buffsend + 23, &public.sin_addr, sizeof(public.sin_addr));
2781 put_unaligned_uint16(&buffsend[15], sin.sin_port);
2782 put_unaligned_uint16(&buffsend[19], us.sin_port);
2783 }
2784 buffsend[11] = codec; /* rx */
2785 buffsend[12] = codec; /* tx */
2787
2788 if (unistimdebug) {
2789 ast_verb(0, "Sending OpenAudioStreamRX\n");
2790 }
2791 if (pte->device->rtp_method == 3) {
2794 } else {
2797 }
2798 if (pte->device->rtp_method != 2) {
2799 memcpy(buffsend + 28, &public.sin_addr, sizeof(public.sin_addr));
2800 put_unaligned_uint16(&buffsend[20], sin.sin_port);
2801 put_unaligned_uint16(&buffsend[22], htons(rtcpsin_port));
2802 put_unaligned_uint16(&buffsend[24], us.sin_port);
2803 put_unaligned_uint16(&buffsend[26], htons(rtcpsin_port));
2804 } else {
2805 memcpy(buffsend + 23, &public.sin_addr, sizeof(public.sin_addr));
2806 put_unaligned_uint16(&buffsend[15], sin.sin_port);
2807 put_unaligned_uint16(&buffsend[19], us.sin_port);
2808 }
2809 buffsend[11] = codec; /* rx */
2810 buffsend[12] = codec; /* tx */
2812 } else {
2813 uint16_t rtcpsin_port = htons(us.sin_port) + 1; /* RTCP port is RTP + 1 */
2814
2815 if (unistimdebug) {
2816 ast_verb(0, "Sending packet_send_call default method\n");
2817 }
2818
2819 memcpy(buffsend + SIZE_HEADER, packet_send_call, sizeof(packet_send_call));
2820 memcpy(buffsend + 53, &public.sin_addr, sizeof(public.sin_addr));
2821 /* Destination port when sending RTP */
2822 put_unaligned_uint16(&buffsend[49], us.sin_port);
2823 /* Destination port when sending RTCP */
2824 put_unaligned_uint16(&buffsend[51], htons(rtcpsin_port));
2825 /* Codec */
2826 buffsend[40] = codec;
2827 buffsend[41] = codec;
2829 buffsend[42] = 1; /* 1 = 20ms (160 bytes), 2 = 40ms (320 bytes) */
2831 buffsend[42] = 1; /* 1 = 20ms (160 bytes), 2 = 40ms (320 bytes) */
2833 buffsend[42] = 2; /* 1 = 30ms (24 bytes), 2 = 60 ms (48 bytes) */
2835 buffsend[42] = 2; /* 1 = 10ms (10 bytes), 2 = 20ms (20 bytes) */
2836 } else {
2837 ast_log(LOG_WARNING, "Unsupported codec %s!\n",
2839 }
2840 /* Source port for transmit RTP and Destination port for receiving RTP */
2841 put_unaligned_uint16(&buffsend[45], sin.sin_port);
2842 put_unaligned_uint16(&buffsend[47], htons(rtcpsin_port));
2843 send_client(SIZE_HEADER + sizeof(packet_send_call), buffsend, pte);
2844 }
2845}
2846
2848{
2849 struct sockaddr_in sin = { 0, };
2850 struct sockaddr_in sout = { 0, };
2851 struct ast_sockaddr sin_tmp;
2852 struct ast_sockaddr sout_tmp;
2853
2854 /* Sanity checks */
2855 if (!sub) {
2856 ast_log(LOG_WARNING, "start_rtp with a null subchannel !\n");
2857 return;
2858 }
2859 if (!sub->parent) {
2860 ast_log(LOG_WARNING, "start_rtp with a null line!\n");
2861 return;
2862 }
2863 if (!sub->parent->parent) {
2864 ast_log(LOG_WARNING, "start_rtp with a null device!\n");
2865 return;
2866 }
2867 if (!sub->parent->parent->session) {
2868 ast_log(LOG_WARNING, "start_rtp with a null session!\n");
2869 return;
2870 }
2871 if (!sub->owner) {
2872 ast_log(LOG_WARNING, "start_rtp with a null asterisk channel!\n");
2873 return;
2874 }
2875 sout = sub->parent->parent->session->sout;
2876 ast_mutex_lock(&sub->lock);
2877 /* Allocate the RTP */
2878 if (unistimdebug) {
2879 ast_verb(0, "Starting RTP. Bind on %s\n", ast_inet_ntoa(sout.sin_addr));
2880 }
2881 ast_sockaddr_from_sin(&sout_tmp, &sout);
2882 sub->rtp = ast_rtp_instance_new("asterisk", sched, &sout_tmp, NULL);
2883 if (!sub->rtp) {
2884 ast_log(LOG_WARNING, "Unable to create RTP session: %s binaddr=%s\n",
2885 strerror(errno), ast_inet_ntoa(sout.sin_addr));
2886 ast_mutex_unlock(&sub->lock);
2887 return;
2888 }
2893 ast_rtp_instance_set_qos(sub->rtp, qos.tos_audio, qos.cos_audio, "UNISTIM RTP");
2894 ast_rtp_instance_set_prop(sub->rtp, AST_RTP_PROPERTY_NAT, sub->parent->parent->nat);
2895
2896 /* Create the RTP connection */
2897 sin.sin_family = AF_INET;
2898 /* Setting up RTP for our side */
2899 memcpy(&sin.sin_addr, &sub->parent->parent->session->sin.sin_addr,
2900 sizeof(sin.sin_addr));
2901
2902 sin.sin_port = htons(find_rtp_port(sub));
2903 ast_sockaddr_from_sin(&sin_tmp, &sin);
2906 struct ast_format *tmpfmt;
2908
2911 "Our read/writeformat has been changed to something incompatible: %s, using %s best codec from %s\n",
2913 ast_format_get_name(tmpfmt),
2915
2916 ast_channel_set_readformat(sub->owner, tmpfmt);
2917 ast_channel_set_writeformat(sub->owner, tmpfmt);
2918 ao2_ref(tmpfmt, -1);
2919 }
2921 ast_mutex_unlock(&sub->lock);
2922}
2923
2924static void send_dial_tone(struct unistimsession *pte)
2925{
2926 struct ast_tone_zone_sound *ts = NULL;
2927 struct ast_tone_zone_part tone_data;
2928 char *s = NULL;
2929 char *ind;
2930
2931 if ((ts = ast_get_indication_tone(pte->device->tz, "dial"))) {
2932 ind = ast_strdupa(ts->data);
2933 s = strsep(&ind, ",");
2934 ast_tone_zone_part_parse(s, &tone_data);
2935 send_tone(pte, tone_data.freq1, tone_data.freq2);
2936 if (unistimdebug) {
2937 ast_verb(0, "Country code found (%s), freq1=%u freq2=%u\n",
2938 pte->device->tz->country, tone_data.freq1, tone_data.freq2);
2939 }
2941 }
2942}
2943
2944static void show_phone_number(struct unistimsession *pte)
2945{
2946 char tmp[TEXT_LENGTH_MAX + 1];
2947 const char *tmp_number = ustmtext("Number:", pte);
2948 int line, tmp_copy, offset = 0, i;
2949
2950 pte->device->phone_number[pte->device->size_phone_number] = '\0';
2952 offset = pte->device->size_phone_number - MAX_SCREEN_NUMBER - 1;
2953 if (offset > strlen(tmp_number)) {
2954 offset = strlen(tmp_number);
2955 }
2956 tmp_copy = strlen(tmp_number) - offset + 1;
2957 if (tmp_copy > sizeof(tmp)) {
2958 tmp_copy = sizeof(tmp);
2959 }
2960 memcpy(tmp, tmp_number + offset, tmp_copy);
2961 } else {
2962 ast_copy_string(tmp, tmp_number, sizeof(tmp));
2963 }
2964
2965 offset = (pte->device->size_phone_number >= TEXT_LENGTH_MAX) ? (pte->device->size_phone_number - TEXT_LENGTH_MAX +1) : 0;
2966 if (pte->device->size_phone_number) {
2967 memcpy(tmp + strlen(tmp), pte->device->phone_number + offset, pte->device->size_phone_number - offset + 1);
2968 }
2969 offset = strlen(tmp);
2970
2971 for (i = strlen(tmp); i < TEXT_LENGTH_MAX; i++) {
2972 tmp[i] = '.';
2973 }
2974 tmp[i] = '\0';
2975
2976 line = (pte->device->height == 1) ? TEXT_LINE0 : TEXT_LINE2;
2977 send_text(line, TEXT_NORMAL, pte, tmp);
2978 send_blink_cursor(pte);
2979 send_cursor_pos(pte, (unsigned char) (line + offset));
2981}
2982
2983static void handle_dial_page(struct unistimsession *pte)
2984{
2985 pte->state = STATE_DIALPAGE;
2986 if (pte->device->call_forward[0] == -1) {
2987 send_text(TEXT_LINE0, TEXT_NORMAL, pte, "");
2988 send_text(TEXT_LINE1, TEXT_NORMAL, pte, ustmtext("Enter forward", pte));
2989 send_text_status(pte, ustmtext("Fwd Cancel BackSp Erase", pte));
2990 if (pte->device->call_forward[1] != 0) {
2992 sizeof(pte->device->phone_number));
2993 show_phone_number(pte);
2995 return;
2996 }
2997 } else {
2998 if ((pte->device->output == OUTPUT_HANDSET) &&
2999 (pte->device->receiver_state == STATE_ONHOOK)) {
3001 } else {
3003 }
3004 send_dial_tone(pte);
3005
3006 if (pte->device->height > 1) {
3007 send_text(TEXT_LINE0, TEXT_NORMAL, pte, ustmtext("Enter the number to dial", pte));
3008 send_text(TEXT_LINE1, TEXT_NORMAL, pte, ustmtext("and press Call", pte));
3009 }
3011 send_text_status(pte, ustmtext("Call BackSp Erase", pte));
3012 } else {
3013 send_text_status(pte, ustmtext("Call Redial BackSp Erase", pte));
3014 }
3015 }
3016
3017 pte->device->size_phone_number = 0;
3018 pte->device->phone_number[0] = 0;
3019 show_phone_number(pte);
3022 pte->device->missed_call = 0;
3024 pte->device->lastmsgssent = -1;
3025 return;
3026}
3027
3029{
3030 struct ast_rtp_instance *rtp;
3031 int fds;
3032
3033 if (unistimdebug) {
3034 ast_verb(0, "Swapping %p and %p\n", a, b);
3035 }
3036 if ((!a->owner) || (!b->owner)) {
3038 "Attempted to swap subchannels with a null owner : sub #%p=%p sub #%p=%p\n",
3039 a, a->owner, b, b->owner);
3040 return;
3041 }
3042 rtp = a->rtp;
3043 a->rtp = b->rtp;
3044 b->rtp = rtp;
3045
3046 fds = ast_channel_fd(a->owner, 0);
3047 ast_channel_internal_fd_set(a->owner, 0, ast_channel_fd(b->owner, 0));
3048 ast_channel_internal_fd_set(b->owner, 0, fds);
3049
3050 fds = ast_channel_fd(a->owner, 1);
3051 ast_channel_internal_fd_set(a->owner, 1, ast_channel_fd(b->owner, 1));
3052 ast_channel_internal_fd_set(b->owner, 1, fds);
3053}
3054
3055/* Step 1 : Music On Hold for peer, Dialing screen for us */
3056static void transfer_call_step1(struct unistimsession *pte)
3057{
3058 struct unistim_subchannel *sub /*, *sub_trans */;
3059 struct unistim_device *d = pte->device;
3060
3061 sub = get_sub(d, SUB_REAL);
3062 /* sub_trans = get_sub(d, SUB_THREEWAY); */
3063
3064 if (!sub || !sub->owner) {
3065 ast_log(LOG_WARNING, "Unable to find subchannel for music on hold\n");
3066 return;
3067 }
3068 /* Start music on hold if appropriate */
3069 if (sub->moh) {
3070 ast_log(LOG_WARNING, "Transfer with peer already listening music on hold\n");
3071 } else {
3072 ast_queue_hold(sub->owner, sub->parent->musicclass);
3073 sub->moh = 1;
3074 sub->subtype = SUB_THREEWAY;
3075 }
3076 sub_start_silence(pte, sub);
3077 handle_dial_page(pte);
3078}
3079
3081{
3082 struct unistim_subchannel *sub, *sub_trans;
3083 struct unistim_device *d = pte->device;
3084
3085 sub = get_sub(d, SUB_REAL);
3086 sub_trans = get_sub(d, SUB_THREEWAY);
3087
3088 if (!sub || !sub->owner) {
3089 ast_log(LOG_WARNING, "Unable to find subchannel for music on hold\n");
3090 return;
3091 }
3092 if (sub_trans) {
3093 if (unistimdebug) {
3094 ast_verb(0, "Transfer canceled, hangup our threeway channel\n");
3095 }
3096 if (sub->owner) {
3097 swap_subs(sub, sub_trans);
3098 ast_queue_unhold(sub_trans->owner);
3099 sub_trans->moh = 0;
3100 sub_trans->subtype = SUB_REAL;
3101 sub->subtype = SUB_THREEWAY;
3103 } else {
3104 ast_log(LOG_WARNING, "Canceling a threeway channel without owner\n");
3105 }
3106 return;
3107 }
3108}
3109
3110/* From phone to PBX */
3112{
3113 struct ast_channel *c;
3114 struct unistim_subchannel *sub;
3115 int softkey;
3116
3117 s->state = STATE_CALL;
3118
3120 if (sub) {
3121 /* If sub for threway call created than we use transfer behavior */
3122 struct unistim_subchannel *sub_trans = NULL;
3123 struct unistim_device *d = s->device;
3124
3125 sub_trans = get_sub(d, SUB_REAL);
3126 if (sub_trans) {
3127 ast_log(LOG_WARNING, "Can't transfer while active subchannel exists!\n");
3128 return;
3129 }
3130 if (!sub->owner) {
3131 ast_log(LOG_WARNING, "Unable to find subchannel with music on hold\n");
3132 return;
3133 }
3134
3135 sub_trans = unistim_alloc_sub(d, SUB_REAL);
3136 if (!sub_trans) {
3137 ast_log(LOG_WARNING, "Unable to allocate three-way subchannel\n");
3138 return;
3139 }
3140 sub_trans->parent = sub->parent;
3142 send_tone(s, 0, 0);
3143 /* Make new channel */
3144 c = unistim_new(sub_trans, AST_STATE_DOWN, NULL, NULL);
3145 if (!c) {
3146 ast_log(LOG_WARNING, "Cannot allocate new structure on channel %p\n", sub->parent);
3147 return;
3148 }
3149 /* Swap things around between the three-way and real call */
3150 swap_subs(sub, sub_trans);
3152 if (s->device->height == 1) {
3154 } else {
3155 send_text(TEXT_LINE0, TEXT_NORMAL, s, ustmtext("Calling (pre-transfer)", s));
3157 send_text(TEXT_LINE2, TEXT_NORMAL, s, ustmtext("Dialing...", s));
3158 }
3159 send_text_status(s, ustmtext("TransfrCancel", s));
3160
3161 if (ast_pthread_create(&sub->ss_thread, NULL, unistim_ss, c)) {
3162 ast_log(LOG_WARNING, "Unable to start simple switch on channel %p\n", c);
3163 sub->ss_thread = AST_PTHREADT_NULL;
3164 ast_hangup(c);
3165 return;
3166 }
3167 if (unistimdebug) {
3168 ast_verb(0, "Started three way call on channel %p (%s) subchan %u\n",
3169 sub_trans->owner, ast_channel_name(sub_trans->owner), sub_trans->subtype);
3170 }
3171 return;
3172 }
3173
3174 softkey = get_avail_softkey(s, NULL);
3175 if (softkey == -1) {
3176 ast_log(LOG_WARNING, "Have no avail softkey for calling\n");
3177 return;
3178 }
3179 sub = get_sub(s->device, SUB_REAL);
3180 if (sub) { /* have already call assigned */
3181 sub_hold(s, sub); /* Need to put on hold */
3182 }
3183 if (!(sub = unistim_alloc_sub(s->device, SUB_REAL))) {
3184 ast_log(LOG_WARNING, "Unable to allocate subchannel!\n");
3185 return;
3186 }
3187 sub->parent = s->device->sline[softkey];
3188 s->device->ssub[softkey] = sub;
3189 sub->softkey = softkey;
3190
3191 if (unistimdebug) {
3192 ast_verb(0, "Using softkey %d, line %p\n", sub->softkey, sub->parent);
3193 }
3195 s->device->selected = -1;
3196 if (!sub->owner) { /* A call is already in progress ? */
3197 RAII_VAR(struct ast_features_pickup_config *, pickup_cfg, NULL, ao2_cleanup);
3198 const char *pickupexten;
3199
3200 c = unistim_new(sub, AST_STATE_DOWN, NULL, NULL); /* No, starting a new one */
3201 if (!sub->rtp) { /* Need to start RTP before calling ast_pbx_run */
3202 start_rtp(sub);
3203 }
3204 if (c) {
3207 if (!pickup_cfg) {
3208 ast_log(LOG_ERROR, "Unable to retrieve pickup configuration options. Unable to detect call pickup extension\n");
3209 pickupexten = "";
3210 } else {
3211 pickupexten = ast_strdupa(pickup_cfg->pickupexten);
3212 }
3214 }
3215 if (c && !strcmp(s->device->phone_number, pickupexten)) {
3216 if (unistimdebug) {
3217 ast_verb(0, "Try to pickup in unistim_new\n");
3218 }
3220 send_text_status(s, ustmtext(" Transf Hangup", s));
3222 if (ast_pickup_call(c)) {
3223 ast_log(LOG_NOTICE, "Nothing to pick up\n");
3225 } else {
3227 }
3228 ast_hangup(c);
3229 c = NULL;
3230 } else if (c) {
3232 send_tone(s, 0, 0); /* Dialing empty number should also stop dial tone */
3233 if (s->device->height == 1) {
3234 if (strlen(s->device->phone_number) > 0) {
3236 } else {
3237 send_text(TEXT_LINE0, TEXT_NORMAL, s, ustmtext("Calling...", s));
3238 }
3239 } else {
3240 send_text(TEXT_LINE0, TEXT_NORMAL, s, ustmtext("Calling :", s));
3242 send_text(TEXT_LINE2, TEXT_NORMAL, s, ustmtext("Dialing...", s));
3243 }
3244 send_text_status(s, ustmtext(" Hangup", s));
3245
3246 /* start switch */
3247 if (ast_pthread_create(&sub->ss_thread, NULL, unistim_ss, c)) {
3248 ast_log(LOG_WARNING, "Unable to create switch thread\n");
3249 sub->ss_thread = AST_PTHREADT_NULL;
3251 }
3252 } else
3253 ast_log(LOG_WARNING, "Unable to create channel for %s@%s\n",
3254 sub->parent->name, s->device->name);
3255 } else {
3256 ast_debug(1, "Current sub [%s] already has owner\n", ast_channel_name(sub->owner));
3257 }
3258 return;
3259}
3260
3261/* From PBX to phone */
3263{
3264 struct unistim_subchannel *sub = NULL;
3265 int i;
3266
3267 s->state = STATE_CALL;
3268 s->device->missed_call = 0;
3269 send_no_ring(s);
3270 sub = get_sub(s->device, SUB_RING); /* Put other SUB_REAL call on hold */
3271 if (!sub) {
3272 ast_log(LOG_WARNING, "No ringing lines on: %s\n", s->device->name);
3273 return;
3274 }
3275 /* Change icons for all ringing keys */
3276 for (i = 0; i < FAVNUM; i++) {
3277 if (!s->device->ssub[i]) { /* No sub assigned - skip */
3278 continue;
3279 }
3280 if (s->device->ssub[i]->subtype == SUB_REAL) {
3281 sub_hold(s, s->device->ssub[i]);
3282 }
3283 if (s->device->ssub[i] != sub) {
3284 continue;
3285 }
3286 if (sub->softkey == i) { /* If softkey assigned at this moment - do not erase */
3287 continue;
3288 }
3289 if (sub->softkey < 0) { /* If softkey not defined - first one used */
3290 sub->softkey = i;
3291 continue;
3292 }
3294 s->device->ssub[i] = NULL;
3295 }
3296 if (sub->softkey < 0) {
3297 ast_log(LOG_WARNING, "Can not assign softkey for incoming call on: %s\n", s->device->name);
3298 return;
3299 }
3301 sub->parent = s->device->sline[sub->softkey];
3302 sub->subtype = SUB_REAL;
3303 if (unistimdebug) {
3304 ast_verb(0, "Handle Call Incoming for %s@%s\n", sub->parent->name,
3305 s->device->name);
3306 }
3307 start_rtp(sub);
3308 if (!sub->rtp) {
3309 ast_log(LOG_WARNING, "Unable to create channel for %s@%s\n", sub->parent->name, s->device->name);
3310 return;
3311 }
3312 if (sub->owner) {
3314 }
3315 send_text(TEXT_LINE2, TEXT_NORMAL, s, ustmtext("is on-line", s));
3316 send_text_status(s, ustmtext(" Transf Hangup", s));
3318
3319 if ((s->device->output == OUTPUT_HANDSET) &&
3322 } else {
3324 }
3325 write_history(s, 'i', 0);
3326 return;
3327}
3328
3329static int send_dtmf_tone(struct unistimsession *pte, char digit)
3330{
3331 int row, col;
3332
3333 if (unistimdebug) {
3334 ast_verb(0, "Phone Play Digit %c\n", digit);
3335 }
3336 if (pte->device->dtmfduration > 0) {
3337 row = (digit - '1') % 3;
3338 col = (digit - '1' - row) / 3;
3339 if (digit >= '1' && digit <='9') {
3340 send_tone(pte, dtmf_row[row], dtmf_col[col]);
3341 } else if (digit >= 'A' && digit <= 'D') {
3342 send_tone(pte, dtmf_row[digit-'A'], dtmf_col[3]);
3343 } else if (digit == '*') {
3344 send_tone(pte, dtmf_row[3], dtmf_col[0]);
3345 } else if (digit == '0') {
3346 send_tone(pte, dtmf_row[3], dtmf_col[1]);
3347 } else if (digit == '#') {
3348 send_tone(pte, dtmf_row[3], dtmf_col[2]);
3349 } else {
3350 send_tone(pte, 500, 2000);
3351 }
3352 }
3353 return 0;
3354}
3355
3356static int unistim_do_senddigit(struct unistimsession *pte, char digit)
3357{
3358 struct ast_frame f = { .frametype = AST_FRAME_DTMF, .subclass.integer = digit, .src = "unistim" };
3359 struct unistim_subchannel *sub;
3360
3361 sub = get_sub(pte->device, SUB_REAL);
3362 if (!sub || !sub->owner || sub->alreadygone) {
3363 ast_log(LOG_WARNING, "Unable to find subchannel in dtmf senddigit\n");
3364 return -1;
3365 }
3366
3367 /* Send DTMF indication _before_ playing sounds */
3368 ast_queue_frame(sub->owner, &f);
3369 if (pte->device->dtmfduration > 0) {
3370 if (unistimdebug) {
3371 ast_verb(0, "Send Digit %c (%i ms)\n", digit, pte->device->dtmfduration);
3372 }
3373 send_dtmf_tone(pte, digit);
3374 usleep(pte->device->dtmfduration * 1000); /* XXX Less than perfect, blocking an important thread is not a good idea */
3375 send_tone(pte, 0, 0);
3376 }
3377 return 0;
3378}
3379
3380static void handle_key_fav(struct unistimsession *pte, char keycode)
3381{
3382 int keynum = keycode - KEY_FAV0;
3383 struct unistim_subchannel *sub, *sub_key = NULL;
3384 sub = get_sub_holding(pte->device, SUB_REAL, 0);
3385
3386 /* Make an action on selected favorite key */
3387 if (!pte->device->ssub[keynum]) { /* Key have no assigned call */
3388 sub = get_sub_holding(pte->device, SUB_REAL, 0);
3390 if (is_key_line(pte->device, keynum)) {
3391 if (unistimdebug) {
3392 ast_verb(0, "Handle line w/o sub - dialpage\n");
3393 }
3394 pte->device->selected = keynum;
3395 sub_hold(pte, sub); /* Put active call on hold */
3396 send_stop_timer(pte);
3397 handle_dial_page(pte);
3398 } else if (is_key_favorite(pte->device, keynum)) {
3399 /* Put active call on hold in handle_call_outgoing function, after preparation and
3400 checking if lines available for calling */
3401 if (unistimdebug) {
3402 ast_verb(0, "Handle favorite w/o sub - dialing\n");
3403 }
3404 if ((pte->device->output == OUTPUT_HANDSET) &&
3405 (pte->device->receiver_state == STATE_ONHOOK)) {
3407 } else {
3409 }
3410 key_favorite(pte, keycode);
3411 }
3412 } else {
3413 sub_key = pte->device->ssub[keynum];
3414 /* Favicon have assigned sub, activate it and put current on hold */
3415 if (sub_key->subtype == SUB_REAL && !sub_key->holding) {
3416 sub_hold(pte, sub_key);
3417 show_main_page(pte);
3418 } else if (sub_key->subtype == SUB_REAL && sub_key->holding) {
3419 /* We are going to unhold line (we should put active line on hold, of any) */
3420 if (pte->state == STATE_DIALPAGE){
3421 send_tone(pte, 0, 0);
3422 }
3423 sub_hold(pte, sub);
3424 send_callerid_screen(pte, sub_key);
3425 sub_unhold(pte, sub_key);
3426 pte->state = STATE_CALL;
3427 } else if (sub_key->subtype == SUB_RING) {
3428 sub_hold(pte, sub);
3429 sub_key->softkey = keynum;
3431 }
3432 }
3433}
3434
3435static void key_call(struct unistimsession *pte, char keycode)
3436{
3437 struct unistim_subchannel *sub = get_sub(pte->device, SUB_REAL);
3438 struct unistim_subchannel *sub_3way = get_sub(pte->device, SUB_THREEWAY);
3439
3440 if (!sub) {
3441 return;
3442 }
3443 if ((keycode >= KEY_0) && (keycode <= KEY_SHARP)) {
3444 if (keycode == KEY_SHARP) {
3445 keycode = '#';
3446 } else if (keycode == KEY_STAR) {
3447 keycode = '*';
3448 } else {
3449 keycode -= 0x10;
3450 }
3451 unistim_do_senddigit(pte, keycode);
3452 return;
3453 }
3454 switch (keycode) {
3455 case KEY_FUNC1:
3456 if (sub->owner && ast_channel_state(sub->owner) == AST_STATE_UP) {
3457 if (sub_3way) {
3458 close_call(pte);
3459 }
3460 }
3461 break;
3462 case KEY_FUNC2:
3463 if (sub_3way) {
3465 } else if (ast_channel_state(sub->owner) == AST_STATE_UP) {
3467 }
3468 break;
3469 case KEY_HANGUP:
3470 case KEY_FUNC4:
3471 if (!sub_3way) {
3472 close_call(pte);
3473 }
3474 break;
3475 case KEY_FAV0:
3476 case KEY_FAV1:
3477 case KEY_FAV2:
3478 case KEY_FAV3:
3479 case KEY_FAV4:
3480 case KEY_FAV5:
3481 handle_key_fav(pte, keycode);
3482 break;
3483 case KEY_HEADPHN:
3484 if (pte->device->output == OUTPUT_HEADPHONE) {
3486 } else {
3488 }
3489 break;
3490 case KEY_LOUDSPK:
3491 if (pte->device->output != OUTPUT_SPEAKER)
3493 else
3495 MUTE_OFF);
3496 break;
3497 case KEY_ONHOLD:
3498 if (!sub) {
3499 if(pte->device->ssub[pte->device->selected]) {
3500 sub = pte->device->ssub[pte->device->selected];
3501 } else {
3502 break;
3503 }
3504 }
3505 if (sub->holding) {
3506 sub_unhold(pte, sub);
3507 } else {
3508 sub_hold(pte, sub);
3509 }
3510 break;
3511 }
3512 return;
3513}
3514
3515static void key_ringing(struct unistimsession *pte, char keycode)
3516{
3517 switch (keycode) {
3518 case KEY_FAV0:
3519 case KEY_FAV1:
3520 case KEY_FAV2:
3521 case KEY_FAV3:
3522 case KEY_FAV4:
3523 case KEY_FAV5:
3524 handle_key_fav(pte, keycode);
3525 break;
3526 case KEY_FUNC3:
3527 ignore_call(pte);
3528 break;
3529 case KEY_HANGUP:
3530 case KEY_FUNC4:
3531 discard_call(pte);
3532 break;
3533 case KEY_LOUDSPK:
3536 break;
3537 case KEY_HEADPHN:
3540 break;
3541 case KEY_FUNC1:
3543 break;
3544 }
3545 return;
3546}
3547
3548static void key_favorite(struct unistimsession *pte, char keycode)
3549{
3550 int fav = keycode - KEY_FAV0;
3551 if (!is_key_favorite(pte->device, fav)) {
3552 ast_log(LOG_WARNING, "It's not a favorite key\n");
3553 return;
3554 }
3556 sizeof(pte->device->phone_number));
3558 return;
3559}
3560
3561static void key_dial_page(struct unistimsession *pte, char keycode)
3562{
3564
3565 pte->device->nextdial = 0;
3566 if (keycode == KEY_FUNC3) {
3567 if (pte->device->size_phone_number <= 1) {
3568 keycode = KEY_FUNC4;
3569 } else {
3570 pte->device->size_phone_number -= 2;
3571 keycode = pte->device->phone_number[pte->device->size_phone_number] + 0x10;
3572 }
3573 }
3574 if (keycode == KEY_SHARP && pte->device->sharp_dial == 1) {
3575 keycode = KEY_FUNC1;
3576 }
3577 if ((keycode >= KEY_0) && (keycode <= KEY_SHARP)) {
3578 int i = pte->device->size_phone_number;
3579
3580 if (pte->device->size_phone_number == 0) {
3581 send_tone(pte, 0, 0);
3582 }
3583 if (keycode == KEY_SHARP) {
3584 keycode = '#';
3585 } else if (keycode == KEY_STAR) {
3586 keycode = '*';
3587 } else {
3588 keycode -= 0x10;
3589 }
3590 pte->device->phone_number[i] = keycode;
3591 pte->device->size_phone_number++;
3592 pte->device->phone_number[i + 1] = 0;
3593 show_phone_number(pte);
3594
3597 keycode = KEY_FUNC1;
3598 } else {
3599 if (pte->device->interdigit_timer) {
3601 }
3602 }
3603 }
3604 if (keycode == KEY_FUNC4) {
3605 pte->device->size_phone_number = 0;
3606 show_phone_number(pte);
3607 return;
3608 }
3609
3610 if (pte->device->call_forward[0] == -1) {
3611 if (keycode == KEY_FUNC1) {
3613 sizeof(pte->device->call_forward));
3614 show_main_page(pte);
3615 } else if ((keycode == KEY_FUNC2) || (keycode == KEY_HANGUP)) {
3616 pte->device->call_forward[0] = '\0';
3619 show_main_page(pte);
3620 }
3621 return;
3622 }
3623 switch (keycode) {
3624 case KEY_FUNC2:
3626 break;
3627 }
3629 sizeof(pte->device->phone_number));
3630 case KEY_FUNC1:
3632 break;
3633 case KEY_HANGUP:
3634 if (sub && sub->owner) {
3635 sub_stop_silence(pte, sub);
3636 send_tone(pte, 0, 0);
3637 ast_queue_unhold(sub->owner);
3638 sub->moh = 0;
3639 sub->subtype = SUB_REAL;
3640 pte->state = STATE_CALL;
3641
3642 send_text_status(pte, ustmtext(" Transf Hangup", pte));
3644 } else {
3647 show_main_page(pte);
3648 }
3649 break;
3650 case KEY_FAV0:
3651 case KEY_FAV1:
3652 case KEY_FAV2:
3653 case KEY_FAV3:
3654 case KEY_FAV4:
3655 case KEY_FAV5:
3657 pte->device->selected = -1;
3658 handle_key_fav(pte, keycode);
3659 break;
3660 case KEY_LOUDSPK:
3661 if (pte->device->output == OUTPUT_SPEAKER) {
3662 if (pte->device->receiver_state == STATE_OFFHOOK) {
3664 MUTE_OFF);
3665 } else {
3666 show_main_page(pte);
3667 }
3668 } else {
3670 }
3671 break;
3672 case KEY_HEADPHN:
3673 if (pte->device->output == OUTPUT_HEADPHONE) {
3674 if (pte->device->receiver_state == STATE_OFFHOOK) {
3676 } else {
3677 show_main_page(pte);
3678 }
3679 } else {
3681 }
3682 break;
3683 }
3684 return;
3685}
3686
3687static void handle_select_option(struct unistimsession *pte)
3688{
3689 char tmp[128];
3690
3691 if (pte->state != STATE_SELECTOPTION) {
3693 pte->size_buff_entry = 1;
3694 pte->buff_entry[0] = 0; /* Position in menu */
3695 }
3696 snprintf(tmp, sizeof(tmp), "%d. %s", pte->buff_entry[0] + 1, ustmtext(options_menu[(int)pte->buff_entry[0]].label, pte));
3698 send_text_status(pte, ustmtext("Select Cancel", pte));
3699 return;
3700}
3701
3702static void key_select_option(struct unistimsession *pte, char keycode)
3703{
3704 switch (keycode) {
3705 case KEY_DOWN:
3706 pte->buff_entry[0]++;
3707 if (options_menu[(int)pte->buff_entry[0]].label == NULL) {
3708 pte->buff_entry[0]--;
3709 }
3710 break;
3711 case KEY_UP:
3712 if (pte->buff_entry[0] > 0) {
3713 pte->buff_entry[0]--;
3714 }
3715 break;
3716 case KEY_FUNC1:
3717 options_menu[(int)pte->buff_entry[0]].handle_option(pte);
3718 return;
3719 case KEY_HANGUP:
3720 case KEY_FUNC4:
3721 show_main_page(pte);
3722 return;
3723 }
3724
3726 return;
3727}
3728
3729#define SELECTCODEC_START_ENTRY_POS 15
3730#define SELECTCODEC_MAX_LENGTH 2
3731#define SELECTCODEC_MSG "Codec number : .."
3732static void handle_select_codec(struct unistimsession *pte)
3733{
3734 char buf[30], buf2[6];
3735
3736 pte->state = STATE_SELECTCODEC;
3737 ast_copy_string(buf, ustmtext("Using codec", pte), sizeof(buf));
3738 snprintf(buf2, sizeof(buf2), " %d", pte->device->codec_number);
3739 strcat(buf, buf2);
3740 strcat(buf, " (G711u=0,");
3741
3743 send_text(TEXT_LINE1, TEXT_NORMAL, pte, "G723=4,G711a=8,G729A=18)");
3745 send_blink_cursor(pte);
3747 pte->size_buff_entry = 0;
3748 send_text_status(pte, ustmtext("Select BackSp Erase Cancel", pte));
3749 return;
3750}
3751
3752static void key_select_codec(struct unistimsession *pte, char keycode)
3753{
3754 if (keycode == KEY_FUNC2) {
3755 if (pte->size_buff_entry <= 1) {
3756 keycode = KEY_FUNC3;
3757 } else {
3758 pte->size_buff_entry -= 2;
3759 keycode = pte->buff_entry[pte->size_buff_entry] + 0x10;
3760 }
3761 }
3762 if ((keycode >= KEY_0) && (keycode <= KEY_9)) {
3763 char tmpbuf[] = SELECTCODEC_MSG;
3764 int i = 0;
3765
3767 return;
3768 }
3769 while (i < pte->size_buff_entry) {
3770 tmpbuf[i + SELECTCODEC_START_ENTRY_POS] = pte->buff_entry[i];
3771 i++;
3772 }
3773 tmpbuf[i + SELECTCODEC_START_ENTRY_POS] = keycode - 0x10;
3774 pte->buff_entry[i] = keycode - 0x10;
3775 pte->size_buff_entry++;
3776 send_text(TEXT_LINE2, TEXT_INVERSE, pte, tmpbuf);
3777 send_blink_cursor(pte);
3778 send_cursor_pos(pte,
3779 (unsigned char) (TEXT_LINE2 + SELECTCODEC_START_ENTRY_POS + 1 + i));
3780 return;
3781 }
3782
3783 switch (keycode) {
3784 case KEY_FUNC1:
3785 if (pte->size_buff_entry == 1) {
3786 pte->device->codec_number = pte->buff_entry[0] - 48;
3787 } else if (pte->size_buff_entry == 2) {
3788 pte->device->codec_number =
3789 ((pte->buff_entry[0] - 48) * 10) + (pte->buff_entry[1] - 48);
3790 }
3791 show_main_page(pte);
3792 break;
3793 case KEY_FUNC3:
3794 pte->size_buff_entry = 0;
3796 send_blink_cursor(pte);
3798 break;
3799 case KEY_HANGUP:
3800 case KEY_FUNC4:
3801 show_main_page(pte);
3802 break;
3803 }
3804 return;
3805}
3806
3807static int find_language(const char* lang)
3808{
3809 int i = 0;
3810 while (options_languages[i].lang_short != NULL) {
3811 if(!strcmp(options_languages[i].lang_short, lang)) {
3812 return i;
3813 }
3814 i++;
3815 }
3816 return 0;
3817}
3818
3820{
3821 char tmp_language[40];
3822 struct unistim_languages lang;
3823
3824 if (pte->state != STATE_SELECTLANGUAGE) {
3826 pte->size_buff_entry = 1;
3827 pte->buff_entry[0] = find_language(pte->device->language);
3828 }
3829 lang = options_languages[(int)pte->buff_entry[0]];
3830 ast_copy_string(tmp_language, pte->device->language, sizeof(tmp_language));
3831 ast_copy_string(pte->device->language, lang.lang_short, sizeof(pte->device->language));
3832 send_charset_update(pte, lang.encoding);
3833 send_text(TEXT_LINE0, TEXT_NORMAL, pte, ustmtext(lang.label, pte));
3834
3835 ast_copy_string(pte->device->language, tmp_language, sizeof(pte->device->language));
3837 send_charset_update(pte, lang.encoding);
3838 send_text_status(pte, ustmtext("Select Cancel", pte));
3839 return;
3840}
3841
3842static void key_select_language(struct unistimsession *pte, char keycode)
3843{
3844 switch (keycode) {
3845 case KEY_DOWN:
3846 pte->buff_entry[0]++;
3847 if (options_languages[(int)pte->buff_entry[0]].label == NULL) {
3848 pte->buff_entry[0]--;
3849 }
3850 break;
3851 case KEY_UP:
3852 if (pte->buff_entry[0] > 0) {
3853 pte->buff_entry[0]--;
3854 }
3855 break;
3856 case KEY_FUNC1:
3860 show_main_page(pte);
3861 return;
3862 case KEY_HANGUP:
3863 case KEY_FUNC4:
3865 return;
3866 }
3867
3869 return;
3870}
3871
3872
3873#define SELECTEXTENSION_START_ENTRY_POS 0
3874#define SELECTEXTENSION_MAX_LENGTH 10
3875#define SELECTEXTENSION_MSG ".........."
3876static void show_extension_page(struct unistimsession *pte)
3877{
3878 pte->state = STATE_EXTENSION;
3879
3880 send_text(TEXT_LINE0, TEXT_NORMAL, pte, ustmtext("Please enter a Terminal", pte));
3881 send_text(TEXT_LINE1, TEXT_NORMAL, pte, ustmtext("Number (TN) :", pte));
3883 send_blink_cursor(pte);
3885 send_text_status(pte, ustmtext("Enter BackSpcErase", pte));
3886 pte->size_buff_entry = 0;
3887 return;
3888}
3889
3890static void key_select_extension(struct unistimsession *pte, char keycode)
3891{
3892 if (keycode == KEY_FUNC2) {
3893 if (pte->size_buff_entry <= 1) {
3894 keycode = KEY_FUNC3;
3895 } else {
3896 pte->size_buff_entry -= 2;
3897 keycode = pte->buff_entry[pte->size_buff_entry] + 0x10;
3898 }
3899 }
3900 if ((keycode >= KEY_0) && (keycode <= KEY_9)) {
3901 char tmpbuf[] = SELECTEXTENSION_MSG;
3902 int i = 0;
3903
3905 return;
3906 }
3907 while (i < pte->size_buff_entry) {
3908 tmpbuf[i + SELECTEXTENSION_START_ENTRY_POS] = pte->buff_entry[i];
3909 i++;
3910 }
3911 tmpbuf[i + SELECTEXTENSION_START_ENTRY_POS] = keycode - 0x10;
3912 pte->buff_entry[i] = keycode - 0x10;
3913 pte->size_buff_entry++;
3914 send_text(TEXT_LINE2, TEXT_NORMAL, pte, tmpbuf);
3915 send_blink_cursor(pte);
3916 send_cursor_pos(pte, (unsigned char) (TEXT_LINE2 + SELECTEXTENSION_START_ENTRY_POS + 1 + i));
3917 return;
3918 }
3919
3920 switch (keycode) {
3921 case KEY_FUNC1:
3922 if (pte->size_buff_entry < 1) {
3923 return;
3924 }
3926 struct unistim_device *d;
3927
3928 /* First step : looking for this TN in our device list */
3930 d = devices;
3931 pte->buff_entry[pte->size_buff_entry] = '\0';
3932 while (d) {
3933 if (d->id[0] == 'T') { /* It's a TN device ? */
3934 /* It's the TN we're looking for ? */
3935 if (!strcmp((d->id) + 1, pte->buff_entry)) {
3936 pte->device = d;
3937 d->session = pte;
3938 d->codec_number = DEFAULT_CODEC;
3939 d->missed_call = 0;
3940 d->receiver_state = STATE_ONHOOK;
3941 strcpy(d->id, pte->macaddr);
3942 pte->device->extension_number[0] = 'T';
3945 pte->buff_entry, pte->size_buff_entry + 1);
3947 show_main_page(pte);
3949 return;
3950 }
3951 }
3952 d = d->next;
3953 }
3955 send_text(TEXT_LINE0, TEXT_NORMAL, pte, ustmtext("Invalid Terminal Number.", pte));
3956 send_text(TEXT_LINE1, TEXT_NORMAL, pte, ustmtext("Please try again :", pte));
3958 pte->size_buff_entry));
3959 send_blink_cursor(pte);
3960 } else {
3962 pte->size_buff_entry + 1);
3963 if (register_extension(pte)) {
3964 send_text(TEXT_LINE0, TEXT_NORMAL, pte, ustmtext("Invalid extension.", pte));
3965 send_text(TEXT_LINE1, TEXT_NORMAL, pte, ustmtext("Please try again :", pte));
3966 send_cursor_pos(pte, (unsigned char) (TEXT_LINE2 +
3968 pte->size_buff_entry));
3969 send_blink_cursor(pte);
3970 } else
3971 show_main_page(pte);
3972 }
3973 break;
3974 case KEY_FUNC3:
3975 pte->size_buff_entry = 0;
3977 send_blink_cursor(pte);
3979 break;
3980 }
3981 return;
3982}
3983
3984static void show_entry_history(struct unistimsession *pte, FILE ** f)
3985{
3986 char line[TEXT_LENGTH_MAX + 1], status[STATUS_LENGTH_MAX + 1], func1[10], func2[10],
3987 func3[10];
3988
3989 /* Display date/time and call status */
3990 if (fread(line, TEXT_LENGTH_MAX, 1, *f) != 1) {
3991 display_last_error("Can't read history date entry");
3992 fclose(*f);
3993 return;
3994 }
3995 line[sizeof(line) - 1] = '\0';
3996 if (pte->device->height == 1) {
3997 if (pte->buff_entry[3] == 1) {
3998 send_text(TEXT_LINE0, TEXT_NORMAL, pte, line);
3999 }
4000 } else {
4001 send_text(TEXT_LINE0, TEXT_NORMAL, pte, line);
4002 }
4003 /* Display number */
4004 if (fread(line, TEXT_LENGTH_MAX, 1, *f) != 1) {
4005 display_last_error("Can't read callerid entry");
4006 fclose(*f);
4007 return;
4008 }
4009 line[sizeof(line) - 1] = '\0';
4010 ast_copy_string(pte->device->lst_cid, line, sizeof(pte->device->lst_cid));
4012 if (pte->device->height == 1) {
4013 if (pte->buff_entry[3] == 2) {
4014 send_text(TEXT_LINE0, TEXT_NORMAL, pte, line);
4015 }
4016 } else {
4017 send_text(TEXT_LINE1, TEXT_NORMAL, pte, line);
4018 }
4019 /* Display name */
4020 if (fread(line, TEXT_LENGTH_MAX, 1, *f) != 1) {
4021 display_last_error("Can't read callername entry");
4022 fclose(*f);
4023 return;
4024 }
4025 line[sizeof(line) - 1] = '\0';
4026 if (pte->device->height == 1) {
4027 if (pte->buff_entry[3] == 3) {
4028 send_text(TEXT_LINE0, TEXT_NORMAL, pte, line);
4029 }
4030 } else {
4031 send_text(TEXT_LINE2, TEXT_NORMAL, pte, line);
4032 }
4033 fclose(*f);
4034
4035 snprintf(line, sizeof(line), "%s %03d/%03d", ustmtext("Call", pte), pte->buff_entry[2],
4036 pte->buff_entry[1]);
4037 send_texttitle(pte, line);
4038
4039 if (pte->buff_entry[2] == 1) {
4040 ast_copy_string(func1, " ", sizeof(func1));
4041 } else {
4042 ast_copy_string(func1, ustmtext("Prev ", pte), sizeof(func1));
4043 }
4044 if (pte->buff_entry[2] >= pte->buff_entry[1]) {
4045 ast_copy_string(func2, " ", sizeof(func2));
4046 } else {
4047 ast_copy_string(func2, ustmtext("Next ", pte), sizeof(func2));
4048 }
4049 if (strlen(pte->device->lst_cid)) {
4050 ast_copy_string(func3, ustmtext("Redial ", pte), sizeof(func3));
4051 } else {
4052 ast_copy_string(func3, " ", sizeof(func3));
4053 }
4054 snprintf(status, sizeof(status), "%s%s%s%s", func1, func2, func3, ustmtext("Cancel", pte));
4056}
4057
4058static char open_history(struct unistimsession *pte, char way, FILE ** f)
4059{
4061 char count;
4062
4063 snprintf(tmp, sizeof(tmp), "%s/%s/%s-%c.csv", ast_config_AST_LOG_DIR,
4064 USTM_LOG_DIR, pte->device->name, way);
4065 *f = fopen(tmp, "r");
4066 if (!*f) {
4067 display_last_error("Unable to open history file");
4068 return 0;
4069 }
4070 if (fread(&count, 1, 1, *f) != 1) {
4071 display_last_error("Unable to read history header - display.");
4072 fclose(*f);
4073 *f = NULL;
4074 return 0;
4075 }
4076 if (count > MAX_ENTRY_LOG) {
4077 ast_log(LOG_WARNING, "Invalid count in history header of %s (%d max %d)\n", tmp,
4078 count, MAX_ENTRY_LOG);
4079 fclose(*f);
4080 *f = NULL;
4081 return 0;
4082 }
4083 return count;
4084}
4085
4086static void show_history(struct unistimsession *pte, char way)
4087{
4088 FILE *f;
4089 char count;
4090
4091 if (!pte->device) {
4092 return;
4093 }
4094 if (!pte->device->callhistory) {
4095 return;
4096 }
4097 count = open_history(pte, way, &f);
4098 if (!count) {
4099 return;
4100 }
4101 pte->buff_entry[0] = way;
4102 pte->buff_entry[1] = count;
4103 pte->buff_entry[2] = 1;
4104 pte->buff_entry[3] = 1;
4105 show_entry_history(pte, &f);
4106 pte->state = STATE_HISTORY;
4107}
4108
4109static void show_main_page(struct unistimsession *pte)
4110{
4111 char tmpbuf[TEXT_LENGTH_MAX + 1];
4112 const char *text;
4113
4114 if ((pte->device->extension == EXTENSION_ASK) &&
4117 return;
4118 }
4119
4120 pte->state = STATE_MAINPAGE;
4122 pte->device->lastmsgssent = -1;
4123
4124 send_tone(pte, 0, 0);
4125 send_stop_timer(pte); /* case of holding call */
4129
4130 if (!ast_strlen_zero(pte->device->call_forward)) {
4131 if (pte->device->height == 1) {
4132 char tmp_field[100];
4133 snprintf(tmp_field, sizeof(tmp_field), "%s %s", ustmtext("Fwd to:", pte), pte->device->call_forward);
4134 send_text(TEXT_LINE0, TEXT_NORMAL, pte, tmp_field);
4135 } else {
4136 send_text(TEXT_LINE0, TEXT_NORMAL, pte, ustmtext("Call forwarded to :", pte));
4138 }
4141 send_text_status(pte, ustmtext("Dial NoFwd ", pte));
4142 } else {
4143 send_text_status(pte, ustmtext("Dial Redial NoFwd ", pte));
4144 }
4145 } else {
4146 if ((pte->device->extension == EXTENSION_ASK) || (pte->device->extension == EXTENSION_TN)) {
4148 send_text_status(pte, ustmtext("Dial Fwd Unregis", pte));
4149 } else {
4150 send_text_status(pte, ustmtext("Dial Redial Fwd Unregis", pte));
4151 }
4152 } else {
4154 send_text_status(pte, ustmtext("Dial Fwd Pickup", pte));
4155 } else {
4156 send_text_status(pte, ustmtext("Dial Redial Fwd Pickup", pte));
4157 }
4158 }
4160 if (pte->device->missed_call == 0) {
4161 send_date_time2(pte);
4162 send_idle_clock(pte);
4163 if (strlen(pte->device->maintext0)) {
4165 }
4166 } else {
4167 if (pte->device->missed_call == 1) {
4168 text = ustmtext("unanswered call", pte);
4169 } else {
4170 text = ustmtext("unanswered calls", pte);
4171 }
4172 snprintf(tmpbuf, sizeof(tmpbuf), "%d %s", pte->device->missed_call, text);
4173 send_text(TEXT_LINE0, TEXT_NORMAL, pte, tmpbuf);
4175 }
4176 }
4177 if (pte->device->height > 1) {
4178 if (ast_strlen_zero(pte->device->maintext2)) {
4179 strcpy(tmpbuf, "IP : ");
4180 strcat(tmpbuf, ast_inet_ntoa(pte->sin.sin_addr));
4181 send_text(TEXT_LINE2, TEXT_NORMAL, pte, tmpbuf);
4182 } else {
4184 }
4185 }
4186
4187 send_texttitle(pte, ustmtext(pte->device->titledefault, pte));
4189}
4190
4191static void key_main_page(struct unistimsession *pte, char keycode)
4192{
4193 if (pte->device->missed_call) {
4195 pte->device->missed_call = 0;
4196 }
4197 if ((keycode >= KEY_0) && (keycode <= KEY_SHARP)) {
4198 handle_dial_page(pte);
4199 key_dial_page(pte, keycode);
4200 return;
4201 }
4202 switch (keycode) {
4203 case KEY_FUNC1:
4204 pte->device->selected = get_avail_softkey(pte, NULL);
4205 handle_dial_page(pte);
4206 break;
4207 case KEY_FUNC2:
4209 break;
4210 }
4211 if ((pte->device->output == OUTPUT_HANDSET) &&
4212 (pte->device->receiver_state == STATE_ONHOOK)) {
4214 } else {
4216 }
4218 sizeof(pte->device->phone_number));
4220 break;
4221 case KEY_FUNC3:
4222 if (!ast_strlen_zero(pte->device->call_forward)) {
4223 /* Cancel call forwarding */
4224 memmove(pte->device->call_forward + 1, pte->device->call_forward,
4225 sizeof(pte->device->call_forward) - 1);
4226 pte->device->call_forward[0] = '\0';
4228 pte->device->output = OUTPUT_HANDSET; /* Seems to be reseted somewhere */
4229 show_main_page(pte);
4230 break;
4231 }
4232 pte->device->call_forward[0] = -1;
4233 handle_dial_page(pte);
4234 break;
4235 case KEY_FUNC4:
4236 if (pte->device->extension == EXTENSION_ASK) {
4238 pte->device->extension_number[0] = '\0';
4240 } else if (pte->device->extension == EXTENSION_TN) {
4242 strcpy(pte->device->id, pte->device->extension_number);
4243 pte->buff_entry[0] = '\0';
4244 pte->size_buff_entry = 0;
4245 pte->device->session = NULL;
4246 pte->device = NULL;
4249 } else { /* Pickup function */
4250 /* XXX Is there a way to get a specific channel here? */
4251 RAII_VAR(struct ast_features_pickup_config *, pickup_cfg,
4253
4254 if (!pickup_cfg) {
4255 ast_log(LOG_ERROR, "Unable to retrieve pickup configuration options. Unable to detect call pickup extension\n");
4256 break;
4257 }
4258
4259 pte->device->selected = -1;
4260 ast_copy_string(pte->device->phone_number, pickup_cfg->pickupexten,
4261 sizeof(pte->device->phone_number));
4263 }
4264 break;
4265 case KEY_FAV0:
4266 case KEY_FAV1:
4267 case KEY_FAV2:
4268 case KEY_FAV3:
4269 case KEY_FAV4:
4270 case KEY_FAV5:
4271 handle_key_fav(pte, keycode);
4272 break;
4273 case KEY_CONF:
4275 break;
4276 case KEY_LOUDSPK:
4278 handle_dial_page(pte);
4279 break;
4280 case KEY_HEADPHN:
4282 handle_dial_page(pte);
4283 break;
4284 case KEY_SNDHIST:
4285 show_history(pte, 'o');
4286 break;
4287 case KEY_RCVHIST:
4288 show_history(pte, 'i');
4289 break;
4290 }
4291 return;
4292}
4293
4294static void key_history(struct unistimsession *pte, char keycode)
4295{
4296 FILE *f;
4297 char count;
4298 long offset;
4299 int flag = 0;
4300
4301 switch (keycode) {
4302 case KEY_LEFT:
4303 if (pte->device->height == 1) {
4304 if (pte->buff_entry[3] <= 1) {
4305 return;
4306 }
4307 pte->buff_entry[3]--;
4308 flag = 1;
4309 break;
4310 }
4311 case KEY_UP:
4312 case KEY_FUNC1:
4313 if (pte->buff_entry[2] <= 1) {
4314 return;
4315 }
4316 pte->buff_entry[2]--;
4317 flag = 1;
4318 break;
4319 case KEY_RIGHT:
4320 if (pte->device->height == 1) {
4321 if (pte->buff_entry[3] == 3) {
4322 return;
4323 }
4324 pte->buff_entry[3]++;
4325 flag = 1;
4326 break;
4327 }
4328 case KEY_DOWN:
4329 case KEY_FUNC2:
4330 if (pte->buff_entry[2] >= pte->buff_entry[1]) {
4331 return;
4332 }
4333 pte->buff_entry[2]++;
4334 flag = 1;
4335 break;
4336 case KEY_FUNC3:
4337 if (ast_strlen_zero(pte->device->lst_cid)) {
4338 break;
4339 }
4341 sizeof(pte->device->redial_number));
4343 break;
4344 case KEY_FUNC4:
4345 case KEY_HANGUP:
4346 show_main_page(pte);
4347 break;
4348 case KEY_SNDHIST:
4349 if (pte->buff_entry[0] == 'i') {
4350 show_history(pte, 'o');
4351 } else {
4352 show_main_page(pte);
4353 }
4354 break;
4355 case KEY_RCVHIST:
4356 if (pte->buff_entry[0] == 'i') {
4357 show_main_page(pte);
4358 } else {
4359 show_history(pte, 'i');
4360 }
4361 break;
4362 }
4363
4364 if (flag) {
4365 count = open_history(pte, pte->buff_entry[0], &f);
4366 if (!count) {
4367 return;
4368 }
4369 offset = ((pte->buff_entry[2] - 1) * TEXT_LENGTH_MAX * 3);
4370 if (fseek(f, offset, SEEK_CUR)) {
4371 display_last_error("Unable to seek history entry.");
4372 fclose(f);
4373 return;
4374 }
4375 show_entry_history(pte, &f);
4376 }
4377
4378 return;
4379}
4380
4381static void init_phone_step2(struct unistimsession *pte)
4382{
4383 BUFFSEND;
4384 if (unistimdebug) {
4385 ast_verb(0, "Sending S4\n");
4386 }
4387 memcpy(buffsend + SIZE_HEADER, packet_send_s4, sizeof(packet_send_s4));
4388 send_client(SIZE_HEADER + sizeof(packet_send_s4), buffsend, pte);
4389 send_date_time2(pte);
4390 send_date_time3(pte);
4391 if (unistimdebug) {
4392 ast_verb(0, "Sending S7\n");
4393 }
4394 memcpy(buffsend + SIZE_HEADER, packet_send_S7, sizeof(packet_send_S7));
4395 send_client(SIZE_HEADER + sizeof(packet_send_S7), buffsend, pte);
4396 if (unistimdebug) {
4397 ast_verb(0, "Sending Contrast\n");
4398 }
4399 memcpy(buffsend + SIZE_HEADER, packet_send_Contrast, sizeof(packet_send_Contrast));
4400 if (pte->device != NULL) {
4401 buffsend[9] = pte->device->contrast;
4402 }
4403 send_client(SIZE_HEADER + sizeof(packet_send_Contrast), buffsend, pte);
4404
4405 if (unistimdebug) {
4406 ast_verb(0, "Sending S9\n");
4407 }
4408 memcpy(buffsend + SIZE_HEADER, packet_send_s9, sizeof(packet_send_s9));
4409 send_client(SIZE_HEADER + sizeof(packet_send_s9), buffsend, pte);
4410 send_no_ring(pte);
4411
4412 if (unistimdebug) {
4413 ast_verb(0, "Sending S7\n");
4414 }
4415 memcpy(buffsend + SIZE_HEADER, packet_send_S7, sizeof(packet_send_S7));
4416 send_client(SIZE_HEADER + sizeof(packet_send_S7), buffsend, pte);
4418 send_ping(pte);
4419 if (unistimdebug) {
4420 ast_verb(0, "Sending init language\n");
4421 }
4422 if (pte->device) {
4424 }
4425 if (pte->state < STATE_MAINPAGE) {
4428 return;
4429 } else {
4430 int i;
4431 char tmp[30];
4432
4433 for (i = 1; i < FAVNUM; i++) {
4434 send_favorite(i, 0, pte, "");
4435 }
4436 send_text(TEXT_LINE0, TEXT_NORMAL, pte, ustmtext("Phone is not registered", pte));
4437 send_text(TEXT_LINE1, TEXT_NORMAL, pte, ustmtext("in unistim.conf", pte));
4438 strcpy(tmp, "MAC = ");
4439 strcat(tmp, pte->macaddr);
4441 send_text_status(pte, "");
4442 send_texttitle(pte, ustmtext("UNISTIM for*", pte));
4443 return;
4444 }
4445 }
4446 show_main_page(pte);
4448 if (unistimdebug) {
4449 ast_verb(0, "Sending arrow\n");
4450 }
4451 memcpy(buffsend + SIZE_HEADER, packet_send_arrow, sizeof(packet_send_arrow));
4452 send_client(SIZE_HEADER + sizeof(packet_send_arrow), buffsend, pte);
4453 return;
4454}
4455
4456/* Toggles the state of microphone muting */
4458{
4459 if (pte->device->microphone == MUTE_OFF) {
4460 pte->device->microphone = MUTE_ON;
4462 } else if (pte->device->microphone == MUTE_ON) {
4463 pte->device->microphone = MUTE_OFF;
4465 }
4466 send_mute(pte, (pte->device->microphone & 0x01));
4467}
4468
4469static void process_request(int size, unsigned char *buf, struct unistimsession *pte)
4470{
4471 char tmpbuf[255];
4472 if (memcmp
4476 return;
4477 }
4479 buf[size] = 0;
4480 if (unistimdebug) {
4481 ast_verb(0, "Got the firmware version : '%s'\n", buf + 13);
4482 }
4483 ast_copy_string(pte->firmware, (char *) (buf + 13), sizeof(pte->firmware));
4484 init_phone_step2(pte);
4485 return;
4486 }
4487 if (memcmp(buf + SIZE_HEADER, packet_recv_it_type, sizeof(packet_recv_it_type)) == 0) {
4488 char type = buf[13];
4489 if (unistimdebug) {
4490 ast_verb(0, "Got the equipment type: '%d'\n", type);
4491 }
4492 switch (type) {
4493 case 0x03: /* i2002 */
4494 if (pte->device) {
4495 pte->device->height = 1;
4496 }
4497 break;
4498 }
4499 return;
4500 }
4501 if (memcmp(buf + SIZE_HEADER, packet_recv_mac_addr, sizeof(packet_recv_mac_addr)) == 0) {
4502 rcv_mac_addr(pte, buf);
4503 return;
4504 }
4505 if (memcmp(buf + SIZE_HEADER, packet_recv_r2, sizeof(packet_recv_r2)) == 0) {
4506 if (unistimdebug) {
4507 ast_verb(0, "R2 received\n");
4508 }
4509 return;
4510 }
4511
4512 if (pte->state < STATE_MAINPAGE) {
4513 if (unistimdebug) {
4514 ast_verb(0, "Request not authorized in this state\n");
4515 }
4516 return;
4517 }
4519 char keycode = buf[13];
4520
4521 if (unistimdebug) {
4522 ast_verb(0, "Expansion key pressed: keycode = 0x%02hhx - current state: %s\n", (unsigned char)keycode,
4523 ptestate_tostr(pte->state));
4524 }
4525 }
4527 char keycode = buf[13];
4528
4529 if (unistimdebug) {
4530 ast_verb(0, "Key pressed: keycode = 0x%02hhx - current state: %s\n", (unsigned char)keycode,
4531 ptestate_tostr(pte->state));
4532 }
4533 if (keycode == KEY_MUTE) {
4535 }
4536 switch (pte->state) {
4537 case STATE_INIT:
4538 if (unistimdebug) {
4539 ast_verb(0, "No keys allowed in the init state\n");
4540 }
4541 break;
4542 case STATE_AUTHDENY:
4543 if (unistimdebug) {
4544 ast_verb(0, "No keys allowed in authdeny state\n");
4545 }
4546 break;
4547 case STATE_MAINPAGE:
4548 key_main_page(pte, keycode);
4549 break;
4550 case STATE_DIALPAGE:
4551 key_dial_page(pte, keycode);
4552 break;
4553 case STATE_RINGING:
4554 key_ringing(pte, keycode);
4555 break;
4556 case STATE_CALL:
4557 key_call(pte, keycode);
4558 break;
4559 case STATE_EXTENSION:
4560 key_select_extension(pte, keycode);
4561 break;
4562 case STATE_SELECTOPTION:
4563 key_select_option(pte, keycode);
4564 break;
4565 case STATE_SELECTCODEC:
4566 key_select_codec(pte, keycode);
4567 break;
4569 key_select_language(pte, keycode);
4570 break;
4571 case STATE_HISTORY:
4572 key_history(pte, keycode);
4573 break;
4574 default:
4575 ast_log(LOG_WARNING, "Key : Unknown state\n");
4576 }
4577 return;
4578 }
4579 if (memcmp(buf + SIZE_HEADER, packet_recv_pick_up, sizeof(packet_recv_pick_up)) == 0) {
4580 if (unistimdebug) {
4581 ast_verb(0, "Handset off hook, current state: %s\n", ptestate_tostr(pte->state));
4582 }
4583 if (!pte->device) { /* We are not yet registered (asking for a TN in AUTOPROVISIONING_TN) */
4584 return;
4585 }
4587 if (pte->device->output == OUTPUT_HEADPHONE) {
4589 } else {
4591 }
4592 if (pte->state == STATE_RINGING) {
4594 } else if ((pte->state == STATE_DIALPAGE) || (pte->state == STATE_CALL)) {
4596 } else if (pte->state == STATE_EXTENSION) { /* We must have a TN before calling */
4597 return;
4598 } else {
4599 pte->device->selected = get_avail_softkey(pte, NULL);
4601 handle_dial_page(pte);
4602 }
4603 return;
4604 }
4605 if (memcmp(buf + SIZE_HEADER, packet_recv_hangup, sizeof(packet_recv_hangup)) == 0) {
4606 if (unistimdebug) {
4607 ast_verb(0, "Handset on hook, current state: %s\n", ptestate_tostr(pte->state));
4608 }
4609 if (!pte->device) {
4610 return;
4611 }
4613 if (pte->state == STATE_CALL) {
4614 if (pte->device->output != OUTPUT_SPEAKER) {
4615 close_call(pte);
4616 }
4617 } else if (pte->state == STATE_EXTENSION) {
4618 return;
4619 } else {
4620 pte->device->nextdial = 0;
4621 show_main_page(pte);
4622 }
4623 return;
4624 }
4625 strcpy(tmpbuf, ast_inet_ntoa(pte->sin.sin_addr));
4626 strcat(tmpbuf, " Unknown request packet\n");
4627 if (unistimdebug) {
4628 ast_debug(1, "%s", tmpbuf);
4629 }
4630 return;
4631}
4632
4633static void parsing(int size, unsigned char *buf, struct unistimsession *pte,
4634 struct sockaddr_in *addr_from)
4635{
4636 unsigned short *sbuf = (unsigned short *) buf;
4637 unsigned short seq;
4638 char tmpbuf[255];
4639
4640 strcpy(tmpbuf, ast_inet_ntoa(addr_from->sin_addr));
4641
4642 if (size < 10) {
4643 if (size == 0) {
4644 ast_log(LOG_WARNING, "%s Read error\n", tmpbuf);
4645 } else {
4646 ast_log(LOG_NOTICE, "%s Packet too short - ignoring\n", tmpbuf);
4647 }
4648 return;
4649 }
4650 if (sbuf[0] == 0xffff) { /* Starting with 0xffff ? *//* Yes, discovery packet ? */
4651 if (size != sizeof(packet_rcv_discovery)) {
4652 ast_log(LOG_NOTICE, "%s Invalid size of a discovery packet\n", tmpbuf);
4653 } else {
4654 if (memcmp(buf, packet_rcv_discovery, sizeof(packet_rcv_discovery)) == 0) {
4655 if (unistimdebug) {
4656 ast_verb(0, "Discovery packet received - Sending Discovery ACK\n");
4657 }
4658 if (pte) { /* A session was already active for this IP ? */
4659 if (pte->state == STATE_INIT) { /* Yes, but it's a dupe */
4660 if (unistimdebug) {
4661 ast_verb(1, "Duplicated Discovery packet\n");
4662 }
4664 packet_send_discovery_ack, addr_from, &pte->sout);
4665 pte->seq_phone = (short) 0x0000; /* reset sequence number */
4666 } else { /* No, probably a reboot, phone side */
4667 close_client(pte); /* Cleanup the previous session */
4668 if (create_client(addr_from)) {
4670 packet_send_discovery_ack, addr_from, &pte->sout);
4671 }
4672 }
4673 } else {
4674 /* Creating new entry in our phone list */
4675 if ((pte = create_client(addr_from))) {
4677 packet_send_discovery_ack, addr_from, &pte->sout);
4678 }
4679 }
4680 return;
4681 }
4682 ast_log(LOG_NOTICE, "%s Invalid discovery packet\n", tmpbuf);
4683 }
4684 return;
4685 }
4686 if (!pte) {
4687 if (unistimdebug) {
4688 ast_verb(0, "%s Not a discovery packet from an unknown source : ignoring\n", tmpbuf);
4689 }
4690 return;
4691 }
4692
4693 if (sbuf[0] != 0) { /* Starting with something else than 0x0000 ? */
4694 ast_log(LOG_NOTICE, "Unknown packet received - ignoring\n");
4695 return;
4696 }
4697 if (buf[5] != 2) {
4698 ast_log(LOG_NOTICE, "%s Wrong direction : got 0x%02hhx expected 0x02\n", tmpbuf, buf[5]);
4699 return;
4700 }
4701 seq = ntohs(sbuf[1]);
4702 if (buf[4] == 1) {
4703 ast_mutex_lock(&pte->lock);
4704 if (unistimdebug) {
4705 ast_verb(0, "ACK received for packet #0x%04x\n", (unsigned)seq);
4706 }
4707 pte->nb_retransmit = 0;
4708
4709 if ((pte->last_seq_ack) + 1 == seq) {
4710 pte->last_seq_ack++;
4711 check_send_queue(pte);
4712 ast_mutex_unlock(&pte->lock);
4713 return;
4714 }
4715 if (pte->last_seq_ack > seq) {
4716 if (pte->last_seq_ack == 0xffff) {
4717 ast_verb(0, "ACK at 0xffff, restarting counter.\n");
4718 pte->last_seq_ack = 0;
4719 } else {
4721 "%s Warning : ACK received for an already ACKed packet : #0x%04x we are at #0x%04x\n",
4722 tmpbuf, (unsigned)seq, (unsigned)pte->last_seq_ack);
4723 }
4724 ast_mutex_unlock(&pte->lock);
4725 return;
4726 }
4727 if (pte->seq_server < seq) {
4729 "%s Error : ACK received for a non-existent packet : #0x%04x\n",
4730 tmpbuf, (unsigned)pte->seq_server);
4731 ast_mutex_unlock(&pte->lock);
4732 return;
4733 }
4734 if (unistimdebug) {
4735 ast_verb(0, "%s ACK gap : Received ACK #0x%04x, previous was #0x%04x\n",
4736 tmpbuf, (unsigned)seq, (unsigned)pte->last_seq_ack);
4737 }
4738 pte->last_seq_ack = seq;
4739 check_send_queue(pte);
4740 ast_mutex_unlock(&pte->lock);
4741 return;
4742 }
4743 if (buf[4] == 2) {
4744 if (unistimdebug) {
4745 ast_verb(0, "Request received\n");
4746 }
4747 if (pte->seq_phone == seq) {
4748 /* Send ACK */
4749 buf[4] = 1;
4750 buf[5] = 1;
4751 send_raw_client(SIZE_HEADER, buf, addr_from, &pte->sout);
4752 pte->seq_phone++;
4753
4754 process_request(size, buf, pte);
4755 return;
4756 }
4757 if (pte->seq_phone > seq) {
4759 "%s Warning : received a retransmitted packet : #0x%04x (we are at #0x%04x)\n",
4760 tmpbuf, (unsigned)seq, (unsigned)pte->seq_phone);
4761 /* BUG ? pte->device->seq_phone = seq; */
4762 /* Send ACK */
4763 buf[4] = 1;
4764 buf[5] = 1;
4765 send_raw_client(SIZE_HEADER, buf, addr_from, &pte->sout);
4766 return;
4767 }
4769 "%s Warning : we lost a packet : received #0x%04x (we are at #0x%04x)\n",
4770 tmpbuf, (unsigned)seq, (unsigned)pte->seq_phone);
4771 return;
4772 }
4773 if (buf[4] == 0) {
4774 ast_log(LOG_NOTICE, "%s Retransmit request for packet #0x%04x\n", tmpbuf, (unsigned)seq);
4775 if (pte->last_seq_ack > seq) {
4777 "%s Error : received a request for an already ACKed packet : #0x%04x\n",
4778 tmpbuf, (unsigned)pte->last_seq_ack);
4779 return;
4780 }
4781 if (pte->seq_server < seq) {
4783 "%s Error : received a request for a non-existent packet : #0x%04x\n",
4784 tmpbuf, (unsigned)pte->seq_server);
4785 return;
4786 }
4787 send_retransmit(pte);
4788 return;
4789 }
4790 ast_log(LOG_NOTICE, "%s Unknown request : got 0x%02hhx expected 0x00,0x01 or 0x02\n", tmpbuf, buf[4]);
4791 return;
4792}
4793
4795{
4796 struct unistim_subchannel *sub;
4797 if (!ast) {
4798 ast_log(LOG_WARNING, "Unistim callback function called with a null channel\n");
4799 return NULL;
4800 }
4801 if (!ast_channel_tech_pvt(ast)) {
4802 ast_log(LOG_WARNING, "Unistim callback function called without a tech_pvt\n");
4803 return NULL;
4804 }
4806
4807 if (!sub->parent) {
4808 ast_log(LOG_WARNING, "Unistim callback function called without a line\n");
4809 return NULL;
4810 }
4811 if (!sub->parent->parent) {
4812 ast_log(LOG_WARNING, "Unistim callback function called without a device\n");
4813 return NULL;
4814 }
4815 ast_mutex_lock(&sub->parent->parent->lock);
4816 if (!sub->parent->parent->session) {
4817 ast_log(LOG_WARNING, "Unistim callback function called without a session\n");
4818 ast_mutex_unlock(&sub->parent->parent->lock);
4819 return NULL;
4820 }
4821 ast_mutex_unlock(&sub->parent->parent->lock);
4822 return sub->parent->parent->session;
4823}
4824
4826{
4827 char *cidname_str;
4828 char *cidnum_str;
4829
4830 if (!sub) {
4831 return;
4832 }
4833 if (sub->owner) {
4835 cidnum_str = ast_channel_connected(sub->owner)->id.number.str;
4836 } else {
4837 cidnum_str = DEFAULTCALLERID;
4838 }
4839 change_callerid(pte, 0, cidnum_str);
4840 if (strlen(cidnum_str) == 0) {
4841 cidnum_str = DEFAULTCALLERID;
4842 }
4843
4845 cidname_str = ast_channel_connected(sub->owner)->id.name.str;
4846 } else {
4847 cidname_str = DEFAULTCALLERNAME;
4848 }
4849 change_callerid(pte, 1, cidname_str);
4850 if (strlen(cidname_str) == 0) {
4851 cidname_str = DEFAULTCALLERNAME;
4852 }
4853
4854 if (pte->device->height == 1) {
4855 char tmpstr[256];
4856 snprintf(tmpstr, sizeof(tmpstr), "%s %s", cidnum_str, ustmtext(cidname_str, pte));
4857 send_text(TEXT_LINE0, TEXT_NORMAL, pte, tmpstr);
4858 } else {
4859 send_text(TEXT_LINE0, TEXT_NORMAL, pte, cidname_str);
4860 send_text(TEXT_LINE1, TEXT_NORMAL, pte, ustmtext(cidnum_str, pte));
4861 }
4862 }
4863}
4864
4865/*--- unistim_call: Initiate UNISTIM call from PBX ---*/
4866/* used from the dial() application */
4867static int unistim_call(struct ast_channel *ast, const char *dest, int timeout)
4868{
4869 int res = 0, i;
4870 struct unistim_subchannel *sub, *sub_real;
4871 struct unistimsession *session;
4872 signed char ringstyle, ringvolume;
4873
4875 if (!session) {
4876 ast_log(LOG_ERROR, "Device not registered, cannot call %s\n", dest);
4877 return -1;
4878 }
4880 sub_real = get_sub(session->device, SUB_REAL);
4882 ast_log(LOG_WARNING, "unistim_call called on %s, neither down nor reserved\n",
4883 ast_channel_name(ast));
4884 return -1;
4885 }
4886
4887 if (unistimdebug) {
4888 ast_verb(3, "unistim_call(%s)\n", ast_channel_name(ast));
4889 }
4890 session->state = STATE_RINGING;
4892 if (ast_strlen_zero(ast_channel_call_forward(ast))) { /* Send ring only if no call forward, otherwise short ring will apear */
4893 send_text(TEXT_LINE2, TEXT_NORMAL, session, ustmtext("is calling you.", session));
4894 send_text_status(session, ustmtext("Accept Ignore Hangup", session));
4895
4896 if (sub_real) {
4897 ringstyle = session->device->cwstyle;
4898 ringvolume = session->device->cwvolume;
4899 } else {
4900 ringstyle = (sub->ringstyle == -1) ? session->device->ringstyle : sub->ringstyle;
4901 ringvolume = (sub->ringvolume == -1) ? session->device->ringvolume : sub->ringvolume;
4902 }
4903 send_ring(session, ringvolume, ringstyle);
4905 /* Send call identification to all */
4906 for (i = 0; i < FAVNUM; i++) {
4907 if (!soft_key_visible(session->device, i)) {
4908 continue;
4909 }
4910 if (session->device->ssub[i]) {
4911 continue;
4912 }
4913 if (is_key_line(session->device, i) && !strcmp(sub->parent->name, session->device->sline[i]->name)) {
4914 if (unistimdebug) {
4915 ast_verb(0, "Found softkey %d for line %s\n", i, sub->parent->name);
4916 }
4918 session->device->ssub[i] = sub;
4919 }
4920 }
4921 }
4924 return res;
4925}
4926
4927static int unistim_hangup_clean(struct ast_channel *ast, struct unistim_subchannel *sub) {
4928 ast_mutex_lock(&sub->lock);
4931 sub->alreadygone = 0;
4932 if (sub->rtp) {
4933 if (unistimdebug) {
4934 ast_verb(0, "Destroying RTP session\n");
4935 }
4938 sub->rtp = NULL;
4939 }
4940 ast_mutex_unlock(&sub->lock);
4941 return 0;
4942}
4943
4944/*--- unistim_hangup: Hangup UNISTIM call */
4945static int unistim_hangup(struct ast_channel *ast)
4946{
4947 struct unistim_subchannel *sub = NULL, *sub_real = NULL, *sub_trans = NULL;
4948 struct unistim_line *l;
4949 struct unistim_device *d;
4950 struct unistimsession *s;
4951 int i,end_call = 1;
4952
4953 s = channel_to_session(ast);
4955 l = sub->parent;
4956 d = l->parent;
4957 if (!s) {
4958 ast_debug(1, "Asked to hangup channel not connected\n");
4960 return 0;
4961 }
4962 if (unistimdebug) {
4963 ast_verb(0, "unistim_hangup(%s) on %s@%s (STATE_%s)\n", ast_channel_name(ast), l->name, l->parent->name, ptestate_tostr(s->state));
4964 }
4965 sub_trans = get_sub(d, SUB_THREEWAY);
4966 sub_real = get_sub(d, SUB_REAL);
4967 if (sub_trans && (sub_trans->owner) && (sub->subtype == SUB_REAL)) { /* 3rd party busy or congested and transfer_cancel_step2 does not called */
4968 if (unistimdebug) {
4969 ast_verb(0, "Threeway call disconnected, switching to real call\n");
4970 }
4971 ast_queue_unhold(sub_trans->owner);
4972 sub_trans->moh = 0;
4973 sub_trans->subtype = SUB_REAL;
4974 swap_subs(sub_trans, sub);
4975 send_text_status(s, ustmtext(" Transf Hangup", s));
4976 send_callerid_screen(s, sub_trans);
4979 return 0;
4980 }
4981 if (sub_real && (sub_real->owner) && (sub->subtype == SUB_THREEWAY) && (s->state == STATE_CALL)) { /* 3way call cancelled by softkey pressed */
4982 if (unistimdebug) {
4983 ast_verb(0, "Real call disconnected, stay in call\n");
4984 }
4985 send_text_status(s, ustmtext(" Transf Hangup", s));
4986 send_callerid_screen(s, sub_real);
4989 return 0;
4990 }
4991 if (sub->subtype == SUB_REAL) {
4993 } else if (sub->subtype == SUB_RING) {
4994 send_no_ring(s);
4995 for (i = 0; i < FAVNUM; i++) {
4996 if (!soft_key_visible(s->device, i)) {
4997 continue;
4998 }
4999 if (d->ssub[i] != sub) {
5000 if (d->ssub[i] != NULL) { /* Found other subchannel active other than hangup'ed one */
5001 end_call = 0;
5002 }
5003 continue;
5004 }
5005 if (is_key_line(d, i) && !strcmp(l->name, d->sline[i]->name)) {
5007 d->ssub[i] = NULL;
5008 continue;
5009 }
5010 }
5011 }
5012 if (end_call) {
5013 send_end_call(s); /* Send end call packet only if ending active call, in other way sound should be loosed */
5014 }
5015 sub->moh = 0;
5016 if (sub->softkey >= 0) {
5018 }
5019 /* Delete assign sub to softkey */
5020 for (i = 0; i < FAVNUM; i++) {
5021 if (d->ssub[i] == sub) {
5022 d->ssub[i] = NULL;
5023 break;
5024 }
5025 }
5026 /*refresh_all_favorite(s); */ /* TODO: Update favicons in case of DND keys */
5027 if (s->state == STATE_RINGING && sub->subtype == SUB_RING) {
5028 send_no_ring(s);
5030 d->missed_call++;
5031 write_history(s, 'i', 1);
5032 }
5033 if (!sub_real) {
5034 show_main_page(s);
5035 } else { /* hangup on a ringing line: reset status to reflect that we're still on an active call */
5036 s->state = STATE_CALL;
5037 send_callerid_screen(s, sub_real);
5038 send_text(TEXT_LINE2, TEXT_NORMAL, s, ustmtext("is on-line", s));
5039 send_text_status(s, ustmtext(" Transf Hangup", s));
5041
5042 }
5043 }
5044 if (s->state == STATE_CALL && sub->subtype == SUB_REAL) {
5045 close_call(s);
5046 }
5047 sub->softkey = -1;
5050 return 0;
5051}
5052
5053/*--- unistim_answer: Answer UNISTIM call */
5054static int unistim_answer(struct ast_channel *ast)
5055{
5056 int res = 0;
5057 struct unistim_subchannel *sub;
5058 struct unistim_line *l;
5059 struct unistim_device *d;
5060 struct unistimsession *s;
5061
5062 s = channel_to_session(ast);
5063 if (!s) {
5064 ast_log(LOG_WARNING, "unistim_answer on a disconnected device ?\n");
5065 return -1;
5066 }
5068 l = sub->parent;
5069 d = l->parent;
5070
5071 if (unistimdebug) {
5072 ast_verb(0, "unistim_answer(%s) on %s@%s-%d\n", ast_channel_name(ast), l->name,
5073 l->parent->name, sub->softkey);
5074 }
5075 send_text(TEXT_LINE2, TEXT_NORMAL, s, ustmtext("is now on-line", s));
5076 if (get_sub(d, SUB_THREEWAY)) {
5077 send_text_status(s, ustmtext("Transf Cancel", s));
5078 } else {
5079 send_text_status(s, ustmtext(" Transf Hangup", s));
5080 }
5082 if (ast_channel_state(ast) != AST_STATE_UP)
5084 return res;
5085}
5086
5087/*--- unistimsock_read: Read data from UNISTIM socket ---*/
5088/* Successful messages is connected to UNISTIM call and forwarded to parsing() */
5089static int unistimsock_read(int *id, int fd, short events, void *ignore)
5090{
5091 struct sockaddr_in addr_from = { 0, };
5092 struct unistimsession *cur = NULL;
5093 int found = 0;
5094 int tmp = 0;
5095 int dw_num_bytes_rcvd;
5096 unsigned int size_addr_from;
5097#ifdef DUMP_PACKET
5098 int dw_num_bytes_rcvdd;
5099#endif
5100
5101 size_addr_from = sizeof(addr_from);
5102 dw_num_bytes_rcvd =
5103 recvfrom(unistimsock, buff, SIZE_PAGE, 0, (struct sockaddr *) &addr_from,
5104 &size_addr_from);
5105 if (dw_num_bytes_rcvd == -1) {
5106 if (errno == EAGAIN) {
5107 ast_log(LOG_NOTICE, "UNISTIM: Received packet with bad UDP checksum\n");
5108 } else if (errno != ECONNREFUSED) {
5109 ast_log(LOG_WARNING, "Recv error %d (%s)\n", errno, strerror(errno));
5110 }
5111 return 1;
5112 }
5113
5114 /* Looking in the phone list if we already have a registration for him */
5116 cur = sessions;
5117 while (cur) {
5118 if (cur->sin.sin_addr.s_addr == addr_from.sin_addr.s_addr) {
5119 found = 1;
5120 break;
5121 }
5122 tmp++;
5123 cur = cur->next;
5124 }
5126
5127#ifdef DUMP_PACKET
5128 if (unistimdebug)
5129 ast_verb(0, "\n*** Dump %d bytes from %s - phone_table[%d] ***\n",
5130 dw_num_bytes_rcvd, ast_inet_ntoa(addr_from.sin_addr), tmp);
5131 for (dw_num_bytes_rcvdd = 0; dw_num_bytes_rcvdd < dw_num_bytes_rcvd;
5132 dw_num_bytes_rcvdd++)
5133 ast_verb(0, "%02hhx ", buff[dw_num_bytes_rcvdd]);
5134 ast_verb(0, "\n******************************************\n");
5135#endif
5136
5137 if (!found) {
5138 if (unistimdebug) {
5139 ast_verb(0, "Received a packet from an unknown source\n");
5140 }
5141 parsing(dw_num_bytes_rcvd, buff, NULL, (struct sockaddr_in *) &addr_from);
5142
5143 } else {
5144 parsing(dw_num_bytes_rcvd, buff, cur, (struct sockaddr_in *) &addr_from);
5145 }
5146 return 1;
5147}
5148
5149static struct ast_frame *unistim_rtp_read(const struct ast_channel *ast,
5150 const struct unistim_subchannel *sub)
5151{
5152 /* Retrieve audio/etc from channel. Assumes sub->lock is already held. */
5153 struct ast_frame *f;
5154
5155 if (!ast) {
5156 ast_log(LOG_WARNING, "Channel NULL while reading\n");
5157 return &ast_null_frame;
5158 }
5159
5160 if (!sub->rtp) {
5161 ast_log(LOG_WARNING, "RTP handle NULL while reading on subchannel %u\n",
5162 sub->subtype);
5163 return &ast_null_frame;
5164 }
5165
5166 switch (ast_channel_fdno(ast)) {
5167 case 0:
5168 f = ast_rtp_instance_read(sub->rtp, 0); /* RTP Audio */
5169 break;
5170 case 1:
5171 f = ast_rtp_instance_read(sub->rtp, 1); /* RTCP Control Channel */
5172 break;
5173 default:
5174 f = &ast_null_frame;
5175 }
5176
5177 if (sub->owner) {
5178 /* We already hold the channel lock */
5179 if (f->frametype == AST_FRAME_VOICE) {
5182 struct ast_format_cap *caps;
5183
5184 ast_debug(1,
5185 "Oooh, format changed from %s to %s\n",
5188
5190 if (caps) {
5192 ast_channel_nativeformats_set(sub->owner, caps);
5193 ao2_ref(caps, -1);
5194 }
5197 }
5198 }
5199 }
5200
5201 return f;
5202}
5203
5204static struct ast_frame *unistim_read(struct ast_channel *ast)
5205{
5206 struct ast_frame *fr;
5208
5209 ast_mutex_lock(&sub->lock);
5210 fr = unistim_rtp_read(ast, sub);
5211 ast_mutex_unlock(&sub->lock);
5212
5213 return fr;
5214}
5215
5216static int unistim_write(struct ast_channel *ast, struct ast_frame *frame)
5217{
5219 int res = 0;
5220
5221 if (frame->frametype != AST_FRAME_VOICE) {
5222 if (frame->frametype == AST_FRAME_IMAGE) {
5223 return 0;
5224 } else {
5225 ast_log(LOG_WARNING, "Can't send %u type frames with unistim_write\n",
5226 frame->frametype);
5227 return 0;
5228 }
5229 } else {
5232
5234 "Asked to transmit frame type %s, while native formats is %s (read/write = (%s/%s)\n",
5239 return -1;
5240 }
5241 }
5242
5243 if (sub) {
5244 ast_mutex_lock(&sub->lock);
5245 if (sub->rtp) {
5246 res = ast_rtp_instance_write(sub->rtp, frame);
5247 }
5248 ast_mutex_unlock(&sub->lock);
5249 }
5250
5251 return res;
5252}
5253
5254static int unistim_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
5255{
5256 struct unistim_subchannel *p = ast_channel_tech_pvt(newchan);
5257 struct unistim_line *l = p->parent;
5258
5259 ast_mutex_lock(&p->lock);
5260
5261 ast_debug(1, "New owner for channel USTM/%s@%s-%u is %s\n", l->name,
5262 l->parent->name, p->subtype, ast_channel_name(newchan));
5263
5264 if (p->owner != oldchan) {
5265 ast_log(LOG_WARNING, "old channel wasn't %s (%p) but was %s (%p)\n",
5266 ast_channel_name(oldchan), oldchan, ast_channel_name(p->owner), p->owner);
5268 return -1;
5269 }
5270
5271 unistim_set_owner(p, newchan);
5272
5274
5275 return 0;
5276
5277}
5278
5279static char *control2str(int ind)
5280{
5281 switch (ind) {
5282 case AST_CONTROL_HANGUP:
5283 return "Other end has hungup";
5284 case AST_CONTROL_RING:
5285 return "Local ring";
5287 return "Remote end is ringing";
5288 case AST_CONTROL_ANSWER:
5289 return "Remote end has answered";
5290 case AST_CONTROL_BUSY:
5291 return "Remote end is busy";
5293 return "Make it go off hook";
5295 return "Line is off hook";
5297 return "Congestion (circuits busy)";
5298 case AST_CONTROL_FLASH:
5299 return "Flash hook";
5300 case AST_CONTROL_WINK:
5301 return "Wink";
5302 case AST_CONTROL_OPTION:
5303 return "Set a low-level option";
5305 return "Key Radio";
5307 return "Un-Key Radio";
5309 return "Remote end changed";
5311 return "RTP source updated";
5313 return "Source of media changed";
5314 case -1:
5315 return "Stop tone";
5316 }
5317 return "UNKNOWN";
5318}
5319
5320static void in_band_indication(struct ast_channel *ast, const struct ast_tone_zone *tz,
5321 const char *indication)
5322{
5323 struct ast_tone_zone_sound *ts = NULL;
5324
5325 if ((ts = ast_get_indication_tone(tz, indication))) {
5326 ast_playtones_start(ast, 0, ts->data, 1);
5328 } else {
5329 ast_log(LOG_WARNING, "Unable to get indication tone for %s\n", indication);
5330 }
5331}
5332
5333static int unistim_indicate(struct ast_channel *ast, int ind, const void *data, size_t datalen)
5334{
5335 struct unistim_subchannel *sub;
5336 struct unistim_line *l;
5337 struct unistimsession *s;
5338
5339 if (unistimdebug) {
5340 ast_verb(3, "Asked to indicate '%s' (%d) condition on channel %s\n",
5341 control2str(ind), ind, ast_channel_name(ast));
5342 }
5343
5344 s = channel_to_session(ast);
5345 if (!s) {
5346 return -1;
5347 }
5349 l = sub->parent;
5350
5351 switch (ind) {
5353 if (ast_channel_state(ast) != AST_STATE_UP) {
5354 send_text(TEXT_LINE2, TEXT_NORMAL, s, ustmtext("Ringing...", s));
5355 in_band_indication(ast, l->parent->tz, "ring");
5356 s->device->missed_call = -1;
5357 break;
5358 }
5359 return -1;
5360 case AST_CONTROL_BUSY:
5361 if (ast_channel_state(ast) != AST_STATE_UP) {
5362 sub->alreadygone = 1;
5363 send_text(TEXT_LINE2, TEXT_NORMAL, s, ustmtext("Busy", s));
5364 in_band_indication(ast, l->parent->tz, "busy");
5365 s->device->missed_call = -1;
5366 break;
5367 }
5368 return -1;
5370 /* Overlapped dialing is not currently supported for UNIStim. Treat an indication
5371 * of incomplete as congestion
5372 */
5374 if (ast_channel_state(ast) != AST_STATE_UP) {
5375 sub->alreadygone = 1;
5376 send_text(TEXT_LINE2, TEXT_NORMAL, s, ustmtext("Congestion", s));
5377 in_band_indication(ast, l->parent->tz, "congestion");
5378 s->device->missed_call = -1;
5379 break;
5380 }
5381 return -1;
5382 case AST_CONTROL_HOLD:
5383 ast_moh_start(ast, data, NULL);
5384 break;
5385 case AST_CONTROL_UNHOLD:
5386 ast_moh_stop(ast);
5387 break;
5392 break;
5393 case -1:
5394 ast_playtones_stop(ast);
5395 s->device->missed_call = 0;
5396 break;
5398 ast_log(LOG_NOTICE, "Connected party is now %s <%s>\n",
5399 S_COR(ast_channel_connected(ast)->id.name.valid, ast_channel_connected(ast)->id.name.str, ""),
5400 S_COR(ast_channel_connected(ast)->id.number.valid, ast_channel_connected(ast)->id.number.str, ""));
5401 if (sub->subtype == SUB_REAL) {
5403 }
5404 break;
5406 if (sub->rtp) {
5408 }
5409 break;
5410 default:
5411 ast_log(LOG_WARNING, "Don't know how to indicate condition %d\n", ind);
5412 /* fallthrough */
5415 return -1;
5416 }
5417
5418 return 0;
5419}
5420
5421static struct unistim_subchannel *find_subchannel_by_name(const char *dest)
5422{
5423 struct unistim_line *l;
5424 struct unistim_device *d;
5425 struct unistim_subchannel *sub = NULL;
5426 char line[256];
5427 char *at;
5428 char *device;
5429
5430 ast_copy_string(line, dest, sizeof(line));
5431 at = strchr(line, '@');
5432 if (!at) {
5433 ast_log(LOG_NOTICE, "Device '%s' has no @ (at) sign!\n", dest);
5434 return NULL;
5435 }
5436 *at = '\0';
5437 at++;
5438 device = at;
5440 d = devices;
5441 at = strchr(device, '/'); /* Extra options ? */
5442 if (at) {
5443 *at = '\0';
5444 }
5445 while (d) {
5446 if (!strcasecmp(d->name, device)) {
5447 if (unistimdebug) {
5448 ast_verb(0, "Found device: %s\n", d->name);
5449 }
5450 /* Found the device */
5451 AST_LIST_LOCK(&d->lines);
5452 AST_LIST_TRAVERSE(&d->lines, l, list) {
5453 /* Search for the right line */
5454 if (!strcasecmp(l->name, line)) {
5455 if (unistimdebug) {
5456 ast_verb(0, "Found line: %s\n", l->name);
5457 }
5458 sub = get_sub(d, SUB_REAL);
5459 if (!sub) {
5461 }
5462 if (sub->owner) {
5463 /* Allocate additional channel if asterisk channel already here */
5465 sub->holding = 1;
5466 }
5467 sub->ringvolume = -1;
5468 sub->ringstyle = -1;
5469 if (at) { /* Other options ? */
5470 at++; /* Skip slash */
5471 if (*at == 'r') { /* distinctive ring */
5472 at++;
5473 if ((*at < '0') || (*at > '7')) { /* ring style */
5474 ast_log(LOG_WARNING, "Invalid ring selection (%s)", at);
5475 } else {
5476 signed char ring_volume = -1;
5477 signed char ring_style = *at - '0';
5478 at++;
5479 if ((*at >= '0') && (*at <= '3')) { /* ring volume */
5480 ring_volume = *at - '0';
5481 }
5482 if (unistimdebug) {
5483 ast_verb(0, "Distinctive ring: style #%d volume %d\n",
5484 ring_style, ring_volume);
5485 }
5486 sub->ringvolume = ring_volume;
5487 sub->ringstyle = ring_style;
5488 }
5489 }
5490 }
5491 sub->parent = l;
5492 break;
5493 }
5494 }
5495 AST_LIST_UNLOCK(&d->lines);
5496 if (sub) {
5498 return sub;
5499 }
5500 }
5501 d = d->next;
5502 }
5503 /* Device not found */
5505
5506 return NULL;
5507}
5508
5509static int unistim_senddigit_begin(struct ast_channel *ast, char digit)
5510{
5511 struct unistimsession *pte = channel_to_session(ast);
5512
5513 if (!pte) {
5514 return -1;
5515 }
5516 return send_dtmf_tone(pte, digit);
5517}
5518
5519static int unistim_senddigit_end(struct ast_channel *ast, char digit, unsigned int duration)
5520{
5521 struct unistimsession *pte = channel_to_session(ast);
5522
5523 if (!pte) {
5524 return -1;
5525 }
5526
5527 if (unistimdebug) {
5528 ast_verb(0, "Send Digit off %c (duration %d)\n", digit, duration);
5529 }
5530 send_tone(pte, 0, 0);
5531 return 0;
5532}
5533
5534/*--- unistim_sendtext: Display a text on the phone screen ---*/
5535/* Called from PBX core text message functions */
5536static int unistim_sendtext(struct ast_channel *ast, const char *text)
5537{
5538 struct unistimsession *pte = channel_to_session(ast);
5539 int size;
5540 char tmp[TEXT_LENGTH_MAX + 1];
5541
5542 if (unistimdebug) {
5543 ast_verb(0, "unistim_sendtext called\n");
5544 }
5545 if (!text) {
5546 ast_log(LOG_WARNING, "unistim_sendtext called with a null text\n");
5547 return -1;
5548 }
5549
5550 if (!pte) {
5551 return -1;
5552 }
5553
5554 size = strlen(text);
5555 if (text[0] == '@') {
5556 int pos = 0, i = 1, tok = 0, sz = 0;
5557 char label[11];
5558 char number[16];
5559 char icon = '\0';
5560 char cur = '\0';
5561
5562 memset(label, 0, 11);
5563 memset(number, 0, 16);
5564 while (text[i]) {
5565 cur = text[i++];
5566 switch (tok) {
5567 case 0:
5568 if ((cur < '0') && (cur > '5')) {
5570 "sendtext failed : position must be a number beetween 0 and 5\n");
5571 return 1;
5572 }
5573 pos = cur - '0';
5574 tok = 1;
5575 continue;
5576 case 1:
5577 if (cur != '@') {
5578 ast_log(LOG_WARNING, "sendtext failed : invalid position\n");
5579 return 1;
5580 }
5581 tok = 2;
5582 continue;
5583 case 2:
5584 if ((cur < '3') && (cur > '6')) {
5586 "sendtext failed : icon must be a number beetween 32 and 63 (first digit invalid)\n");
5587 return 1;
5588 }
5589 icon = (cur - '0') * 10;
5590 tok = 3;
5591 continue;
5592 case 3:
5593 if ((cur < '0') && (cur > '9')) {
5595 "sendtext failed : icon must be a number beetween 32 and 63 (second digit invalid)\n");
5596 return 1;
5597 }
5598 icon += (cur - '0');
5599 tok = 4;
5600 continue;
5601 case 4:
5602 if (cur != '@') {
5604 "sendtext failed : icon must be a number beetween 32 and 63 (too many digits)\n");
5605 return 1;
5606 }
5607 tok = 5;
5608 continue;
5609 case 5:
5610 if (cur == '@') {
5611 tok = 6;
5612 sz = 0;
5613 continue;
5614 }
5615 if (sz > 10) {
5616 continue;
5617 }
5618 label[sz] = cur;
5619 sz++;
5620 continue;
5621 case 6:
5622 if (sz > 15) {
5624 "sendtext failed : extension too long = %d (15 car max)\n",
5625 sz);
5626 return 1;
5627 }
5628 number[sz] = cur;
5629 sz++;
5630 continue;
5631 }
5632 }
5633 if (tok != 6) {
5634 ast_log(LOG_WARNING, "sendtext failed : incomplet command\n");
5635 return 1;
5636 }
5637 if (!pte->device) {
5638 ast_log(LOG_WARNING, "sendtext failed : no device ?\n");
5639 return 1;
5640 }
5641 strcpy(pte->device->softkeylabel[pos], label);
5642 strcpy(pte->device->softkeynumber[pos], number);
5643 pte->device->softkeyicon[pos] = icon;
5644 send_favorite(pos, icon, pte, label);
5645 return 0;
5646 }
5647
5648 if (size <= TEXT_LENGTH_MAX * 2) {
5649 if (pte->device->height == 1) {
5651 } else {
5652 send_text(TEXT_LINE0, TEXT_NORMAL, pte, ustmtext("Message :", pte));
5654 }
5655 if (size <= TEXT_LENGTH_MAX) {
5656 send_text(TEXT_LINE2, TEXT_NORMAL, pte, "");
5657 return 0;
5658 }
5660 tmp[sizeof(tmp) - 1] = '\0';
5662 return 0;
5663 }
5666 tmp[sizeof(tmp) - 1] = '\0';
5668 memcpy(tmp, text + TEXT_LENGTH_MAX * 2, TEXT_LENGTH_MAX);
5669 tmp[sizeof(tmp) - 1] = '\0';
5671 return 0;
5672}
5673
5674/*--- unistim_send_mwi_to_peer: Send message waiting indication ---*/
5675static int unistim_send_mwi_to_peer(struct unistim_line *peer, unsigned int tick)
5676{
5677 int new;
5678 RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
5679
5681 if (msg) {
5682 struct ast_mwi_state *mwi_state = stasis_message_data(msg);
5683 new = mwi_state->new_msgs;
5684 } else { /* Fall back on checking the mailbox directly */
5685 new = ast_app_has_voicemail(peer->mailbox, NULL);
5686 }
5687 ast_debug(3, "MWI Status for mailbox %s is %d, lastmsgsent:%d\n",
5688 peer->mailbox, new, peer->parent->lastmsgssent);
5689 peer->parent->nextmsgcheck = tick + TIMER_MWI;
5690
5691 /* Return now if it's the same thing we told them last time */
5692 if ((peer->parent->session->state != STATE_MAINPAGE) || (new == peer->parent->lastmsgssent)) {
5693 return 0;
5694 }
5695
5696 peer->parent->lastmsgssent = new;
5698
5699 return 0;
5700}
5701
5702/*--- unistim_new: Initiate a call in the UNISTIM channel */
5703/* called from unistim_request (calls from the pbx ) */
5704static struct ast_channel *unistim_new(struct unistim_subchannel *sub, int state, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor)
5705{
5706 struct ast_format_cap *caps;
5707 struct ast_channel *tmp;
5708 struct unistim_line *l;
5709 struct ast_format *tmpfmt;
5710
5711 if (!sub) {
5712 ast_log(LOG_WARNING, "subchannel null in unistim_new\n");
5713 return NULL;
5714 }
5715 if (!sub->parent) {
5716 ast_log(LOG_WARNING, "no line for subchannel %p\n", sub);
5717 return NULL;
5718 }
5719
5721 if (!caps) {
5722 return NULL;
5723 }
5724
5725 l = sub->parent;
5727 l->parent->context, assignedids, requestor, l->amaflags, "USTM/%s@%s-%p", l->name, l->parent->name, sub);
5728 if (unistimdebug) {
5729 ast_verb(0, "unistim_new sub=%u (%p) chan=%p line=%s\n", sub->subtype, sub, tmp, l->name);
5730 }
5731 if (!tmp) {
5732 ast_log(LOG_WARNING, "Unable to allocate channel structure\n");
5733 ao2_ref(caps, -1);
5734 return NULL;
5735 }
5736
5738
5739 if (ast_format_cap_count(l->cap)) {
5741 } else {
5743 }
5745 ao2_ref(caps, -1);
5746
5748
5749 if (unistimdebug) {
5750 struct ast_str *native_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
5752 struct ast_str *global_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
5753
5754 ast_verb(0, "Best codec = %s from nativeformats %s (line cap=%s global=%s)\n",
5755 ast_format_get_name(tmpfmt),
5757 ast_format_cap_get_names(l->cap, &cap_buf),
5758 ast_format_cap_get_names(global_cap, &global_buf));
5759 }
5760 if ((sub->rtp) && (sub->subtype == 0)) {
5761 if (unistimdebug) {
5762 ast_verb(0, "New unistim channel with a previous rtp handle ?\n");
5763 }
5766 }
5767 if (sub->rtp) {
5769 }
5770/* tmp->type = type; */
5772 if (state == AST_STATE_RING) {
5774 }
5776
5781 ao2_ref(tmpfmt, -1);
5782
5785
5786 if (!ast_strlen_zero(l->parent->language)) {
5787 ast_channel_language_set(tmp, l->parent->language);
5788 }
5793 ast_channel_call_forward_set(tmp, l->parent->call_forward);
5794 if (!ast_strlen_zero(l->cid_num)) {
5795 char *name, *loc, *instr;
5796 instr = ast_strdup(l->cid_num);
5797 if (instr) {
5798 ast_callerid_parse(instr, &name, &loc);
5805 ast_free(instr);
5806 }
5807 }
5809
5812
5813 if (state != AST_STATE_DOWN) {
5814 if (unistimdebug) {
5815 ast_verb(0, "Starting pbx in unistim_new\n");
5816 }
5817 if (ast_pbx_start(tmp)) {
5818 ast_log(LOG_WARNING, "Unable to start PBX on %s\n", ast_channel_name(tmp));
5819 ast_hangup(tmp);
5820 tmp = NULL;
5821 }
5822 }
5823
5824 return tmp;
5825}
5826
5827static void unistim_set_owner(struct unistim_subchannel *sub, struct ast_channel *chan)
5828{
5829 sub->owner = chan;
5830 if (sub->rtp) {
5831 ast_rtp_instance_set_channel_id(sub->rtp, sub->owner ? ast_channel_uniqueid(sub->owner) : "");
5832 }
5833}
5834
5835static void *do_monitor(void *data)
5836{
5837 struct unistimsession *cur = NULL;
5838 unsigned int dw_timeout = 0;
5839 unsigned int tick;
5840 int res;
5841 int reloading;
5842
5843 /* Add an I/O event to our UDP socket */
5844 if (unistimsock > -1) {
5846 }
5847 /* This thread monitors our UDP socket and timers */
5848 for (;;) {
5849 /* This loop is executed at least every IDLE_WAITus (1s) or every time a packet is received */
5850 /* Looking for the smallest time-out value */
5851 tick = get_tick_count();
5852 dw_timeout = UINT_MAX;
5854 cur = sessions;
5855 DEBUG_TIMER("checking timeout for session %p with tick = %u\n", cur, tick);
5856 while (cur) {
5857 DEBUG_TIMER("checking timeout for session %p timeout = %u\n", cur,
5858 cur->timeout);
5859 /* Check if we have miss something */
5860 if (cur->timeout <= tick) {
5861 DEBUG_TIMER("Event for session %p\n", cur);
5862 /* If the queue is empty, send a ping */
5863 if (cur->last_buf_available == 0) {
5864 send_ping(cur);
5865 } else {
5866 if (send_retransmit(cur)) {
5867 DEBUG_TIMER("The chained link was modified, restarting...\n");
5868 cur = sessions;
5869 dw_timeout = UINT_MAX;
5870 continue;
5871 }
5872 }
5873 }
5874 if (dw_timeout > cur->timeout - tick) {
5875 dw_timeout = cur->timeout - tick;
5876 }
5877 /* Checking if the phone is logged on for a new MWI */
5878 if (cur->device) {
5879 struct unistim_line *l;
5880 AST_LIST_LOCK(&cur->device->lines);
5881 AST_LIST_TRAVERSE(&cur->device->lines, l, list) {
5882 if ((!ast_strlen_zero(l->mailbox)) && (tick >= l->parent->nextmsgcheck)) {
5883 DEBUG_TIMER("Checking mailbox for MWI\n");
5884 unistim_send_mwi_to_peer(l, tick);
5885 break;
5886 }
5887 }
5889 if (cur->device->nextdial && tick >= cur->device->nextdial) {
5891 cur->device->nextdial = 0;
5892 }
5893 }
5894 cur = cur->next;
5895 }
5897 DEBUG_TIMER("Waiting for %dus\n", dw_timeout);
5898 res = dw_timeout;
5899 /* We should not wait more than IDLE_WAIT */
5900 if ((res < 0) || (res > IDLE_WAIT)) {
5901 res = IDLE_WAIT;
5902 }
5903 /* Wait for UDP messages for a maximum of res us */
5904 res = ast_io_wait(io, res); /* This function will call unistimsock_read if a packet is received */
5905 /* Check for a reload request */
5907 reloading = unistim_reloading;
5910 if (reloading) {
5911 ast_verb(1, "Reloading unistim.conf...\n");
5912 reload_config();
5913 }
5914 pthread_testcancel();
5915 }
5916 /* Never reached */
5917 return NULL;
5918}
5919
5920/*--- restart_monitor: Start the channel monitor thread ---*/
5921static int restart_monitor(void)
5922{
5923 pthread_attr_t attr;
5924 /* If we're supposed to be stopped -- stay stopped */
5926 return 0;
5927 }
5928 if (ast_mutex_lock(&monlock)) {
5929 ast_log(LOG_WARNING, "Unable to lock monitor\n");
5930 return -1;
5931 }
5932 if (monitor_thread == pthread_self()) {
5934 ast_log(LOG_WARNING, "Cannot kill myself\n");
5935 return -1;
5936 }
5938 /* Wake up the thread */
5939 pthread_kill(monitor_thread, SIGURG);
5940 } else {
5941 pthread_attr_init(&attr);
5942 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
5943 /* Start a new monitor */
5944 if (ast_pthread_create(&monitor_thread, &attr, do_monitor, NULL) < 0) {
5946 ast_log(LOG_ERROR, "Unable to start monitor thread.\n");
5947 return -1;
5948 }
5949 }
5951 return 0;
5952}
5953
5954/*--- unistim_request: PBX interface function ---*/
5955/* UNISTIM calls initiated by the PBX arrive here */
5956static struct ast_channel *unistim_request(const char *type, struct ast_format_cap *cap, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, const char *dest,
5957 int *cause)
5958{
5959 struct unistim_subchannel *sub, *sub_ring, *sub_trans;
5960 struct unistim_device *d;
5961 struct ast_channel *tmpc = NULL;
5962 char tmp[256];
5963
5966 struct ast_str *global_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
5968 "Asked to get a channel of unsupported format %s while capability is %s\n",
5969 ast_format_cap_get_names(cap, &cap_buf),
5970 ast_format_cap_get_names(global_cap, &global_buf));
5971 return NULL;
5972 }
5973
5974 ast_copy_string(tmp, dest, sizeof(tmp));
5975 if (ast_strlen_zero(tmp)) {
5976 ast_log(LOG_NOTICE, "Unistim channels require a device\n");
5977 return NULL;
5978 }
5980 if (!sub) {
5981 ast_log(LOG_NOTICE, "No available lines on: %s\n", dest);
5982 *cause = AST_CAUSE_CONGESTION;
5983 return NULL;
5984 }
5985 d = sub->parent->parent;
5986 sub_ring = get_sub(d, SUB_RING);
5987 sub_trans = get_sub(d, SUB_THREEWAY);
5988 /* Another request already in progress */
5989 if (!d->session) {
5991 *cause = AST_CAUSE_CONGESTION;
5992 return NULL;
5993 }
5994 if (sub_ring || sub_trans) {
5995 if (unistimdebug) {
5996 ast_verb(0, "Can't create channel, request already in progress: Busy!\n");
5997 }
5999 *cause = AST_CAUSE_BUSY;
6000 return NULL;
6001 }
6002 if (d->session->state == STATE_DIALPAGE) {
6003 if (unistimdebug) {
6004 ast_verb(0, "Can't create channel, user on dialpage: Busy!\n");
6005 }
6007 *cause = AST_CAUSE_BUSY;
6008 return NULL;
6009 }
6010
6011 if (get_avail_softkey(d->session, sub->parent->name) == -1) {
6012 if (unistimdebug) {
6013 ast_verb(0, "Can't create channel for line %s, all lines busy\n", sub->parent->name);
6014 }
6016 *cause = AST_CAUSE_BUSY;
6017 return NULL;
6018 }
6019 sub->subtype = SUB_RING;
6020 sub->softkey = -1;
6021
6023 tmpc = unistim_new(sub, AST_STATE_DOWN, assignedids, requestor);
6024 if (!tmpc) {
6025 ast_log(LOG_WARNING, "Unable to make channel for '%s'\n", tmp);
6026 }
6027 if (unistimdebug) {
6028 ast_verb(0, "unistim_request owner = %p\n", sub->owner);
6029 }
6031 /* and finish */
6032 return tmpc;
6033}
6034
6035static char *unistim_show_info(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
6036{
6037 struct unistim_device *device = devices;
6038 struct unistim_line *line;
6039 struct unistim_subchannel *sub;
6040 struct unistimsession *s;
6042
6043 switch (cmd) {
6044 case CLI_INIT:
6045 e->command = "unistim show info";
6046 e->usage =
6047 "Usage: unistim show info\n"
6048 " Dump internal structures.\n\n"
6049 " device\n"
6050 " ->line\n"
6051 " -->sub\n"
6052 " ==>key\n";
6053 return NULL;
6054
6055 case CLI_GENERATE:
6056 return NULL; /* no completion */
6057 }
6058
6059 if (a->argc != e->args) {
6060 return CLI_SHOWUSAGE;
6061 }
6062 ast_cli(a->fd, "Dumping internal structures:\n");
6064 while (device) {
6065 int i;
6066
6067 ast_cli(a->fd, "\nname=%s id=%s ha=%p sess=%p device=%p selected=%d height=%d\n",
6068 device->name, device->id, device->ha, device->session,
6069 device, device->selected, device->height);
6070 AST_LIST_LOCK(&device->lines);
6071 AST_LIST_TRAVERSE(&device->lines,line,list) {
6072 ast_cli(a->fd,
6073 "->name=%s fullname=%s exten=%s callid=%s cap=%s line=%p\n",
6074 line->name, line->fullname, line->exten, line->cid_num,
6075 ast_format_cap_get_names(line->cap, &cap_buf), line);
6076 }
6077 AST_LIST_UNLOCK(&device->lines);
6078
6079 AST_LIST_LOCK(&device->subs);
6080 AST_LIST_TRAVERSE(&device->subs, sub, list) {
6081 if (!sub) {
6082 continue;
6083 }
6084 ast_cli(a->fd,
6085 "-->subtype=%s chan=%p rtp=%p line=%p alreadygone=%d softkey=%d\n",
6086 subtype_tostr(sub->subtype), sub->owner, sub->rtp, sub->parent,
6087 sub->alreadygone, sub->softkey);
6088 }
6089 AST_LIST_UNLOCK(&device->subs);
6090
6091 for (i = 0; i < FAVNUM; i++) {
6092 if (!soft_key_visible(device, i)) {
6093 continue;
6094 }
6095 ast_cli(a->fd, "==> %d. dev=%s icon=%#-4x label=%-10s number=%-5s sub=%p line=%p\n",
6096 i, device->softkeydevice[i], (unsigned)device->softkeyicon[i], device->softkeylabel[i], device->softkeynumber[i],
6097 device->ssub[i], device->sline[i]);
6098 }
6099 device = device->next;
6100 }
6102 ast_cli(a->fd, "\nSessions:\n");
6104 s = sessions;
6105 while (s) {
6106 ast_cli(a->fd,
6107 "sin=%s timeout=%d state=%s macaddr=%s device=%p session=%p\n",
6108 ast_inet_ntoa(s->sin.sin_addr), s->timeout, ptestate_tostr(s->state), s->macaddr,
6109 s->device, s);
6110 s = s->next;
6111 }
6113
6114 return CLI_SUCCESS;
6115}
6116
6117static char *unistim_show_devices(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
6118{
6119 struct unistim_device *device = devices;
6120
6121 switch (cmd) {
6122 case CLI_INIT:
6123 e->command = "unistim show devices";
6124 e->usage =
6125 "Usage: unistim show devices\n"
6126 " Lists all known Unistim devices.\n";
6127 return NULL;
6128 case CLI_GENERATE:
6129 return NULL; /* no completion */
6130 }
6131
6132 if (a->argc != e->args)
6133 return CLI_SHOWUSAGE;
6134
6135 ast_cli(a->fd, "%-20.20s %-20.20s %-15.15s %-15.15s %s\n", "Name/username", "MAC", "Host", "Firmware", "Status");
6137 while (device) {
6138 ast_cli(a->fd, "%-20.20s %-20.20s %-15.15s %-15.15s %s\n",
6139 device->name, device->id,
6140 (!device->session) ? "(Unspecified)" : ast_inet_ntoa(device->session->sin.sin_addr),
6141 (!device->session) ? "(Unspecified)" : device->session->firmware,
6142 (!device->session) ? "UNKNOWN" : "OK");
6143 device = device->next;
6144 }
6146
6147 return CLI_SUCCESS;
6148}
6149
6150static char *unistim_sp(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
6151{
6152 BUFFSEND;
6153 struct unistim_subchannel *sub;
6154 int i, j = 0, len;
6155 unsigned char c, cc;
6156 char tmp[256];
6157
6158 switch (cmd) {
6159 case CLI_INIT:
6160 e->command = "unistim send packet";
6161 e->usage =
6162 "Usage: unistim send packet USTM/line@name hexa\n"
6163 " unistim send packet USTM/1000@hans 19040004\n";
6164 return NULL;
6165
6166 case CLI_GENERATE:
6167 return NULL; /* no completion */
6168 }
6169
6170 if (a->argc < 5) {
6171 return CLI_SHOWUSAGE;
6172 }
6173 if (strlen(a->argv[3]) < 9) {
6174 return CLI_SHOWUSAGE;
6175 }
6176 len = strlen(a->argv[4]);
6177 if (len % 2) {
6178 return CLI_SHOWUSAGE;
6179 }
6180 ast_copy_string(tmp, a->argv[3] + 5, sizeof(tmp));
6182 if (!sub) {
6183 ast_cli(a->fd, "Can't find '%s'\n", tmp);
6184 return CLI_SUCCESS;
6185 }
6186 if (!sub->parent->parent->session) {
6187 ast_cli(a->fd, "'%s' is not connected\n", tmp);
6188 return CLI_SUCCESS;
6189 }
6190 ast_cli(a->fd, "Sending '%s' to %s (%p)\n", a->argv[4], tmp, sub->parent->parent->session);
6191 for (i = 0; i < len; i++) {
6192 c = a->argv[4][i];
6193 if (c >= 'a') {
6194 c -= 'a' - 10;
6195 } else {
6196 c -= '0';
6197 }
6198 i++;
6199 cc = a->argv[4][i];
6200 if (cc >= 'a') {
6201 cc -= 'a' - 10;
6202 } else {
6203 cc -= '0';
6204 }
6205 tmp[j++] = (c << 4) | cc;
6206 }
6207 memcpy(buffsend + SIZE_HEADER, tmp, j);
6208 send_client(SIZE_HEADER + j, buffsend, sub->parent->parent->session);
6209 return CLI_SUCCESS;
6210}
6211
6212static char *unistim_do_debug(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
6213{
6214 switch (cmd) {
6215 case CLI_INIT:
6216 e->command = "unistim set debug {on|off}";
6217 e->usage =
6218 "Usage: unistim set debug\n"
6219 " Display debug messages.\n";
6220 return NULL;
6221
6222 case CLI_GENERATE:
6223 return NULL; /* no completion */
6224 }
6225
6226 if (a->argc != e->args) {
6227 return CLI_SHOWUSAGE;
6228 }
6229 if (!strcasecmp(a->argv[3], "on")) {
6230 unistimdebug = 1;
6231 ast_cli(a->fd, "UNISTIM Debugging Enabled\n");
6232 } else if (!strcasecmp(a->argv[3], "off")) {
6233 unistimdebug = 0;
6234 ast_cli(a->fd, "UNISTIM Debugging Disabled\n");
6235 } else {
6236 return CLI_SHOWUSAGE;
6237 }
6238 return CLI_SUCCESS;
6239}
6240
6241/*! \brief --- unistim_reload: Force reload of module from cli ---
6242 * Runs in the asterisk main thread, so don't do anything useful
6243 * but setting a flag and waiting for do_monitor to do the job
6244 * in our thread */
6245static char *unistim_reload(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
6246{
6247 switch (cmd) {
6248 case CLI_INIT:
6249 e->command = "unistim reload";
6250 e->usage =
6251 "Usage: unistim reload\n"
6252 " Reloads UNISTIM configuration from unistim.conf\n";
6253 return NULL;
6254
6255 case CLI_GENERATE:
6256 return NULL; /* no completion */
6257 }
6258
6259 if (e && a && a->argc != e->args) {
6260 return CLI_SHOWUSAGE;
6261 }
6262 reload();
6263
6264 return CLI_SUCCESS;
6265}
6266
6267static struct ast_cli_entry unistim_cli[] = {
6268 AST_CLI_DEFINE(unistim_reload, "Reload UNISTIM configuration"),
6269 AST_CLI_DEFINE(unistim_show_info, "Show UNISTIM info"),
6270 AST_CLI_DEFINE(unistim_show_devices, "Show UNISTIM devices"),
6271 AST_CLI_DEFINE(unistim_sp, "Send packet (for reverse engineering)"),
6272 AST_CLI_DEFINE(unistim_do_debug, "Toggle UNITSTIM debugging"),
6273};
6274
6275static void unquote(char *out, const char *src, int maxlen)
6276{
6277 int len = strlen(src);
6278 if (!len) {
6279 return;
6280 }
6281 if ((len > 1) && src[0] == '\"') {
6282 /* This is a quoted string */
6283 src++;
6284 /* Don't take more than what's there */
6285 len--;
6286 if (maxlen > len - 1) {
6287 maxlen = len - 1;
6288 }
6289 memcpy(out, src, maxlen);
6290 ((char *) out)[maxlen] = '\0';
6291 } else {
6292 memcpy(out, src, maxlen);
6293 }
6294 return;
6295}
6296
6297static int parse_bookmark(const char *text, struct unistim_device *d)
6298{
6299 char line[256];
6300 char *at;
6301 char *number;
6302 char *icon;
6303 int p;
6304 int len = strlen(text);
6305
6306 ast_copy_string(line, text, sizeof(line));
6307 /* Position specified ? */
6308 if ((len > 2) && (line[1] == '@')) {
6309 p = line[0];
6310 if ((p >= '0') && (p <= '5')) {
6311 p -= '0';
6312 } else {
6314 "Invalid position for bookmark : must be between 0 and 5\n");
6315 return 0;
6316 }
6317 if (d->softkeyicon[p] != 0) {
6318 ast_log(LOG_WARNING, "Invalid position %d for bookmark : already used:\n", p);
6319 return 0;
6320 }
6321 memmove(line, line + 2, sizeof(line) - 2);
6322 } else {
6323 /* No position specified, looking for a free slot */
6324 for (p = 0; p < FAVNUM; p++) {
6325 if (!d->softkeyicon[p]) {
6326 break;
6327 }
6328 }
6329 if (p == FAVNUM) {
6330 ast_log(LOG_WARNING, "No more free bookmark position\n");
6331 return 0;
6332 }
6333 }
6334 at = strchr(line, '@');
6335 if (!at) {
6336 ast_log(LOG_NOTICE, "Bookmark entry '%s' has no @ (at) sign!\n", text);
6337 return 0;
6338 }
6339 *at = '\0';
6340 at++;
6341 number = at;
6342 at = strchr(at, '@');
6343 if (ast_strlen_zero(number)) {
6344 ast_log(LOG_NOTICE, "Bookmark entry '%s' has no number\n", text);
6345 return 0;
6346 }
6347 if (ast_strlen_zero(line)) {
6348 ast_log(LOG_NOTICE, "Bookmark entry '%s' has no description\n", text);
6349 return 0;
6350 }
6351
6352 at = strchr(number, '@');
6353 if (!at) {
6354 d->softkeyicon[p] = FAV_ICON_SHARP; /* default icon */
6355 } else {
6356 *at = '\0';
6357 at++;
6358 icon = at;
6359 if (ast_strlen_zero(icon)) {
6360 ast_log(LOG_NOTICE, "Bookmark entry '%s' has no icon value\n", text);
6361 return 0;
6362 }
6363 if (strncmp(icon, "USTM/", 5)) {
6364 d->softkeyicon[p] = atoi(icon);
6365 } else {
6366 d->softkeyicon[p] = 1;
6367 ast_copy_string(d->softkeydevice[p], icon + 5, sizeof(d->softkeydevice[p]));
6368 }
6369 }
6370 ast_copy_string(d->softkeylabel[p], line, sizeof(d->softkeylabel[p]));
6371 ast_copy_string(d->softkeynumber[p], number, sizeof(d->softkeynumber[p]));
6372 if (unistimdebug) {
6373 ast_verb(0, "New bookmark at pos %d label='%s' number='%s' icon=%#x\n",
6374 p, d->softkeylabel[p], d->softkeynumber[p], (unsigned)d->softkeyicon[p]);
6375 }
6376 return 1;
6377}
6378
6379/* Looking for dynamic icons entries in bookmarks */
6380static void finish_bookmark(void)
6381{
6382 struct unistim_device *d = devices;
6383 int i;
6385 while (d) {
6386 for (i = 0; i < 6; i++) {
6387 if (d->softkeyicon[i] == 1) { /* Something for us */
6388 struct unistim_device *d2 = devices;
6389 while (d2) {
6390 if (!strcmp(d->softkeydevice[i], d2->name)) {
6391 d->sp[i] = d2;
6392 d->softkeyicon[i] = 0;
6393 break;
6394 }
6395 d2 = d2->next;
6396 }
6397 if (d->sp[i] == NULL) {
6398 ast_log(LOG_NOTICE, "Bookmark entry with device %s not found\n",
6399 d->softkeydevice[i]);
6400 }
6401 }
6402 }
6403 d = d->next;
6404 }
6406}
6407
6408static struct unistim_line *find_line_by_number(struct unistim_device *d, const char *val) {
6409 struct unistim_line *l, *ret = NULL;
6410
6411 AST_LIST_LOCK(&d->lines);
6412 AST_LIST_TRAVERSE(&d->lines, l, list) {
6413 if (!strcmp(l->name, val)) {
6414 ret = l;
6415 break;
6416 }
6417 }
6418 AST_LIST_UNLOCK(&d->lines);
6419 return ret;
6420}
6421
6422static void delete_device(struct unistim_device *d)
6423{
6424 struct unistim_line *l;
6425 struct unistim_subchannel *sub;
6426 struct unistimsession *s;
6427
6428 if (unistimdebug) {
6429 ast_verb(0, "Removing device '%s'\n", d->name);
6430 }
6431 AST_LIST_LOCK(&d->subs);
6432 AST_LIST_TRAVERSE_SAFE_BEGIN(&d->subs, sub, list){
6433 if (sub->subtype == SUB_REAL) {
6434 if (sub->owner) {
6436 "Device '%s' was not deleted : a call is in progress. Try again later.\n",
6437 d->name);
6438 AST_LIST_UNLOCK(&d->subs);
6439 return;
6440 }
6441 }
6442 if (sub->subtype == SUB_THREEWAY) {
6444 "Device '%s' with threeway call subchannels allocated, aborting.\n",
6445 d->name);
6446 AST_LIST_UNLOCK(&d->subs);
6447 return;
6448 }
6450 ast_mutex_destroy(&sub->lock);
6451 ast_free(sub);
6452 }
6454 AST_LIST_UNLOCK(&d->subs);
6455
6456
6457 AST_LIST_LOCK(&d->lines);
6458 AST_LIST_TRAVERSE_SAFE_BEGIN(&d->lines, l, list){
6462 }
6464 AST_LIST_UNLOCK(&d->lines);
6465
6466 if (d->session) {
6467 if (sessions == d->session) {
6468 sessions = d->session->next;
6469 } else {
6470 s = sessions;
6471 while (s) {
6472 if (s->next == d->session) {
6473 s->next = d->session->next;
6474 break;
6475 }
6476 s = s->next;
6477 }
6478 }
6479 ast_mutex_destroy(&d->session->lock);
6480 ast_free(d->session);
6481 }
6482 if (devices == d) {
6483 devices = d->next;
6484 } else {
6485 struct unistim_device *d2 = devices;
6486 while (d2) {
6487 if (d2->next == d) {
6488 d2->next = d->next;
6489 break;
6490 }
6491 d2 = d2->next;
6492 }
6493 }
6494 if (d->tz) {
6495 d->tz = ast_tone_zone_unref(d->tz);
6496 }
6497 ast_mutex_destroy(&d->lock);
6498 ast_free(d);
6499}
6500
6501static struct unistim_device *build_device(const char *cat, const struct ast_variable *v)
6502{
6503 struct unistim_device *d;
6504 struct unistim_line *l = NULL, *lt = NULL;
6505 int create = 1;
6506 int nbsoftkey, dateformat, timeformat, callhistory, sharpdial, linecnt;
6507 char linelabel[AST_MAX_EXTENSION];
6508 signed char ringvolume, ringstyle, cwvolume, cwstyle;
6509
6510 /* First, we need to know if we already have this name in our list */
6511 /* Get a lock for the device chained list */
6513 d = devices;
6514 while (d) {
6515 if (!strcmp(d->name, cat)) {
6516 /* Yep, we alreay have this one */
6517 if (unistimsock < 0) {
6518 /* It's a dupe */
6519 ast_log(LOG_WARNING, "Duplicate entry found (%s), ignoring.\n", cat);
6521 return NULL;
6522 }
6523 /* we're reloading right now */
6524 create = 0;
6525 break;
6526 }
6527 d = d->next;
6528 }
6530 if (!(lt = ast_calloc(1, sizeof(*lt)))) {
6531 return NULL;
6532 }
6533 if (create) {
6534 if (!(d = ast_calloc(1, sizeof(*d)))) {
6535 return NULL;
6536 }
6537 ast_mutex_init(&d->lock);
6538 ast_copy_string(d->name, cat, sizeof(d->name));
6539
6540 ast_copy_string(d->context, DEFAULTCONTEXT, sizeof(d->context));
6541 d->contrast = -1;
6542 d->output = OUTPUT_HANDSET;
6543 d->previous_output = OUTPUT_HANDSET;
6544 d->volume = VOLUME_LOW;
6545 d->microphone = MUTE_OFF;
6546 d->height = DEFAULTHEIGHT;
6547 d->selected = -1;
6548 d->interdigit_timer = DEFAULT_INTERDIGIT_TIMER;
6549 } else {
6550 /* Delete existing line information */
6551 AST_LIST_LOCK(&d->lines);
6552 AST_LIST_TRAVERSE_SAFE_BEGIN(&d->lines, l, list){
6555 }
6557 AST_LIST_UNLOCK(&d->lines);
6558
6559 /* reset bookmarks */
6560 memset(d->softkeylabel, 0, sizeof(d->softkeylabel));
6561 memset(d->softkeynumber, 0, sizeof(d->softkeynumber));
6562 memset(d->softkeyicon, 0, sizeof(d->softkeyicon));
6563 memset(d->softkeydevice, 0, sizeof(d->softkeydevice));
6564 memset(d->ssub, 0, sizeof(d->ssub));
6565 memset(d->sline, 0, sizeof(d->sline));
6566 memset(d->sp, 0, sizeof(d->sp));
6567 }
6568 linelabel[0] = '\0';
6569 dateformat = 1;
6570 timeformat = 1;
6571 ringvolume = 2;
6572 cwvolume = 1;
6573 callhistory = 1;
6574 sharpdial = 0;
6575 ringstyle = 3;
6576 cwstyle = 2;
6577 nbsoftkey = 0;
6578 linecnt = 0;
6579 d->dtmfduration = 0;
6580 while (v) {
6581 if (!strcasecmp(v->name, "rtp_port")) {
6582 d->rtp_port = atoi(v->value);
6583 } else if (!strcasecmp(v->name, "rtp_method")) {
6584 d->rtp_method = atoi(v->value);
6585 } else if (!strcasecmp(v->name, "status_method")) {
6586 d->status_method = atoi(v->value);
6587 } else if (!strcasecmp(v->name, "device")) {
6588 ast_copy_string(d->id, v->value, sizeof(d->id));
6589 } else if (!strcasecmp(v->name, "tn")) {
6590 ast_copy_string(d->extension_number, v->value, sizeof(d->extension_number));
6591 } else if (!strcasecmp(v->name, "permit") || !strcasecmp(v->name, "deny")) {
6592 int acl_error = 0;
6593 d->ha = ast_append_ha(v->name, v->value, d->ha, &acl_error);
6594 if (acl_error) {
6595 ast_log(LOG_ERROR, "Invalid ACL '%s' specified for device '%s' on line %d. Deleting device\n",
6596 v->value, cat, v->lineno);
6598 return NULL;
6599 }
6600 } else if (!strcasecmp(v->name, "context")) {
6601 ast_copy_string(d->context, v->value, sizeof(d->context));
6602 } else if (!strcasecmp(v->name, "maintext0")) {
6603 unquote(d->maintext0, v->value, sizeof(d->maintext0) - 1);
6604 } else if (!strcasecmp(v->name, "maintext1")) {
6605 unquote(d->maintext1, v->value, sizeof(d->maintext1) - 1);
6606 } else if (!strcasecmp(v->name, "maintext2")) {
6607 unquote(d->maintext2, v->value, sizeof(d->maintext2) - 1);
6608 } else if (!strcasecmp(v->name, "titledefault")) {
6609 unquote(d->titledefault, v->value, sizeof(d->titledefault) - 1);
6610 } else if (!strcasecmp(v->name, "dateformat")) {
6611 dateformat = atoi(v->value);
6612 } else if (!strcasecmp(v->name, "timeformat")) {
6613 timeformat = atoi(v->value);
6614 } else if (!strcasecmp(v->name, "contrast")) {
6615 d->contrast = atoi(v->value);
6616 if ((d->contrast < 0) || (d->contrast > 15)) {
6617 ast_log(LOG_WARNING, "contrast must be beetween 0 and 15\n");
6618 d->contrast = 8;
6619 }
6620 } else if (!strcasecmp(v->name, "nat")) {
6621 d->nat = ast_true(v->value);
6622 } else if (!strcasecmp(v->name, "hasexp")) {
6623 d->hasexp = ast_true(v->value);
6624 } else if (!strcasecmp(v->name, "ringvolume")) {
6625 ringvolume = atoi(v->value);
6626 } else if (!strcasecmp(v->name, "ringstyle")) {
6627 ringstyle = atoi(v->value);
6628 } else if (!strcasecmp(v->name, "cwvolume")) {
6629 cwvolume = atoi(v->value);
6630 } else if (!strcasecmp(v->name, "cwstyle")) {
6631 cwstyle = atoi(v->value);
6632 } else if (!strcasecmp(v->name, "callhistory")) {
6633 callhistory = atoi(v->value);
6634 } else if (!strcasecmp(v->name, "sharpdial")) {
6635 sharpdial = ast_true(v->value) ? 1 : 0;
6636 } else if (!strcasecmp(v->name, "interdigit_timer")) {
6637 d->interdigit_timer = atoi(v->value);
6638 } else if (!strcasecmp(v->name, "dtmf_duration")) {
6639 d->dtmfduration = atoi(v->value);
6640 if (d->dtmfduration > 150) {
6641 d->dtmfduration = 150;
6642 }
6643 } else if (!strcasecmp(v->name, "callerid")) {
6644 if (!strcasecmp(v->value, "asreceived")) {
6645 lt->cid_num[0] = '\0';
6646 } else {
6647 ast_copy_string(lt->cid_num, v->value, sizeof(lt->cid_num));
6648 }
6649 } else if (!strcasecmp(v->name, "language")) {
6650 ast_copy_string(d->language, v->value, sizeof(d->language));
6651 } else if (!strcasecmp(v->name, "country")) {
6652 ast_copy_string(d->country, v->value, sizeof(d->country));
6653 } else if (!strcasecmp(v->name, "accountcode")) {
6654 ast_copy_string(lt->accountcode, v->value, sizeof(lt->accountcode));
6655 } else if (!strcasecmp(v->name, "amaflags")) {
6656 int y;
6658 if (y < 0) {
6659 ast_log(LOG_WARNING, "Invalid AMA flags: %s at line %d\n", v->value,
6660 v->lineno);
6661 } else {
6662 lt->amaflags = y;
6663 }
6664 } else if (!strcasecmp(v->name, "musiconhold")) {
6665 ast_copy_string(lt->musicclass, v->value, sizeof(lt->musicclass));
6666 } else if (!strcasecmp(v->name, "callgroup")) {
6667 lt->callgroup = ast_get_group(v->value);
6668 } else if (!strcasecmp(v->name, "pickupgroup")) {
6669 lt->pickupgroup = ast_get_group(v->value);
6670 } else if (!strcasecmp(v->name, "mailbox")) {
6671 ast_copy_string(lt->mailbox, v->value, sizeof(lt->mailbox));
6672 } else if (!strcasecmp(v->name, "parkinglot")) {
6673 ast_copy_string(lt->parkinglot, v->value, sizeof(lt->parkinglot));
6674 } else if (!strcasecmp(v->name, "linelabel")) {
6675 unquote(linelabel, v->value, sizeof(linelabel) - 1);
6676 } else if (!strcasecmp(v->name, "extension")) {
6677 if (!strcasecmp(v->value, "none")) {
6678 d->extension = EXTENSION_NONE;
6679 } else if (!strcasecmp(v->value, "ask")) {
6680 d->extension = EXTENSION_ASK;
6681 } else if (!strcasecmp(v->value, "line")) {
6682 d->extension = EXTENSION_LINE;
6683 } else {
6684 ast_log(LOG_WARNING, "Unknown extension option.\n");
6685 }
6686 } else if (!strcasecmp(v->name, "bookmark")) {
6687 if (nbsoftkey > 5) {
6689 "More than 6 softkeys defined. Ignoring new entries.\n");
6690 } else {
6691 if (parse_bookmark(v->value, d)) {
6692 nbsoftkey++;
6693 }
6694 }
6695 } else if (!strcasecmp(v->name, "line")) {
6696 int len = strlen(linelabel);
6697 int create_line = 0;
6698
6699 l = find_line_by_number(d, v->value);
6700 if (!l) { /* If line still not exists */
6701 if (!(l = unistim_line_alloc())) {
6702 ast_free(d);
6703 ast_free(lt);
6704 return NULL;
6705 }
6706 lt->cap = l->cap;
6707 memcpy(l, lt, sizeof(*l));
6708 ast_mutex_init(&l->lock);
6709 create_line = 1;
6710 }
6711 d->to_delete = 0;
6712
6713 /* Set softkey info for new line*/
6714 d->sline[nbsoftkey] = l;
6715 d->softkeyicon[nbsoftkey] = FAV_LINE_ICON;
6716 if (!len) { /* label is undefined ? */
6717 ast_copy_string(d->softkeylabel[nbsoftkey], v->value, sizeof(d->softkeylabel[nbsoftkey]));
6718 } else {
6719 int softkeylinepos = 0;
6720 if ((len > 2) && (linelabel[1] == '@')) {
6721 softkeylinepos = linelabel[0];
6722 if ((softkeylinepos >= '0') && (softkeylinepos <= '5')) {
6723 softkeylinepos -= '0';
6724 d->softkeyicon[nbsoftkey] = FAV_ICON_NONE;
6725 } else {
6727 "Invalid position for linelabel : must be between 0 and 5\n");
6728 }
6729 ast_copy_string(d->softkeylabel[softkeylinepos], linelabel + 2,
6730 sizeof(d->softkeylabel[softkeylinepos]));
6731 d->softkeyicon[softkeylinepos] = FAV_LINE_ICON;
6732 } else {
6733 ast_copy_string(d->softkeylabel[nbsoftkey], linelabel,
6734 sizeof(d->softkeylabel[nbsoftkey]));
6735 }
6736 }
6737 nbsoftkey++;
6738
6739 if (create_line) {
6740 ast_copy_string(l->name, v->value, sizeof(l->name));
6741 snprintf(l->fullname, sizeof(l->fullname), "USTM/%s@%s", l->name, d->name);
6742 if (!ast_strlen_zero(l->mailbox)) {
6743 if (unistimdebug) {
6744 ast_verb(3, "Setting mailbox '%s' on %s@%s\n", l->mailbox, d->name, l->name);
6745 }
6746 }
6748 l->parent = d;
6749 linecnt++;
6750 AST_LIST_LOCK(&d->lines);
6751 AST_LIST_INSERT_TAIL(&d->lines, l, list);
6752 AST_LIST_UNLOCK(&d->lines);
6753 }
6754 } else if (!strcasecmp(v->name, "height")) {
6755 /* Allow the user to lower the expected display lines on the phone
6756 * For example the Nortel i2001 and i2002 only have one ! */
6757 d->height = atoi(v->value);
6758 } else
6759 ast_log(LOG_WARNING, "Don't know keyword '%s' at line %d\n", v->name,
6760 v->lineno);
6761 v = v->next;
6762 }
6763 ast_free(lt);
6764 if (linecnt == 0) {
6765 ast_log(LOG_ERROR, "An Unistim device must have at least one line!\n");
6766 ast_free(d);
6767 return NULL;
6768 }
6769 d->ringvolume = ringvolume;
6770 d->ringstyle = ringstyle;
6771 d->cwvolume = cwvolume;
6772 d->cwstyle = cwstyle;
6773 d->callhistory = callhistory;
6774 d->sharp_dial = sharpdial;
6775 d->tz = ast_get_indication_zone(d->country);
6776 if ((d->tz == NULL) && !ast_strlen_zero(d->country)) {
6777 ast_log(LOG_WARNING, "Country '%s' was not found in indications.conf\n",
6778 d->country);
6779 }
6780 d->datetimeformat = 48 + (dateformat * 4);
6781 d->datetimeformat += timeformat;
6783 (!ast_strlen_zero(d->extension_number))) {
6784 d->extension = EXTENSION_TN;
6785 if (!ast_strlen_zero(d->id)) {
6787 "tn= and device= can't be used together. Ignoring device= entry\n");
6788 }
6789 d->id[0] = 'T'; /* magic : this is a tn entry */
6790 ast_copy_string((d->id) + 1, d->extension_number, sizeof(d->id) - 1);
6791 d->extension_number[0] = '\0';
6792 } else if (ast_strlen_zero(d->id)) {
6793 if (strcmp(d->name, "template")) {
6794 ast_log(LOG_ERROR, "You must specify the mac address with device=\n");
6795 if (d->tz) {
6796 d->tz = ast_tone_zone_unref(d->tz);
6797 }
6798 ast_free(d);
6799 return NULL;
6800 } else {
6801 strcpy(d->id, "000000000000");
6802 }
6803 }
6804 if (!d->rtp_port) {
6805 d->rtp_port = 10000;
6806 }
6807 if (d->contrast == -1) {
6808 d->contrast = 8;
6809 }
6810 if (ast_strlen_zero(d->maintext1)) {
6811 strcpy(d->maintext1, d->name);
6812 }
6813 if (ast_strlen_zero(d->titledefault)) {
6814 struct ast_tm tm = { 0, };
6815 struct timeval cur_time = ast_tvnow();
6816
6817 if ((ast_localtime(&cur_time, &tm, 0)) == 0 || ast_strlen_zero(tm.tm_zone)) {
6818 ast_log(LOG_WARNING, "Error in ast_localtime()\n");
6819 ast_copy_string(d->titledefault, "UNISTIM for*", 12);
6820 } else {
6821 if (strlen(tm.tm_zone) < 4) {
6822 strcpy(d->titledefault, "TimeZone ");
6823 strcat(d->titledefault, tm.tm_zone);
6824 } else if (strlen(tm.tm_zone) < 9) {
6825 strcpy(d->titledefault, "TZ ");
6826 strcat(d->titledefault, tm.tm_zone);
6827 } else {
6828 ast_copy_string(d->titledefault, tm.tm_zone, 12);
6829 }
6830 }
6831 }
6832 /* Update the chained link if it's a new device */
6833 if (create) {
6835 d->next = devices;
6836 devices = d;
6838 ast_verb(3, "Added device '%s'\n", d->name);
6839 } else {
6840 ast_verb(3, "Device '%s' reloaded\n", d->name);
6841 }
6842 return d;
6843}
6844
6845/*--- reload_config: Re-read unistim.conf config file ---*/
6846static int reload_config(void)
6847{
6848 struct ast_config *cfg;
6849 struct ast_variable *v;
6850 struct sockaddr_in bindaddr = { 0, };
6851 char *config = "unistim.conf";
6852 char *cat;
6853 struct unistim_device *d;
6854 const int reuseFlag = 1;
6855 struct unistimsession *s;
6856 struct ast_flags config_flags = { 0, };
6857
6858 cfg = ast_config_load(config, config_flags);
6859 /* We *must* have a config file otherwise stop immediately */
6860 if (!cfg) {
6861 ast_log(LOG_ERROR, "Unable to load config %s\n", config);
6862 return -1;
6863 } else if (cfg == CONFIG_STATUS_FILEINVALID) {
6864 ast_log(LOG_ERROR, "Config file %s is in an invalid format. Aborting.\n", config);
6865 return -1;
6866 }
6867
6868 /* Copy the default jb config over global_jbconf */
6869 memcpy(&global_jbconf, &default_jbconf, sizeof(struct ast_jb_conf));
6870
6871 unistim_keepalive = 120;
6872 unistim_port = 0;
6873 v = ast_variable_browse(cfg, "general");
6874 while (v) {
6875 /* handle jb conf */
6876 if (!ast_jb_read_conf(&global_jbconf, v->name, v->value)) {
6877 continue;
6878 }
6879 if (!strcasecmp(v->name, "keepalive")) {
6880 unistim_keepalive = atoi(v->value);
6881 } else if (!strcasecmp(v->name, "port")) {
6882 unistim_port = atoi(v->value);
6883 } else if (!strcasecmp(v->name, "tos")) {
6884 if (ast_str2tos(v->value, &qos.tos)) {
6885 ast_log(LOG_WARNING, "Invalid tos value at line %d, refer to QoS documentation\n", v->lineno);
6886 }
6887 } else if (!strcasecmp(v->name, "tos_audio")) {
6888 if (ast_str2tos(v->value, &qos.tos_audio)) {
6889 ast_log(LOG_WARNING, "Invalid tos_audio value at line %d, refer to QoS documentation\n", v->lineno);
6890 }
6891 } else if (!strcasecmp(v->name, "cos")) {
6892 if (ast_str2cos(v->value, &qos.cos)) {
6893 ast_log(LOG_WARNING, "Invalid cos value at line %d, refer to QoS documentation\n", v->lineno);
6894 }
6895 } else if (!strcasecmp(v->name, "cos_audio")) {
6896 if (ast_str2cos(v->value, &qos.cos_audio)) {
6897 ast_log(LOG_WARNING, "Invalid cos_audio value at line %d, refer to QoS documentation\n", v->lineno);
6898 }
6899 } else if (!strcasecmp(v->name, "debug")) {
6900 if (!strcasecmp(v->value, "no")) {
6901 unistimdebug = 0;
6902 } else if (!strcasecmp(v->value, "yes")) {
6903 unistimdebug = 1;
6904 }
6905 } else if (!strcasecmp(v->name, "autoprovisioning")) {
6906 if (!strcasecmp(v->value, "no")) {
6908 } else if (!strcasecmp(v->value, "yes")) {
6910 } else if (!strcasecmp(v->value, "tn")) {
6912 } else {
6913 ast_log(LOG_WARNING, "Unknown autoprovisioning option.\n");
6914 }
6915 } else if (!strcasecmp(v->name, "public_ip")) {
6916 if (!ast_strlen_zero(v->value)) {
6917 struct ast_sockaddr addr = { {0,} };
6918 if (ast_sockaddr_resolve_first_af(&addr, v->value, PARSE_PORT_FORBID, AF_INET)) {
6919 ast_log(LOG_WARNING, "Invalid address: %s\n", v->value);
6920 } else {
6922 }
6923 }
6924 }
6925 v = v->next;
6926 }
6927 if ((unistim_keepalive < 10) ||
6929 255 - (((NB_MAX_RETRANSMIT + 1) * RETRANSMIT_TIMER) / 1000))) {
6930 ast_log(LOG_ERROR, "keepalive is invalid in %s\n", config);
6931 ast_config_destroy(cfg);
6932 return -1;
6933 }
6934 packet_send_ping[4] =
6936 if ((unistim_port < 1) || (unistim_port > 65535)) {
6937 ast_log(LOG_ERROR, "port is not set or invalid in %s\n", config);
6938 ast_config_destroy(cfg);
6939 return -1;
6940 }
6941 unistim_keepalive *= 1000;
6942
6944 d = devices;
6945 while (d) {
6946 if (d->to_delete >= 0) {
6947 d->to_delete = 1;
6948 }
6949 d = d->next;
6950 }
6952 /* load the device sections */
6953 cat = ast_category_browse(cfg, NULL);
6954 while (cat) {
6955 if (strcasecmp(cat, "general")) {
6956 d = build_device(cat, ast_variable_browse(cfg, cat));
6957 }
6958 cat = ast_category_browse(cfg, cat);
6959 }
6961 d = devices;
6962 while (d) {
6963 if (d->to_delete) {
6965 d = devices;
6966 continue;
6967 }
6968 d = d->next;
6969 }
6972 ast_config_destroy(cfg);
6974 s = sessions;
6975 while (s) {
6976 if (s->device) {
6978 if (ast_strlen_zero(s->device->language)) {
6979 struct unistim_languages lang;
6982 }
6983 }
6984 s = s->next;
6985 }
6987 /* We don't recreate a socket when reloading (locks would be necessary). */
6988 if (unistimsock > -1) {
6989 return 0;
6990 }
6991 bindaddr.sin_addr.s_addr = INADDR_ANY;
6992 bindaddr.sin_port = htons(unistim_port);
6993 bindaddr.sin_family = AF_INET;
6994 unistimsock = socket(AF_INET, SOCK_DGRAM, 0);
6995 if (unistimsock < 0) {
6996 ast_log(LOG_WARNING, "Unable to create UNISTIM socket: %s\n", strerror(errno));
6997 return -1;
6998 }
6999#ifdef HAVE_PKTINFO
7000 {
7001 const int pktinfoFlag = 1;
7002 setsockopt(unistimsock, IPPROTO_IP, IP_PKTINFO, &pktinfoFlag,
7003 sizeof(pktinfoFlag));
7004 }
7005#else
7006 if (public_ip.sin_family == 0) {
7008 "Your OS does not support IP_PKTINFO, you must set public_ip.\n");
7009 unistimsock = -1;
7010 return -1;
7011 }
7012#endif
7013 setsockopt(unistimsock, SOL_SOCKET, SO_REUSEADDR, (const char *) &reuseFlag,
7014 sizeof(reuseFlag));
7015 if (bind(unistimsock, (struct sockaddr *) &bindaddr, sizeof(bindaddr)) < 0) {
7016 ast_log(LOG_WARNING, "Failed to bind to %s:%d: %s\n",
7017 ast_inet_ntoa(bindaddr.sin_addr), htons(bindaddr.sin_port),
7018 strerror(errno));
7019 close(unistimsock);
7020 unistimsock = -1;
7021 } else {
7022 ast_verb(2, "UNISTIM Listening on %s:%d\n", ast_inet_ntoa(bindaddr.sin_addr), htons(bindaddr.sin_port));
7023 ast_set_qos(unistimsock, qos.tos, qos.cos, "UNISTIM");
7024 }
7025 return 0;
7026}
7027
7028static enum ast_rtp_glue_result unistim_get_rtp_peer(struct ast_channel *chan, struct ast_rtp_instance **instance)
7029{
7031
7032 if (!sub) {
7034 }
7035 if (!sub->rtp) {
7037 }
7038
7039 ao2_ref(sub->rtp, +1);
7040 *instance = sub->rtp;
7041
7043}
7044
7045static int unistim_set_rtp_peer(struct ast_channel *chan, struct ast_rtp_instance *rtp, struct ast_rtp_instance *vrtp, struct ast_rtp_instance *trtp, const struct ast_format_cap *codecs, int nat_active)
7046{
7048 struct sockaddr_in them = { 0, };
7049 struct sockaddr_in us = { 0, };
7050
7051 if (!rtp) {
7052 return 0;
7053 }
7054
7055 sub = (struct unistim_subchannel *) ast_channel_tech_pvt(chan);
7056 if (!sub) {
7057 ast_log(LOG_ERROR, "No Private Structure, this is bad\n");
7058 return -1;
7059 }
7060 {
7061 struct ast_sockaddr tmp;
7063 ast_sockaddr_to_sin(&tmp, &them);
7065 ast_sockaddr_to_sin(&tmp, &us);
7066 }
7067
7068 /* TODO: Set rtp on phone in case of direct rtp (not implemented) */
7069
7070 return 0;
7071}
7072
7074 .type = channel_type,
7075 .get_rtp_info = unistim_get_rtp_peer,
7076 .update_peer = unistim_set_rtp_peer,
7077};
7078
7079/*--- load_module: PBX load module - initialization ---*/
7081{
7082 int res;
7083
7085 goto buff_failed;
7086 }
7088 goto buff_failed;
7089 }
7090
7094
7095 if (!(buff = ast_malloc(SIZE_PAGE))) {
7096 goto buff_failed;
7097 }
7098
7100 if (!io) {
7101 ast_log(LOG_ERROR, "Failed to allocate IO context\n");
7102 goto io_failed;
7103 }
7104
7106 if (!sched) {
7107 ast_log(LOG_ERROR, "Failed to allocate scheduler context\n");
7108 goto sched_failed;
7109 }
7110
7111 res = reload_config();
7112 if (res) {
7114 ao2_ref(global_cap, -1);
7118 }
7119 /* Make sure we can register our unistim channel type */
7121 ast_log(LOG_ERROR, "Unable to register channel type '%s'\n", channel_type);
7122 goto chanreg_failed;
7123 }
7124
7126
7128
7130
7132
7133chanreg_failed:
7134 /*! XXX \todo Leaking anything allocated by reload_config() ... */
7136 sched = NULL;
7137sched_failed:
7139 io = NULL;
7140io_failed:
7141 ast_free(buff);
7142 buff = NULL;
7143buff_failed:
7145 global_cap = NULL;
7149}
7150
7151static int unload_module(void)
7152{
7153 /* First, take us out of the channel loop */
7154 if (sched) {
7156 }
7157
7159
7163
7166 pthread_cancel(monitor_thread);
7167 pthread_kill(monitor_thread, SIGURG);
7168 pthread_join(monitor_thread, NULL);
7169 }
7172
7173 if (buff) {
7174 ast_free(buff);
7175 }
7176 if (unistimsock > -1) {
7177 close(unistimsock);
7178 }
7179 ao2_ref(global_cap, -1);
7180
7181 return 0;
7182}
7183
7184/*! reload: Part of Asterisk module interface ---*/
7185int reload(void)
7186{
7187 if (unistimdebug) {
7188 ast_verb(0, "reload unistim\n");
7189 }
7191 if (!unistim_reloading) {
7193 }
7195
7197
7198 return 0;
7199}
7200
7201AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "UNISTIM Protocol (USTM)",
7202 .support_level = AST_MODULE_SUPPORT_EXTENDED,
7203 .load = load_module,
7204 .unload = unload_module,
7205 .reload = reload,
void ast_jb_configure(struct ast_channel *chan, const struct ast_jb_conf *conf)
Configures a jitterbuffer on a channel.
Definition: abstract_jb.c:593
int ast_jb_read_conf(struct ast_jb_conf *conf, const char *varname, const char *value)
Sets jitterbuffer configuration property.
Definition: abstract_jb.c:545
Access Control of various sorts.
int ast_str2tos(const char *value, unsigned int *tos)
Convert a string to the appropriate TOS value.
Definition: acl.c:966
int ast_str2cos(const char *value, unsigned int *cos)
Convert a string to the appropriate COS value.
Definition: acl.c:952
struct ast_ha * ast_append_ha(const char *sense, const char *stuff, struct ast_ha *path, int *error)
Add a new rule to a list of HAs.
Definition: acl.c:712
static const struct adsi_event events[]
Definition: app_adsiprog.c:85
char digit
jack_status_t status
Definition: app_jack.c:146
const char * str
Definition: app_jack.c:147
char * text
Definition: app_queue.c:1639
static volatile unsigned int seq
Definition: app_sms.c:120
Persistent data storage (akin to *doze registry)
int ast_db_get(const char *family, const char *key, char *value, int valuelen)
Get key value specified by family/key.
Definition: main/db.c:427
Asterisk main include file. File version handling, generic pbx functions.
static struct ast_mansession session
#define ast_free(a)
Definition: astmm.h:180
#define ast_strdup(str)
A wrapper for strdup()
Definition: astmm.h:241
#define ast_strdupa(s)
duplicate a string in memory from the stack
Definition: astmm.h:298
#define ast_calloc(num, len)
A wrapper for calloc()
Definition: astmm.h:202
#define ast_malloc(len)
A wrapper for malloc()
Definition: astmm.h:191
#define ast_log
Definition: astobj2.c:42
#define ao2_link(container, obj)
Add an object to a container.
Definition: astobj2.h:1532
@ CMP_MATCH
Definition: astobj2.h:1027
@ CMP_STOP
Definition: astobj2.h:1028
#define OBJ_POINTER
Definition: astobj2.h:1150
@ AO2_ALLOC_OPT_LOCK_MUTEX
Definition: astobj2.h:363
#define ao2_cleanup(obj)
Definition: astobj2.h:1934
#define ao2_find(container, arg, flags)
Definition: astobj2.h:1736
#define ao2_ref(o, delta)
Reference/unreference an object and return the old refcount.
Definition: astobj2.h:459
#define ao2_alloc(data_size, destructor_fn)
Definition: astobj2.h:409
#define ao2_container_alloc_hash(ao2_options, container_options, n_buckets, hash_fn, sort_fn, cmp_fn)
Allocate and initialize a hash container with the desired number of buckets.
Definition: astobj2.h:1303
Bridging API.
@ AST_BRIDGE_TRANSFER_NOT_PERMITTED
Definition: bridge.h:1102
@ AST_BRIDGE_TRANSFER_SUCCESS
Definition: bridge.h:1100
@ AST_BRIDGE_TRANSFER_INVALID
Definition: bridge.h:1104
@ AST_BRIDGE_TRANSFER_FAIL
Definition: bridge.h:1106
enum ast_transfer_result ast_bridge_transfer_attended(struct ast_channel *to_transferee, struct ast_channel *to_transfer_target)
Attended transfer.
Definition: bridge.c:4677
static int tmp()
Definition: bt_open.c:389
CallerID (and other GR30) management and generation Includes code and algorithms from the Zapata libr...
int ast_callerid_parse(char *instr, char **name, char **location)
Destructively parse inbuf into name and location (or number)
Definition: callerid.c:1063
Internal Asterisk hangup causes.
#define AST_CAUSE_SWITCH_CONGESTION
Definition: causes.h:123
#define AST_CAUSE_CONGESTION
Definition: causes.h:153
#define AST_CAUSE_CALL_REJECTED
Definition: causes.h:111
#define AST_CAUSE_NETWORK_OUT_OF_ORDER
Definition: causes.h:121
#define AST_CAUSE_ANSWERED_ELSEWHERE
Definition: causes.h:114
#define AST_CAUSE_BUSY
Definition: causes.h:149
#define AST_CAUSE_NORMAL_CLEARING
Definition: causes.h:106
static char * tz
Definition: cdr_pgsql.c:71
static const char type[]
Definition: chan_ooh323.c:109
struct ast_sockaddr bindaddr
Definition: chan_ooh323.c:353
static const char config[]
Definition: chan_ooh323.c:111
static char * unistim_show_info(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static struct unistim_subchannel * get_sub_holding(struct unistim_device *device, int type, int holding)
static const unsigned char packet_recv_pressed_key[]
Definition: chan_unistim.c:515
static void key_ringing(struct unistimsession *pte, char keycode)
static ast_mutex_t unistim_reload_lock
Definition: chan_unistim.c:261
#define MONTH_LABEL_SIZE
Definition: chan_unistim.c:97
static int unistimsock
Definition: chan_unistim.c:247
static int unistim_port
Definition: chan_unistim.c:244
static struct unistimsession * sessions
static void transfer_call_step1(struct unistimsession *pte)
static void send_client(int size, const unsigned char *data, struct unistimsession *pte)
Definition: chan_unistim.c:959
static void handle_select_option(struct unistimsession *pte)
static void set_ping_timer(struct unistimsession *pte)
static int get_avail_softkey(struct unistimsession *pte, const char *name)
#define EXPNUM
Definition: chan_unistim.c:217
static const unsigned char packet_send_date_time3[]
Definition: chan_unistim.c:538
static const unsigned char packet_recv_resume_connection_with_server[]
Definition: chan_unistim.c:533
#define MUTE_ON_DISCRET
Definition: chan_unistim.c:149
static void init_phone_step2(struct unistimsession *pte)
static void show_history(struct unistimsession *pte, char way)
static void in_band_indication(struct ast_channel *ast, const struct ast_tone_zone *tz, const char *indication)
static const char * subtype_tostr(const int type)
static const unsigned char packet_send_expansion_icon[]
Definition: chan_unistim.c:527
static int unistim_call(struct ast_channel *ast, const char *dest, int timeout)
static void handle_call_incoming(struct unistimsession *s)
static struct ast_channel * unistim_new(struct unistim_subchannel *sub, int state, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor)
static void send_led_update(struct unistimsession *pte, unsigned char led)
#define SUB_RING
Definition: chan_unistim.c:117
static const unsigned char packet_send_discovery_ack[]
Definition: chan_unistim.c:508
static const unsigned char packet_send_expansion_next[]
Definition: chan_unistim.c:526
static struct unistim_line * find_line_by_number(struct unistim_device *d, const char *val)
static void * unistim_ss(void *data)
static void handle_call_outgoing(struct unistimsession *s)
static void sub_stop_silence(struct unistimsession *pte, struct unistim_subchannel *sub)
static void send_ring(struct unistimsession *pte, signed char volume, signed char style)
static const unsigned char packet_send_date_time2[]
Definition: chan_unistim.c:635
static int find_rtp_port(struct unistim_subchannel *s)
static int unistimdebug
Definition: chan_unistim.c:243
unsigned int tos_audio
Definition: chan_unistim.c:251
#define TEXT_NORMAL
Definition: chan_unistim.c:173
static void key_select_language(struct unistimsession *pte, char keycode)
static void handle_select_codec(struct unistimsession *)
static const unsigned char packet_send_s4[]
Definition: chan_unistim.c:551
static void sub_unhold(struct unistimsession *pte, struct unistim_subchannel *sub)
static struct ast_frame * unistim_rtp_read(const struct ast_channel *ast, const struct unistim_subchannel *sub)
static enum autoprovision autoprovisioning
Definition: chan_unistim.c:245
unsigned int tos
Definition: chan_unistim.c:250
#define FAV_BLINK_SLOW
Definition: chan_unistim.c:212
static const unsigned char packet_send_arrow[]
Definition: chan_unistim.c:633
#define VOLUME_LOW
Definition: chan_unistim.c:142
static void unistim_line_copy(struct unistim_line *dst, struct unistim_line *src)
#define TIMER_MWI
Definition: chan_unistim.c:105
#define TEXT_LENGTH_MAX
Definition: chan_unistim.c:169
static struct ast_frame * unistim_read(struct ast_channel *ast)
static struct unistim_line * unistim_line_destroy(struct unistim_line *l)
static void key_call(struct unistimsession *pte, char keycode)
static void send_dial_tone(struct unistimsession *pte)
static void send_callerid_screen(struct unistimsession *, struct unistim_subchannel *)
static int reload(void)
static struct ast_jb_conf default_jbconf
Global jitterbuffer configuration - by default, jb is disabled.
Definition: chan_unistim.c:227
static void check_send_queue(struct unistimsession *pte)
static void key_history(struct unistimsession *pte, char keycode)
#define TEXT_INVERSE
Definition: chan_unistim.c:174
static void send_text(unsigned char pos, unsigned char inverse, struct unistimsession *pte, const char *text)
#define LED_MUTE_ON
Definition: chan_unistim.c:164
static const unsigned char packet_recv_it_type[]
Definition: chan_unistim.c:513
static const unsigned char packet_send_end_call[]
Definition: chan_unistim.c:592
static struct unistim_line * unistim_line_alloc(void)
#define MUTE_OFF
Definition: chan_unistim.c:147
static int unistim_keepalive
Definition: chan_unistim.c:246
static void key_select_option(struct unistimsession *pte, char keycode)
static struct ast_sched_context * sched
Definition: chan_unistim.c:257
static struct unistim_device * devices
#define STATUS_LENGTH_MAX
Definition: chan_unistim.c:175
static int register_extension(const struct unistimsession *pte)
#define BUFFSEND
Definition: chan_unistim.c:704
#define FAV_ICON_SHARP
Definition: chan_unistim.c:196
static const unsigned char packet_send_start_timer[]
Definition: chan_unistim.c:640
static char * unistim_sp(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
unsigned int cos_audio
Definition: chan_unistim.c:253
static void send_idle_clock(struct unistimsession *pte)
static void sub_hold(struct unistimsession *pte, struct unistim_subchannel *sub)
static const unsigned char packet_send_charset_iso_2022_jp[]
Definition: chan_unistim.c:691
#define SUB_REAL
Definition: chan_unistim.c:116
static char * unistim_show_devices(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static const unsigned char packet_send_s9[]
Definition: chan_unistim.c:594
static void handle_select_language(struct unistimsession *)
static void key_select_codec(struct unistimsession *pte, char keycode)
static struct ast_cli_entry unistim_cli[]
#define LED_BAR_OFF
Definition: chan_unistim.c:151
#define SELECTEXTENSION_MAX_LENGTH
static void show_entry_history(struct unistimsession *pte, FILE **f)
static int unistim_senddigit_begin(struct ast_channel *ast, char digit)
static char * unistim_do_debug(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
#define MUTE_ON
Definition: chan_unistim.c:148
#define LED_SPEAKER_ON
Definition: chan_unistim.c:160
static void send_raw_client(int size, const unsigned char *data, struct sockaddr_in *addr_to, const struct sockaddr_in *addr_ourip)
Definition: chan_unistim.c:903
static void send_charset_update(struct unistimsession *pte, int charset)
static void send_blink_cursor(struct unistimsession *pte)
#define SUB_THREEWAY
Definition: chan_unistim.c:118
autoprovision
Definition: chan_unistim.c:122
@ AUTOPROVISIONING_NO
Definition: chan_unistim.c:123
@ AUTOPROVISIONING_TN
Definition: chan_unistim.c:125
@ AUTOPROVISIONING_YES
Definition: chan_unistim.c:124
static ast_mutex_t devicelock
Definition: chan_unistim.c:273
#define LED_HEADPHONE_ON
Definition: chan_unistim.c:162
static void start_rtp(struct unistim_subchannel *sub)
#define FAV_ICON_SPEAKER_ONHOOK_BLACK
Definition: chan_unistim.c:180
static void delete_device(struct unistim_device *d)
#define DEFAULTCALLERID
Definition: chan_unistim.c:84
static struct unistimsession * channel_to_session(struct ast_channel *ast)
static void send_mute(struct unistimsession *pte, unsigned char mute)
static const unsigned char packet_send_mute[]
Definition: chan_unistim.c:570
static void send_tone(struct unistimsession *pte, uint16_t tone1, uint16_t tone2)
#define FAV_ICON_SPEAKER_ONHOOK_WHITE
Definition: chan_unistim.c:181
static void send_date_time(struct unistimsession *pte)
static struct unistim_subchannel * find_subchannel_by_name(const char *dest)
static int load_module(void)
#define DEVICE_NAME_LEN
Definition: chan_unistim.c:112
static const unsigned char packet_send_S7[]
Definition: chan_unistim.c:645
#define IDLE_WAIT
Definition: chan_unistim.c:101
#define MAX_ENTRY_LOG
Definition: chan_unistim.c:114
#define FAV_ICON_SPEAKER_ONHOLD_BLACK
Definition: chan_unistim.c:190
static const char * ptestate_tostr(const int type)
static int is_key_line(struct unistim_device *d, int fav)
static void send_end_call(struct unistimsession *pte)
static int attempt_transfer(struct unistim_subchannel *p1, struct unistim_subchannel *p2)
static struct unistimsession * create_client(const struct sockaddr_in *addr_from)
static unsigned int get_tick_count(void)
Definition: chan_unistim.c:895
static int write_entry_history(struct unistimsession *pte, FILE *f, char c, char *line1)
static char open_history(struct unistimsession *pte, char way, FILE **f)
#define SELECTCODEC_MAX_LENGTH
static void key_main_page(struct unistimsession *pte, char keycode)
static void process_request(int size, unsigned char *buf, struct unistimsession *pte)
static int lang_hash_fn(const void *obj, const int flags)
Definition: chan_unistim.c:786
static void show_extension_page(struct unistimsession *pte)
static void send_expansion_text(unsigned char pos, struct unistimsession *pte, const char *text)
static const unsigned char packet_send_query_basic_manager_04[]
Definition: chan_unistim.c:696
#define FAV_ICON_HEADPHONES
Definition: chan_unistim.c:192
static int unistim_senddigit_end(struct ast_channel *ast, char digit, unsigned int duration)
static struct ast_channel_tech unistim_tech
Definition: chan_unistim.c:736
static void send_favorite_short(unsigned char pos, unsigned char status, struct unistimsession *pte)
static const unsigned char packet_send_expansion_text[]
Definition: chan_unistim.c:528
static void send_date_time2(struct unistimsession *pte)
static const char * ustmtext(const char *str, struct unistimsession *pte)
Definition: chan_unistim.c:800
static void swap_subs(struct unistim_subchannel *a, struct unistim_subchannel *b)
static int unistim_reloading
Definition: chan_unistim.c:260
static const char tdesc[]
Definition: chan_unistim.c:706
static int is_key_favorite(struct unistim_device *d, int fav)
#define MAX_BUF_SIZE
Definition: chan_unistim.c:91
#define SIZE_PAGE
Definition: chan_unistim.c:111
#define LED_MUTE_OFF
Definition: chan_unistim.c:163
static int unistim_set_rtp_peer(struct ast_channel *chan, struct ast_rtp_instance *rtp, struct ast_rtp_instance *vrtp, struct ast_rtp_instance *trtp, const struct ast_format_cap *codecs, int nat_active)
static const unsigned char packet_send_ring[]
Definition: chan_unistim.c:584
static void * do_monitor(void *data)
static int unistim_unalloc_sub(struct unistim_device *d, struct unistim_subchannel *sub)
#define FAV_ICON_REFLECT
Definition: chan_unistim.c:201
#define FAV_ICON_OFFHOOK_BLACK
Definition: chan_unistim.c:182
static void show_main_page(struct unistimsession *pte)
static const unsigned char packet_send_call[]
Definition: chan_unistim.c:558
#define DEFAULTCONTEXT
Definition: chan_unistim.c:83
static int unistim_hangup(struct ast_channel *ast)
static int unistim_write(struct ast_channel *ast, struct ast_frame *frame)
static void send_favorite(unsigned char pos, unsigned char status, struct unistimsession *pte, const char *text)
static const unsigned char packet_send_charset_iso_8859_5[]
Definition: chan_unistim.c:688
static void display_last_error(const char *sz_msg)
Definition: chan_unistim.c:889
#define SELECTEXTENSION_START_ENTRY_POS
static void send_ping(struct unistimsession *pte)
Definition: chan_unistim.c:991
static int unistimsock_read(int *id, int fd, short events, void *ignore)
#define DEFAULT_CODEC
Definition: chan_unistim.c:110
static int write_history(struct unistimsession *pte, char way, char ismissed)
#define MAX_BUF_NUMBER
Definition: chan_unistim.c:93
static int restart_monitor(void)
static void send_select_output(struct unistimsession *pte, unsigned char output, unsigned char volume, unsigned char mute)
static const unsigned char packet_send_query_basic_manager_10[]
Definition: chan_unistim.c:698
static char * control2str(int ind)
static int find_language(const char *)
static const unsigned char packet_send_stop_timer[]
Definition: chan_unistim.c:643
#define FAV_ICON_CALL_CENTER
Definition: chan_unistim.c:198
static const unsigned char packet_rcv_discovery[]
Definition: chan_unistim.c:506
#define FAV_ICON_PHONE_BLACK
Definition: chan_unistim.c:188
static const unsigned char packet_recv_hangup[]
Definition: chan_unistim.c:519
static void handle_dial_page(struct unistimsession *pte)
#define SELECTEXTENSION_MSG
charset
Definition: chan_unistim.c:336
@ ISO_8859_1
Definition: chan_unistim.c:338
@ ISO_8859_4
Definition: chan_unistim.c:340
@ LANG_DEFAULT
Definition: chan_unistim.c:337
@ ISO_8859_5
Definition: chan_unistim.c:341
@ ISO_2022_JP
Definition: chan_unistim.c:342
@ ISO_8859_2
Definition: chan_unistim.c:339
#define DEFAULTCALLERNAME
Definition: chan_unistim.c:85
#define AST_CONFIG_MAX_PATH
Definition: chan_unistim.c:113
#define RETRANSMIT_TIMER
Definition: chan_unistim.c:103
#define FAV_LINE_ICON
Definition: chan_unistim.c:218
static void send_favorite_selected(unsigned char status, struct unistimsession *pte)
autoprov_extn
Definition: chan_unistim.c:128
@ EXTENSION_ASK
Definition: chan_unistim.c:132
@ EXTENSION_LINE
Definition: chan_unistim.c:134
@ EXTENSION_TN
Definition: chan_unistim.c:136
@ EXTENSION_NONE
Definition: chan_unistim.c:130
static const unsigned char packet_send_open_audio_stream_tx[]
Definition: chan_unistim.c:613
#define OUTPUT_HANDSET
Definition: chan_unistim.c:138
#define LED_BAR_ON
Definition: chan_unistim.c:152
static const unsigned char packet_send_charset_iso_8859_4[]
Definition: chan_unistim.c:685
static int lang_cmp_fn(void *obj, void *arg, int flags)
Definition: chan_unistim.c:792
static int get_to_address(int fd, struct sockaddr_in *toAddr)
static int get_active_softkey(struct unistimsession *pte)
static const unsigned char packet_send_stream_based_tone_on[]
Definition: chan_unistim.c:575
static const unsigned char packet_send_charset_iso_8859_2[]
Definition: chan_unistim.c:682
static const unsigned char packet_send_open_audio_stream_tx3[]
Definition: chan_unistim.c:626
static void unistim_set_owner(struct unistim_subchannel *sub, struct ast_channel *chan)
static void handle_key_fav(struct unistimsession *pte, char keycode)
static const unsigned char packet_send_led_update[]
Definition: chan_unistim.c:694
#define FAVNUM
Definition: chan_unistim.c:216
static const unsigned char packet_recv_pick_up[]
Definition: chan_unistim.c:517
static const unsigned char packet_send_set_pos_cursor[]
Definition: chan_unistim.c:646
static int send_retransmit(struct unistimsession *pte)
static unsigned char packet_send_ping[]
Definition: chan_unistim.c:701
static const unsigned char packet_send_text[]
Definition: chan_unistim.c:662
static struct ast_channel * unistim_request(const char *type, struct ast_format_cap *cap, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, const char *dest, int *cause)
#define TEXT_LINE1
Definition: chan_unistim.c:171
#define FAV_ICON_SPEAKER_OFFHOOK_BLACK
Definition: chan_unistim.c:186
#define VOLUME_LOW_SPEAKER
Definition: chan_unistim.c:143
static const unsigned char packet_send_S1[]
Definition: chan_unistim.c:699
static int send_dtmf_tone(struct unistimsession *pte, char digit)
#define FAV_BLINK_FAST
Definition: chan_unistim.c:211
static int unistim_register(struct unistimsession *s)
static unsigned char packet_send_monthlabels_download[]
Definition: chan_unistim.c:652
static const unsigned char packet_send_rtp_packet_size[]
Definition: chan_unistim.c:597
static void key_select_extension(struct unistimsession *pte, char keycode)
static void close_client(struct unistimsession *s)
static char ustm_strcopy[1024]
Definition: chan_unistim.c:779
static const unsigned char packet_send_jitter_buffer_conf[]
Definition: chan_unistim.c:599
static void finish_bookmark(void)
static struct unistim_languages options_languages[]
Definition: chan_unistim.c:771
static void close_call(struct unistimsession *pte)
#define OUTPUT_HEADPHONE
Definition: chan_unistim.c:139
static const char channel_type[]
Definition: chan_unistim.c:707
static void send_text_status(struct unistimsession *pte, const char *text)
#define NB_MAX_RETRANSMIT
Definition: chan_unistim.c:99
static int unistim_send_mwi_to_peer(struct unistim_line *peer, unsigned int tick)
#define SIZE_HEADER
Definition: chan_unistim.c:167
static void send_stop_timer(struct unistimsession *pte)
static ast_mutex_t monlock
Definition: chan_unistim.c:269
static struct @132 qos
static void show_phone_number(struct unistimsession *pte)
#define USTM_LOG_DIR
Definition: chan_unistim.c:87
#define DEFAULT_INTERDIGIT_TIMER
Definition: chan_unistim.c:107
static int reload_config(void)
static void refresh_all_favorite(struct unistimsession *pte)
static void transfer_cancel_step2(struct unistimsession *pte)
static void send_date_time3(struct unistimsession *pte)
static int unistim_sendtext(struct ast_channel *ast, const char *text)
#define FAV_ICON_HEADPHONES_ONHOLD
Definition: chan_unistim.c:193
#define FAV_ICON_ONHOLD_BLACK
Definition: chan_unistim.c:184
static const unsigned char packet_send_title[]
Definition: chan_unistim.c:659
static void send_texttitle(struct unistimsession *pte, const char *text)
static char * unistim_reload(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
— unistim_reload: Force reload of module from cli — Runs in the asterisk main thread,...
static void send_start_timer(struct unistimsession *pte)
static struct ast_jb_conf global_jbconf
Definition: chan_unistim.c:235
static struct unistim_menu_item options_menu[]
Definition: chan_unistim.c:764
static void dummy(char *unused,...)
Definition: chan_unistim.c:220
static void key_dial_page(struct unistimsession *pte, char keycode)
static void send_expansion_short(unsigned char pos, unsigned char status, struct unistimsession *pte)
static struct io_context * io
Definition: chan_unistim.c:256
static const unsigned char packet_send_favorite[]
Definition: chan_unistim.c:654
#define TEXT_LINE0
Definition: chan_unistim.c:170
static void key_favorite(struct unistimsession *, char)
static void send_start_rtp(struct unistim_subchannel *)
static const unsigned char packet_send_Contrast[]
Definition: chan_unistim.c:638
#define LED_SPEAKER_OFF
Definition: chan_unistim.c:159
#define SELECTCODEC_START_ENTRY_POS
static const unsigned char packet_send_blink_cursor[]
Definition: chan_unistim.c:634
static const unsigned char packet_recv_firm_version[]
Definition: chan_unistim.c:511
static const unsigned char packet_send_icon[]
Definition: chan_unistim.c:644
phone_key
Definition: chan_unistim.c:295
@ KEY_INDEX
Definition: chan_unistim.c:333
@ KEY_FAV0
Definition: chan_unistim.c:323
@ KEY_QUIT
Definition: chan_unistim.c:312
@ KEY_UP
Definition: chan_unistim.c:308
@ KEY_HANGUP
Definition: chan_unistim.c:319
@ KEY_2
Definition: chan_unistim.c:298
@ KEY_6
Definition: chan_unistim.c:302
@ KEY_FUNC4
Definition: chan_unistim.c:317
@ KEY_1
Definition: chan_unistim.c:297
@ KEY_RCVHIST
Definition: chan_unistim.c:332
@ KEY_FAV3
Definition: chan_unistim.c:326
@ KEY_COMPUTR
Definition: chan_unistim.c:329
@ KEY_9
Definition: chan_unistim.c:305
@ KEY_LEFT
Definition: chan_unistim.c:311
@ KEY_RIGHT
Definition: chan_unistim.c:310
@ KEY_0
Definition: chan_unistim.c:296
@ KEY_FAV2
Definition: chan_unistim.c:325
@ KEY_FUNC3
Definition: chan_unistim.c:316
@ KEY_SNDHIST
Definition: chan_unistim.c:331
@ KEY_CONF
Definition: chan_unistim.c:330
@ KEY_SHARP
Definition: chan_unistim.c:307
@ KEY_FAV4
Definition: chan_unistim.c:327
@ KEY_DOWN
Definition: chan_unistim.c:309
@ KEY_8
Definition: chan_unistim.c:304
@ KEY_MUTE
Definition: chan_unistim.c:320
@ KEY_COPY
Definition: chan_unistim.c:313
@ KEY_STAR
Definition: chan_unistim.c:306
@ KEY_ONHOLD
Definition: chan_unistim.c:318
@ KEY_LOUDSPK
Definition: chan_unistim.c:322
@ KEY_FAV1
Definition: chan_unistim.c:324
@ KEY_FAV5
Definition: chan_unistim.c:328
@ KEY_HEADPHN
Definition: chan_unistim.c:321
@ KEY_FUNC1
Definition: chan_unistim.c:314
@ KEY_7
Definition: chan_unistim.c:303
@ KEY_4
Definition: chan_unistim.c:300
@ KEY_5
Definition: chan_unistim.c:301
@ KEY_FUNC2
Definition: chan_unistim.c:315
@ KEY_3
Definition: chan_unistim.c:299
static struct sockaddr_in public_ip
Definition: chan_unistim.c:258
static const unsigned char packet_send_stream_based_tone_dual_freq[]
Definition: chan_unistim.c:579
static void microphone_mute_toggle(struct unistimsession *pte)
static struct unistim_device * build_device(const char *cat, const struct ast_variable *v)
static const unsigned char packet_send_status[]
Definition: chan_unistim.c:668
#define TEXT_LINE2
Definition: chan_unistim.c:172
static void parsing(int size, unsigned char *buf, struct unistimsession *pte, struct sockaddr_in *addr_from)
static void change_callerid(struct unistimsession *pte, int type, char *callerid)
static unsigned char monthlabels[]
Definition: chan_unistim.c:649
static void change_favorite_icon(struct unistimsession *pte, unsigned char status)
#define SELECTCODEC_MSG
#define OUTPUT_SPEAKER
Definition: chan_unistim.c:140
#define FAV_MAX_LENGTH
Definition: chan_unistim.c:214
static void send_expansion_icon(unsigned char pos, unsigned char status, struct unistimsession *pte)
static int unload_module(void)
static int parse_bookmark(const char *text, struct unistim_device *d)
static const unsigned char packet_send_open_audio_stream_rx3[]
Definition: chan_unistim.c:619
static struct unistim_subchannel * get_sub(struct unistim_device *device, int type)
#define DEBUG_TIMER
Definition: chan_unistim.c:241
static const unsigned char packet_send_charset_iso_8859_1[]
Definition: chan_unistim.c:679
#define USTM_LANG_DIR
Definition: chan_unistim.c:88
#define MAX_SCREEN_NUMBER
Definition: chan_unistim.c:95
static int unistim_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
phone_state
Definition: chan_unistim.c:275
@ STATE_EXTENSION
Definition: chan_unistim.c:279
@ STATE_HISTORY
Definition: chan_unistim.c:287
@ STATE_AUTHDENY
Definition: chan_unistim.c:277
@ STATE_SELECTOPTION
Definition: chan_unistim.c:283
@ STATE_CLEANING
Definition: chan_unistim.c:286
@ STATE_CALL
Definition: chan_unistim.c:282
@ STATE_SELECTCODEC
Definition: chan_unistim.c:284
@ STATE_INIT
Definition: chan_unistim.c:276
@ STATE_MAINPAGE
Definition: chan_unistim.c:278
@ STATE_SELECTLANGUAGE
Definition: chan_unistim.c:285
@ STATE_DIALPAGE
Definition: chan_unistim.c:280
@ STATE_RINGING
Definition: chan_unistim.c:281
static void send_month_labels(struct unistimsession *pte, int month)
handset_state
Definition: chan_unistim.c:290
@ STATE_OFFHOOK
Definition: chan_unistim.c:292
@ STATE_ONHOOK
Definition: chan_unistim.c:291
static const unsigned char packet_send_status2[]
Definition: chan_unistim.c:673
static void rcv_mac_addr(struct unistimsession *pte, const unsigned char *buf)
static void ignore_call(struct unistimsession *pte)
static const unsigned char packet_send_stream_based_tone_single_freq[]
Definition: chan_unistim.c:577
static struct unistim_subchannel * unistim_alloc_sub(struct unistim_device *d, int x)
static void sub_start_silence(struct unistimsession *pte, struct unistim_subchannel *sub)
static const float dtmf_col[]
Definition: chan_unistim.c:346
static void send_expansion_next(struct unistimsession *pte)
static const unsigned char packet_send_select_output[]
Definition: chan_unistim.c:581
static ast_mutex_t sessionlock
Definition: chan_unistim.c:271
static const unsigned char packet_recv_mac_addr[]
Definition: chan_unistim.c:535
static void rcv_resume_connection_with_server(struct unistimsession *pte)
static void send_cursor_pos(struct unistimsession *pte, unsigned char pos)
static const unsigned char packet_send_open_audio_stream_rx[]
Definition: chan_unistim.c:608
struct ast_format_cap * global_cap
Definition: chan_unistim.c:120
static int unistim_hangup_clean(struct ast_channel *ast, struct unistim_subchannel *sub)
static void discard_call(struct unistimsession *pte)
static int soft_key_visible(struct unistim_device *d, unsigned char num)
#define DEFAULTHEIGHT
Definition: chan_unistim.c:86
static int unistim_indicate(struct ast_channel *ast, int ind, const void *data, size_t datalen)
static int unistim_answer(struct ast_channel *ast)
static const unsigned char packet_recv_r2[]
Definition: chan_unistim.c:521
unsigned int cos
Definition: chan_unistim.c:252
static const int dtmf_row[]
Definition: chan_unistim.c:345
static void send_no_ring(struct unistimsession *pte)
#define LED_HEADPHONE_OFF
Definition: chan_unistim.c:161
static void send_icon(unsigned char pos, unsigned char status, struct unistimsession *pte)
static const unsigned char packet_send_date_time[]
Definition: chan_unistim.c:542
#define FAV_ICON_NONE
Definition: chan_unistim.c:177
static int unistim_free_sub(struct unistim_subchannel *)
static void unquote(char *out, const char *src, int maxlen)
static unsigned char * buff
Definition: chan_unistim.c:259
static enum ast_rtp_glue_result unistim_get_rtp_peer(struct ast_channel *chan, struct ast_rtp_instance **instance)
static struct ast_rtp_glue unistim_rtp_glue
static const unsigned char packet_send_stream_based_tone_off[]
Definition: chan_unistim.c:567
static int unregister_extension(const struct unistimsession *pte)
static int unistim_do_senddigit(struct unistimsession *pte, char digit)
static pthread_t monitor_thread
Definition: chan_unistim.c:265
static const unsigned char packet_recv_expansion_pressed_key[]
Definition: chan_unistim.c:524
static const unsigned char packet_send_query_mac_address[]
Definition: chan_unistim.c:697
static const unsigned char packet_send_no_ring[]
Definition: chan_unistim.c:549
General Asterisk PBX channel definitions.
void ast_channel_exten_set(struct ast_channel *chan, const char *value)
const char * ast_channel_name(const struct ast_channel *chan)
void ast_channel_rings_set(struct ast_channel *chan, int value)
@ AST_CHAN_TP_WANTSJITTER
Channels have this property if they can accept input with jitter; i.e. most VoIP channels.
Definition: channel.h:960
@ AST_CHAN_TP_CREATESJITTER
Channels have this property if they can create jitter; i.e. most VoIP channels.
Definition: channel.h:965
void * ast_channel_tech_pvt(const struct ast_channel *chan)
void ast_hangup(struct ast_channel *chan)
Hang up a channel.
Definition: channel.c:2541
#define ast_channel_alloc(needqueue, state, cid_num, cid_name, acctcode, exten, context, assignedids, requestor, amaflag,...)
Create a channel structure.
Definition: channel.h:1258
int ast_queue_hangup(struct ast_channel *chan)
Queue a hangup frame.
Definition: channel.c:1150
void ast_channel_nativeformats_set(struct ast_channel *chan, struct ast_format_cap *value)
int ast_channel_fdno(const struct ast_channel *chan)
#define ast_channel_lock(chan)
Definition: channel.h:2922
struct ast_format_cap * ast_channel_nativeformats(const struct ast_channel *chan)
void ast_channel_unregister(const struct ast_channel_tech *tech)
Unregister a channel technology.
Definition: channel.c:570
struct ast_silence_generator * ast_channel_start_silence_generator(struct ast_channel *chan)
Starts a silence generator on the given channel.
Definition: channel.c:8163
int ast_queue_control(struct ast_channel *chan, enum ast_control_frame_type control)
Queue a control frame without payload.
Definition: channel.c:1231
unsigned long long ast_group_t
Definition: channel.h:213
void ast_channel_stop_silence_generator(struct ast_channel *chan, struct ast_silence_generator *state)
Stops a previously-started silence generator on the given channel.
Definition: channel.c:8209
#define ast_channel_ref(c)
Increase channel reference count.
Definition: channel.h:2947
struct ast_party_connected_line * ast_channel_connected(struct ast_channel *chan)
int ast_queue_frame(struct ast_channel *chan, struct ast_frame *f)
Queue one or more frames to a channel's frame queue.
Definition: channel.c:1139
const char * ast_channel_uniqueid(const struct ast_channel *chan)
@ AST_ADSI_UNAVAILABLE
Definition: channel.h:871
int ast_channel_fd(const struct ast_channel *chan, int which)
int ast_set_read_format(struct ast_channel *chan, struct ast_format *format)
Sets read format on channel chan.
Definition: channel.c:5761
void ast_channel_internal_fd_set(struct ast_channel *chan, int which, int value)
int ast_queue_hangup_with_cause(struct ast_channel *chan, int cause)
Queue a hangup frame with hangupcause set.
Definition: channel.c:1166
void ast_channel_set_rawreadformat(struct ast_channel *chan, struct ast_format *format)
#define MAX_LANGUAGE
Definition: channel.h:172
void ast_channel_tech_pvt_set(struct ast_channel *chan, void *value)
void ast_channel_callgroup_set(struct ast_channel *chan, ast_group_t value)
int ast_channel_hangupcause(const struct ast_channel *chan)
void ast_channel_set_rawwriteformat(struct ast_channel *chan, struct ast_format *format)
#define AST_MAX_ACCOUNT_CODE
Definition: channel.h:170
int ast_queue_unhold(struct ast_channel *chan)
Queue an unhold frame.
Definition: channel.c:1216
int ast_queue_hold(struct ast_channel *chan, const char *musicclass)
Queue a hold frame.
Definition: channel.c:1191
void ast_channel_set_readformat(struct ast_channel *chan, struct ast_format *format)
int ast_channel_register(const struct ast_channel_tech *tech)
Register a channel technology (a new channel driver) Called by a channel module to register the kind ...
Definition: channel.c:539
#define ast_channel_unref(c)
Decrease channel reference count.
Definition: channel.h:2958
struct ast_format * ast_channel_writeformat(struct ast_channel *chan)
@ AST_SOFTHANGUP_DEV
Definition: channel.h:1121
int ast_set_write_format(struct ast_channel *chan, struct ast_format *format)
Sets write format on channel chan.
Definition: channel.c:5802
#define AST_MAX_CONTEXT
Definition: channel.h:135
int ast_softhangup_nolock(struct ast_channel *chan, int cause)
Softly hangup up a channel (no channel lock)
Definition: channel.c:2458
enum ama_flags ast_channel_string2amaflag(const char *flag)
Convert a string to a detail record AMA flag.
Definition: channel.c:4359
const char * ast_channel_call_forward(const struct ast_channel *chan)
struct ast_party_caller * ast_channel_caller(struct ast_channel *chan)
void ast_channel_priority_set(struct ast_channel *chan, int value)
void ast_channel_hangupcause_set(struct ast_channel *chan, int value)
void ast_channel_pickupgroup_set(struct ast_channel *chan, ast_group_t value)
void ast_channel_adsicpe_set(struct ast_channel *chan, enum ast_channel_adsicpe value)
ast_group_t ast_get_group(const char *s)
Definition: channel.c:7617
void ast_channel_tech_set(struct ast_channel *chan, const struct ast_channel_tech *value)
#define ast_channel_unlock(chan)
Definition: channel.h:2923
#define AST_MAX_EXTENSION
Definition: channel.h:134
void ast_channel_set_writeformat(struct ast_channel *chan, struct ast_format *format)
#define MAX_MUSICCLASS
Definition: channel.h:173
struct ast_format * ast_channel_readformat(struct ast_channel *chan)
ast_channel_state
ast_channel states
Definition: channelstate.h:35
@ AST_STATE_RING
Definition: channelstate.h:40
@ AST_STATE_RINGING
Definition: channelstate.h:41
@ AST_STATE_DOWN
Definition: channelstate.h:36
@ AST_STATE_UP
Definition: channelstate.h:42
@ AST_STATE_RESERVED
Definition: channelstate.h:37
int ast_setstate(struct ast_channel *chan, enum ast_channel_state)
Change the state of a channel.
Definition: channel.c:7385
Standard Command Line Interface.
#define CLI_SHOWUSAGE
Definition: cli.h:45
#define CLI_SUCCESS
Definition: cli.h:44
int ast_cli_unregister_multiple(struct ast_cli_entry *e, int len)
Unregister multiple commands.
Definition: clicompat.c:30
#define AST_CLI_DEFINE(fn, txt,...)
Definition: cli.h:197
void ast_cli(int fd, const char *fmt,...)
Definition: clicompat.c:6
@ CLI_INIT
Definition: cli.h:152
@ CLI_GENERATE
Definition: cli.h:153
#define ast_cli_register_multiple(e, len)
Register multiple commands.
Definition: cli.h:265
static struct ao2_container * codecs
Registered codecs.
Definition: codec.c:48
@ AST_MEDIA_TYPE_AUDIO
Definition: codec.h:32
@ AST_MEDIA_TYPE_UNKNOWN
Definition: codec.h:31
char buf[BUFSIZE]
Definition: eagi_proxy.c:66
long int flag
Definition: f2c.h:83
enum ast_format_cmp_res ast_format_cmp(const struct ast_format *format1, const struct ast_format *format2)
Compare two formats.
Definition: format.c:201
@ AST_FORMAT_CMP_EQUAL
Definition: format.h:36
@ AST_FORMAT_CMP_NOT_EQUAL
Definition: format.h:38
const char * ast_format_get_name(const struct ast_format *format)
Get the name associated with a format.
Definition: format.c:334
Media Format Cache API.
struct ast_format * ast_format_ulaw
Built-in cached ulaw format.
Definition: format_cache.c:86
struct ast_format * ast_format_g723
Built-in cached g723.1 format.
Definition: format_cache.c:146
struct ast_format * ast_format_alaw
Built-in cached alaw format.
Definition: format_cache.c:91
struct ast_format * ast_format_g729
Built-in cached g729 format.
Definition: format_cache.c:151
#define AST_FORMAT_CAP_NAMES_LEN
Definition: format_cap.h:324
struct ast_format * ast_format_cap_get_format(const struct ast_format_cap *cap, int position)
Get the format at a specific index.
Definition: format_cap.c:400
enum ast_format_cmp_res ast_format_cap_iscompatible_format(const struct ast_format_cap *cap, const struct ast_format *format)
Find if ast_format is within the capabilities of the ast_format_cap object.
Definition: format_cap.c:581
@ AST_FORMAT_CAP_FLAG_DEFAULT
Definition: format_cap.h:38
int ast_format_cap_append_from_cap(struct ast_format_cap *dst, const struct ast_format_cap *src, enum ast_media_type type)
Append the formats of provided type in src to dst.
Definition: format_cap.c:269
const char * ast_format_cap_get_names(const struct ast_format_cap *cap, struct ast_str **buf)
Get the names of codecs of a set of formats.
Definition: format_cap.c:734
int ast_format_cap_iscompatible(const struct ast_format_cap *cap1, const struct ast_format_cap *cap2)
Determine if any joint capabilities exist between two capabilities structures.
Definition: format_cap.c:653
#define ast_format_cap_append(cap, format, framing)
Add format capability to capabilities structure.
Definition: format_cap.h:99
#define ast_format_cap_alloc(flags)
Allocate a new ast_format_cap structure.
Definition: format_cap.h:49
size_t ast_format_cap_count(const struct ast_format_cap *cap)
Get the number of formats present within the capabilities structure.
Definition: format_cap.c:395
static const char name[]
Definition: format_mp3.c:68
static struct ast_threadstorage buf2
static int len(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t buflen)
void ast_channel_stage_snapshot_done(struct ast_channel *chan)
Clear flag to indicate channel snapshot is being staged, and publish snapshot.
void ast_channel_stage_snapshot(struct ast_channel *chan)
Set flag to indicate channel snapshot is being staged.
Application convenience functions, designed to give consistent look and feel to Asterisk apps.
int ast_app_has_voicemail(const char *mailboxes, const char *folder)
Determine if a given mailbox has any voicemail If folder is NULL, defaults to "INBOX"....
Definition: main/app.c:582
char * strsep(char **str, const char *delims)
Configuration File Parser.
#define ast_config_load(filename, flags)
Load a config file.
char * ast_category_browse(struct ast_config *config, const char *prev_name)
Browse categories.
Definition: extconf.c:3326
#define CONFIG_STATUS_FILEINVALID
void ast_config_destroy(struct ast_config *cfg)
Destroys a config.
Definition: extconf.c:1289
struct ast_variable * ast_variable_browse(const struct ast_config *config, const char *category_name)
Definition: extconf.c:1215
struct ast_features_pickup_config * ast_get_chan_features_pickup_config(struct ast_channel *chan)
Get the pickup configuration options for a channel.
#define AST_FRAME_DTMF
@ AST_FRAME_IMAGE
@ AST_FRAME_VOICE
@ AST_CONTROL_RING
@ AST_CONTROL_SRCUPDATE
@ AST_CONTROL_WINK
@ AST_CONTROL_PROGRESS
@ AST_CONTROL_OFFHOOK
@ AST_CONTROL_RADIO_UNKEY
@ AST_CONTROL_BUSY
@ AST_CONTROL_UNHOLD
@ AST_CONTROL_PROCEEDING
@ AST_CONTROL_TAKEOFFHOOK
@ AST_CONTROL_CONGESTION
@ AST_CONTROL_ANSWER
@ AST_CONTROL_RINGING
@ AST_CONTROL_HANGUP
@ AST_CONTROL_RADIO_KEY
@ AST_CONTROL_HOLD
@ AST_CONTROL_OPTION
@ AST_CONTROL_CONNECTED_LINE
@ AST_CONTROL_FLASH
@ AST_CONTROL_SRCCHANGE
@ AST_CONTROL_INCOMPLETE
@ AST_CONTROL_MASQUERADE_NOTIFY
@ AST_CONTROL_PVT_CAUSE_CODE
@ AST_CONTROL_UPDATE_RTP_PEER
struct ast_frame ast_null_frame
Definition: main/frame.c:79
#define ast_debug(level,...)
Log a DEBUG message.
#define LOG_ERROR
#define ast_verb(level,...)
#define LOG_NOTICE
#define LOG_WARNING
Tone Indication Support.
static struct ast_tone_zone_sound * ast_tone_zone_sound_unref(struct ast_tone_zone_sound *ts)
Release a reference to an ast_tone_zone_sound.
Definition: indications.h:227
int ast_playtones_start(struct ast_channel *chan, int vol, const char *tonelist, int interruptible)
Start playing a list of tones on a channel.
Definition: indications.c:302
int ast_tone_zone_part_parse(const char *s, struct ast_tone_zone_part *tone_data)
Parse a tone part.
Definition: indications.c:245
void ast_playtones_stop(struct ast_channel *chan)
Stop playing tones on a channel.
Definition: indications.c:393
struct ast_tone_zone_sound * ast_get_indication_tone(const struct ast_tone_zone *zone, const char *indication)
Locate a tone zone sound.
Definition: indications.c:461
static struct ast_tone_zone * ast_tone_zone_unref(struct ast_tone_zone *tz)
Release a reference to an ast_tone_zone.
Definition: indications.h:205
struct ast_tone_zone * ast_get_indication_zone(const char *country)
locate ast_tone_zone
Definition: indications.c:439
#define AST_IO_IN
Definition: io.h:34
struct io_context * io_context_create(void)
Creates a context Create a context for I/O operations Basically mallocs an IO structure and sets up s...
Definition: io.c:81
int * ast_io_add(struct io_context *ioc, int fd, ast_io_cb callback, short events, void *data)
Adds an IO context.
Definition: io.c:162
void io_context_destroy(struct io_context *ioc)
Destroys a context.
Definition: io.c:107
int ast_io_wait(struct io_context *ioc, int howlong)
Waits for IO.
Definition: io.c:278
#define AST_LIST_TRAVERSE(head, var, field)
Loops over (traverses) the entries in a list.
Definition: linkedlists.h:491
#define AST_LIST_INSERT_TAIL(head, elm, field)
Appends a list entry to the tail of a list.
Definition: linkedlists.h:731
#define AST_LIST_ENTRY(type)
Declare a forward link structure inside a list entry.
Definition: linkedlists.h:410
#define AST_LIST_TRAVERSE_SAFE_END
Closes a safe loop traversal block.
Definition: linkedlists.h:615
#define AST_LIST_LOCK(head)
Locks a list.
Definition: linkedlists.h:40
#define AST_LIST_TRAVERSE_SAFE_BEGIN(head, var, field)
Loops safely over (traverses) the entries in a list.
Definition: linkedlists.h:529
#define AST_LIST_REMOVE_CURRENT(field)
Removes the current entry from a list during a traversal.
Definition: linkedlists.h:557
#define AST_LIST_UNLOCK(head)
Attempts to unlock a list.
Definition: linkedlists.h:140
#define AST_LIST_HEAD(name, type)
Defines a structure to be used to hold a list of specified type.
Definition: linkedlists.h:173
#define AST_LIST_FIRST(head)
Returns the first entry contained in a list.
Definition: linkedlists.h:421
struct ast_tm * ast_localtime(const struct timeval *timep, struct ast_tm *p_tm, const char *zone)
Timezone-independent version of localtime_r(3).
Definition: localtime.c:1739
#define AST_PTHREADT_NULL
Definition: lock.h:66
#define ast_mutex_init(pmutex)
Definition: lock.h:186
#define AST_PTHREADT_STOP
Definition: lock.h:67
#define ast_mutex_unlock(a)
Definition: lock.h:190
#define ast_mutex_destroy(a)
Definition: lock.h:188
#define ast_mutex_lock(a)
Definition: lock.h:189
#define AST_MUTEX_DEFINE_STATIC(mutex)
Definition: lock.h:520
static char dateformat[256]
Definition: logger.c:81
int errno
Asterisk module definitions.
@ AST_MODFLAG_DEFAULT
Definition: module.h:315
void ast_update_use_count(void)
Notify when usecount has been changed.
Definition: loader.c:2544
#define AST_MODULE_INFO(keystr, flags_to_set, desc, fields...)
Definition: module.h:543
@ AST_MODULE_SUPPORT_EXTENDED
Definition: module.h:122
#define ASTERISK_GPL_KEY
The text the key() function should return.
Definition: module.h:46
@ AST_MODULE_LOAD_SUCCESS
Definition: module.h:70
@ AST_MODULE_LOAD_DECLINE
Module has failed to load, may be in an inconsistent state.
Definition: module.h:78
Music on hold handling.
int ast_moh_start(struct ast_channel *chan, const char *mclass, const char *interpclass)
Turn on music on hold on a given channel.
Definition: channel.c:7765
void ast_moh_stop(struct ast_channel *chan)
Turn off music on hold on a given channel.
Definition: channel.c:7775
Asterisk MWI API.
struct stasis_message_type * ast_mwi_state_type(void)
Get the Stasis Message Bus API message type for MWI messages.
struct stasis_cache * ast_mwi_state_cache(void)
Backend cache for ast_mwi_topic_cached().
Definition: mwi.c:94
def ignore(key=None, val=None, section=None, pjsip=None, nmapped=None, type='endpoint')
Definition: sip_to_pjsip.py:48
Network socket handling.
int ast_sockaddr_resolve_first_af(struct ast_sockaddr *addr, const char *name, int flag, int family)
Return the first entry from ast_sockaddr_resolve filtered by address family.
Definition: netsock2.c:337
int ast_set_qos(int sockfd, int tos, int cos, const char *desc)
Set type of service.
Definition: netsock2.c:621
#define ast_sockaddr_to_sin(addr, sin)
Converts a struct ast_sockaddr to a struct sockaddr_in.
Definition: netsock2.h:765
#define ast_sockaddr_from_sin(addr, sin)
Converts a struct sockaddr_in to a struct ast_sockaddr.
Definition: netsock2.h:778
Wrapper for network related headers, masking differences between various operating systems....
const char * ast_inet_ntoa(struct in_addr ia)
thread-safe replacement for inet_ntoa().
Definition: utils.c:928
Asterisk file paths, configured in asterisk.conf.
const char * ast_config_AST_VAR_DIR
Definition: options.c:157
const char * ast_config_AST_LOG_DIR
Definition: options.c:159
Core PBX routines and definitions.
int ast_add_extension(const char *context, int replace, const char *extension, int priority, const char *label, const char *callerid, const char *application, void *data, void(*datad)(void *), const char *registrar)
Add and extension to an extension context.
Definition: pbx.c:6928
enum ast_pbx_result ast_pbx_run(struct ast_channel *c)
Execute the PBX in the current thread.
Definition: pbx.c:4755
int ast_exists_extension(struct ast_channel *c, const char *context, const char *exten, int priority, const char *callerid)
Determine whether an extension exists.
Definition: pbx.c:4175
int ast_context_remove_extension(const char *context, const char *extension, int priority, const char *registrar)
Simply remove extension from context.
Definition: pbx.c:4948
enum ast_pbx_result ast_pbx_start(struct ast_channel *c)
Create a new thread and start the PBX.
Definition: pbx.c:4708
int ast_matchmore_extension(struct ast_channel *c, const char *context, const char *exten, int priority, const char *callerid)
Looks to see if adding anything to this extension might match something. (exists ^ canmatch)
Definition: pbx.c:4195
Call Pickup API.
int ast_pickup_call(struct ast_channel *chan)
Pickup a call.
Definition: pickup.c:199
struct stasis_forward * sub
Definition: res_corosync.c:240
#define NULL
Definition: resample.c:96
Pluggable RTP Architecture.
int ast_rtp_instance_destroy(struct ast_rtp_instance *instance)
Destroy an RTP instance.
Definition: rtp_engine.c:457
struct ast_rtp_instance * ast_rtp_instance_new(const char *engine_name, struct ast_sched_context *sched, const struct ast_sockaddr *sa, void *data)
Create a new RTP instance.
Definition: rtp_engine.c:486
void ast_rtp_instance_stop(struct ast_rtp_instance *instance)
Stop an RTP instance.
Definition: rtp_engine.c:2196
ast_rtp_glue_result
Definition: rtp_engine.h:158
@ AST_RTP_GLUE_RESULT_LOCAL
Definition: rtp_engine.h:164
@ AST_RTP_GLUE_RESULT_FORBID
Definition: rtp_engine.h:160
#define ast_rtp_instance_get_remote_address(instance, address)
Get the address of the remote endpoint that we are sending RTP to.
Definition: rtp_engine.h:1238
struct ast_frame * ast_rtp_instance_read(struct ast_rtp_instance *instance, int rtcp)
Receive a frame over RTP.
Definition: rtp_engine.c:599
void ast_rtp_instance_set_prop(struct ast_rtp_instance *instance, enum ast_rtp_property property, int value)
Set the value of an RTP instance property.
Definition: rtp_engine.c:726
void ast_rtp_instance_get_local_address(struct ast_rtp_instance *instance, struct ast_sockaddr *address)
Get the local address that we are expecting RTP on.
Definition: rtp_engine.c:664
int ast_rtp_codecs_payload_code_tx(struct ast_rtp_codecs *codecs, int asterisk_format, const struct ast_format *format, int code)
Retrieve a tx mapped payload type based on whether it is an Asterisk format and the code.
Definition: rtp_engine.c:1941
int ast_rtp_instance_write(struct ast_rtp_instance *instance, struct ast_frame *frame)
Send a frame out over RTP.
Definition: rtp_engine.c:589
#define ast_rtp_instance_set_remote_address(instance, address)
Set the address of the remote endpoint that we are sending RTP to.
Definition: rtp_engine.h:1126
@ AST_RTP_PROPERTY_NAT
Definition: rtp_engine.h:115
@ AST_RTP_PROPERTY_RTCP
Definition: rtp_engine.h:123
int ast_rtp_instance_set_qos(struct ast_rtp_instance *instance, int tos, int cos, const char *desc)
Set QoS parameters on an RTP session.
Definition: rtp_engine.c:2182
void ast_rtp_instance_set_channel_id(struct ast_rtp_instance *instance, const char *uniqueid)
Set the channel that owns this RTP instance.
Definition: rtp_engine.c:574
#define ast_rtp_glue_register(glue)
Definition: rtp_engine.h:893
void ast_rtp_instance_change_source(struct ast_rtp_instance *instance)
Indicate a new source of audio has dropped in and the ssrc should change.
Definition: rtp_engine.c:2173
struct ast_rtp_codecs * ast_rtp_instance_get_codecs(struct ast_rtp_instance *instance)
Get the codecs structure of an RTP instance.
Definition: rtp_engine.c:748
int ast_rtp_instance_fd(struct ast_rtp_instance *instance, int rtcp)
Get the file descriptor for an RTP session (or RTCP)
Definition: rtp_engine.c:2205
int ast_rtp_glue_unregister(struct ast_rtp_glue *glue)
Unregister RTP glue.
Definition: rtp_engine.c:407
void ast_sched_context_destroy(struct ast_sched_context *c)
destroys a schedule context
Definition: sched.c:271
struct ast_sched_context * ast_sched_context_create(void)
Create a scheduler context.
Definition: sched.c:238
void * stasis_message_data(const struct stasis_message *msg)
Get the data contained in a message.
struct stasis_message * stasis_cache_get(struct stasis_cache *cache, struct stasis_message_type *type, const char *id)
Retrieve an item from the cache for the ast_eid_default entity.
Definition: stasis_cache.c:686
static force_inline int attribute_pure ast_str_hash(const char *str)
Compute a hash value on a string.
Definition: strings.h:1259
int attribute_pure ast_true(const char *val)
Make sure something is true. Determine if a string containing a boolean value is "true"....
Definition: utils.c:2199
#define S_COR(a, b, c)
returns the equivalent of logic or for strings, with an additional boolean check: second one if not e...
Definition: strings.h:87
static force_inline int attribute_pure ast_strlen_zero(const char *s)
Definition: strings.h:65
#define ast_str_alloca(init_len)
Definition: strings.h:848
char * ast_trim_blanks(char *str)
Trims trailing whitespace characters from a string.
Definition: strings.h:186
void ast_copy_string(char *dst, const char *src, size_t size)
Size-limited null-terminating string copy.
Definition: strings.h:425
Generic container type.
Structure to pass both assignedid values to channel drivers.
Definition: channel.h:604
Structure to describe a channel "technology", ie a channel driver See for examples:
Definition: channel.h:628
struct ast_format_cap * capabilities
Definition: channel.h:632
const char *const type
Definition: channel.h:629
Main Channel structure associated with a channel.
const char * data
descriptor for a cli entry.
Definition: cli.h:171
int args
This gets set in ast_cli_register()
Definition: cli.h:185
char * command
Definition: cli.h:186
const char * usage
Definition: cli.h:177
Configuration relating to call pickup.
Structure used to handle boolean flags.
Definition: utils.h:199
Format capabilities structure, holds formats + preference order + etc.
Definition: format_cap.c:54
Definition of a media format.
Definition: format.c:43
struct ast_format * format
Data structure associated with a single frame of data.
struct ast_frame_subclass subclass
union ast_frame::@226 data
enum ast_frame_type frametype
internal representation of ACL entries In principle user applications would have no need for this,...
Definition: acl.h:51
General jitterbuffer configuration.
Definition: abstract_jb.h:70
unsigned int flags
Combination of the AST_JB_ENABLED, AST_JB_FORCED and AST_JB_LOG flags.
Definition: abstract_jb.h:72
Structure for mutex and tracking information.
Definition: lock.h:135
The structure that contains MWI state.
Definition: mwi.h:455
int new_msgs
Definition: mwi.h:459
struct ast_party_id id
Caller party ID.
Definition: channel.h:420
struct ast_party_id id
Connected party ID.
Definition: channel.h:458
struct ast_party_name name
Subscriber name.
Definition: channel.h:340
struct ast_party_number number
Subscriber phone number.
Definition: channel.h:342
unsigned char valid
TRUE if the name information is valid/present.
Definition: channel.h:279
char * str
Subscriber name (Malloced)
Definition: channel.h:264
unsigned char valid
TRUE if the number information is valid/present.
Definition: channel.h:297
char * str
Subscriber phone number (Malloced)
Definition: channel.h:291
const char * type
Definition: rtp_engine.h:768
Socket address structure.
Definition: netsock2.h:97
Support for dynamic strings.
Definition: strings.h:623
int tm_mday
Definition: localtime.h:39
char * tm_zone
Definition: localtime.h:46
int tm_sec
Definition: localtime.h:36
int tm_hour
Definition: localtime.h:38
int tm_min
Definition: localtime.h:37
int tm_year
Definition: localtime.h:41
int tm_mon
Definition: localtime.h:40
A description of a part of a tone.
Definition: indications.h:109
unsigned int freq2
Definition: indications.h:111
unsigned int freq1
Definition: indications.h:110
Description of a tone.
Definition: indications.h:35
const char * data
Description of a tone.
Definition: indications.h:52
A set of tones for a given locale.
Definition: indications.h:74
char country[MAX_TONEZONE_COUNTRY]
Country code that this set of tones is for.
Definition: indications.h:76
Structure for variables, used for configurations and for channel variables.
struct ast_variable * next
Definition: search.h:40
Global IO variables are now in a struct in order to be made threadsafe.
Definition: io.c:71
Number structure.
Definition: app_followme.c:154
Definition: sched.c:76
struct test_val * next
const char * name
A device containing one or more lines.
Definition: chan_unistim.c:394
char maintext2[25]
Definition: chan_unistim.c:416
char softkeyicon[FAVNUM]
Definition: chan_unistim.c:407
char softkeynumber[FAVNUM][AST_MAX_EXTENSION]
Definition: chan_unistim.c:406
signed char to_delete
Definition: chan_unistim.c:449
char redial_number[AST_MAX_EXTENSION]
Definition: chan_unistim.c:400
char maintext1[25]
Definition: chan_unistim.c:415
signed char ringvolume
Definition: chan_unistim.c:422
enum autoprov_extn extension
Definition: chan_unistim.c:447
char softkeylabel[FAVNUM][11]
Definition: chan_unistim.c:405
char expsoftkeylabel[EXPNUM][11]
Definition: chan_unistim.c:404
char titledefault[13]
Definition: chan_unistim.c:417
signed char cwvolume
Definition: chan_unistim.c:424
char context[AST_MAX_EXTENSION]
Definition: chan_unistim.c:398
struct unistim_subchannel * ssub[FAVNUM]
Definition: chan_unistim.c:409
struct ast_ha * ha
Definition: chan_unistim.c:453
struct unistim_device * sp[FAVNUM]
Definition: chan_unistim.c:411
char call_forward[AST_MAX_EXTENSION]
Definition: chan_unistim.c:438
char lst_cid[TEXT_LENGTH_MAX]
Definition: chan_unistim.c:436
struct ast_silence_generator * silence_generator
Definition: chan_unistim.c:450
struct unistim_device::@136 lines
struct unistim_line * sline[FAVNUM]
Definition: chan_unistim.c:410
time_t nextmsgcheck
Definition: chan_unistim.c:445
char name[DEVICE_NAME_LEN]
Definition: chan_unistim.c:402
char softkeydevice[FAVNUM][16]
Definition: chan_unistim.c:408
signed char cwstyle
Definition: chan_unistim.c:425
struct ast_tone_zone * tz
Definition: chan_unistim.c:421
char extension_number[11]
Definition: chan_unistim.c:448
struct unistimsession * session
Definition: chan_unistim.c:454
struct unistim_device * next
Definition: chan_unistim.c:455
struct unistim_device::@135 subs
signed char contrast
Definition: chan_unistim.c:419
ast_mutex_t lock
Definition: chan_unistim.c:395
char language[MAX_LANGUAGE]
Definition: chan_unistim.c:412
char lst_cnm[TEXT_LENGTH_MAX]
Definition: chan_unistim.c:437
signed char ringstyle
Definition: chan_unistim.c:423
char maintext0[25]
Definition: chan_unistim.c:414
char phone_number[AST_MAX_EXTENSION]
Definition: chan_unistim.c:399
struct ao2_container * trans
Definition: chan_unistim.c:492
struct unistim_line::@134 list
char fullname[101]
Definition: chan_unistim.c:375
struct unistim_line * next
Definition: chan_unistim.c:386
char cid_num[AST_MAX_EXTENSION]
Definition: chan_unistim.c:377
char name[80]
Definition: chan_unistim.c:374
char parkinglot[AST_MAX_CONTEXT]
Definition: chan_unistim.c:385
char exten[AST_MAX_EXTENSION]
Definition: chan_unistim.c:376
struct ast_format_cap * cap
Definition: chan_unistim.c:384
struct unistim_device * parent
Definition: chan_unistim.c:387
ast_group_t pickupgroup
Definition: chan_unistim.c:381
char musicclass[MAX_MUSICCLASS]
Definition: chan_unistim.c:379
char mailbox[AST_MAX_EXTENSION]
Definition: chan_unistim.c:378
ast_mutex_t lock
Definition: chan_unistim.c:373
char accountcode[AST_MAX_ACCOUNT_CODE]
Definition: chan_unistim.c:382
ast_group_t callgroup
Definition: chan_unistim.c:380
void(* handle_option)(struct unistimsession *)
Definition: chan_unistim.c:484
struct unistim_subchannel::@133 list
signed char ringvolume
Definition: chan_unistim.c:363
struct unistim_line * parent
Definition: chan_unistim.c:357
struct ast_rtp_instance * rtp
Definition: chan_unistim.c:358
struct ast_channel * owner
Definition: chan_unistim.c:356
unsigned int subtype
Definition: chan_unistim.c:355
ast_mutex_t lock
Definition: chan_unistim.c:354
signed char ringstyle
Definition: chan_unistim.c:364
unsigned char buf[MAX_BUF_NUMBER][MAX_BUF_SIZE]
Definition: chan_unistim.c:475
char buff_entry[16]
Definition: chan_unistim.c:471
unsigned short seq_phone
Definition: chan_unistim.c:463
struct wsabuf wsabufsend[MAX_BUF_NUMBER]
Definition: chan_unistim.c:474
unsigned short seq_server
Definition: chan_unistim.c:464
char macaddr[18]
Definition: chan_unistim.c:472
unsigned short last_seq_ack
Definition: chan_unistim.c:465
char firmware[8]
Definition: chan_unistim.c:473
struct sockaddr_in sout
Definition: chan_unistim.c:461
struct unistim_device * device
Definition: chan_unistim.c:476
unsigned long tick_next_ping
Definition: chan_unistim.c:466
struct sockaddr_in sin
Definition: chan_unistim.c:460
struct unistimsession * next
Definition: chan_unistim.c:477
ast_mutex_t lock
Definition: chan_unistim.c:459
Definition: chan_unistim.c:781
const char * str_trans
Definition: chan_unistim.c:783
const char * str_orig
Definition: chan_unistim.c:782
Definition: ast_expr2.c:325
unsigned char * buf
Definition: chan_unistim.c:350
u_long len
Definition: chan_unistim.c:349
static struct test_val b
static struct test_val a
static struct test_val d
static struct test_val c
struct timeval ast_tvnow(void)
Returns current timeval. Meant to replace calls to gettimeofday().
Definition: time.h:159
Handle unaligned data access.
static void put_unaligned_uint16(void *p, unsigned short datum)
Definition: unaligned.h:65
FILE * out
Definition: utils/frame.c:33
#define RAII_VAR(vartype, varname, initval, dtor)
Declare a variable that will call a destructor function when it goes out of scope.
Definition: utils.h:941
#define ast_pthread_create(a, b, c, d)
Definition: utils.h:584
int ast_mkdir(const char *path, int mode)
Recursively create directory path.
Definition: utils.c:2479
#define ARRAY_LEN(a)
Definition: utils.h:666